Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.
Go agentagenticaichatbotdsh-pluginembeddingsevaluationgenerative-aigolangknowledge-basellmmulti-tenantollamaopenaiquestion-answeringragrerankingsemantic-searchvector-searchwiki
fix(im): resolve resource URLs through bound storage backends (#4578)
lyingbuge6fd3fd3e2d4
diff --git a/internal/application/repository/resource.go b/internal/application/repository/resource.goindex 8a895c3bf..d3c0ad56f 100644--- a/internal/application/repository/resource.go+++ b/internal/application/repository/resource.go@@ -31,6 +31,19 @@ func (r *resourceRepository) GetByID(ctx context.Context, id string) (*types.Storeturn &resource, err}+func (r *resourceRepository) BindStorageBackend(+ ctx context.Context, id, backendID string,+) (*types.StoredResource, error) {+ err := r.db.WithContext(ctx).Model(&types.StoredResource{}).+ Where("id = ? AND state = ? AND (storage_backend_id = '' OR storage_backend_id IS NULL)",+ id, types.ResourceStateActive).+ Update("storage_backend_id", backendID).Error+ if err != nil {+ return nil, err+ }+ return r.GetByID(ctx, id)+}+func (r *resourceRepository) GetByHandle(ctx context.Context, handle string) (*types.StoredResource, error) {var resource types.StoredResourceerr := r.db.WithContext(ctx).diff --git a/internal/application/service/file/resource_catalog.go b/internal/application/service/file/resource_catalog.goindex dfaa0970d..ced19f8d6 100644--- a/internal/application/service/file/resource_catalog.go+++ b/internal/application/service/file/resource_catalog.go@@ -24,6 +24,20 @@ type resourceCatalogFileService struct {inner interfaces.FileServicecatalog interfaces.ResourceCatalogexternalURL string+ global bool+}++// NewGlobalResourceCatalogFileService pins writes to the process-wide driver's+// concrete instance, independently of workspace defaults and legacy aliases.+func NewGlobalResourceCatalogFileService(+ inner interfaces.FileService,+ catalog interfaces.ResourceCatalog,+) interfaces.FileService {+ svc := NewResourceCatalogFileService(inner, catalog)+ if wrapped, ok := svc.(*resourceCatalogFileService); ok {+ wrapped.global = true+ }+ return svc}// NewResourceCatalogFileService decorates a physical FileService with stable@@ -70,7 +84,16 @@ func (s *resourceCatalogFileService) register(contentHash string,) (string, error) {kind, mimeType := resourceKind(name)- ref, err := s.catalog.Register(ctx, tenantID, physical, interfaces.ResourceRegistration{+ register := s.catalog.Register+ if s.global {+ registrar, ok := s.catalog.(interfaces.GlobalResourceRegistrar)+ if !ok {+ _ = s.inner.DeleteFile(ctx, physical)+ return "", fmt.Errorf("global storage registration is unavailable")+ }+ register = registrar.RegisterGlobal+ }+ ref, err := register(ctx, tenantID, physical, interfaces.ResourceRegistration{Kind: kind,MimeType: mimeType,OriginalName: filepath.Base(name),diff --git a/internal/application/service/resource.go b/internal/application/service/resource.goindex 9f2a563f4..a32197aef 100644--- a/internal/application/service/resource.go+++ b/internal/application/service/resource.go@@ -21,7 +21,9 @@ import (const defaultResourceGrantTTL = 2 * time.Hourtype resourceCatalog struct {- repo interfaces.ResourceRepository+ repo interfaces.ResourceRepository+ storage interfaces.StorageBackendRepository+ globalStorage *types.StorageBackend}// NewResourceCatalog creates the stable resource-reference domain service.@@ -61,6 +63,11 @@ func (s *resourceCatalog) Register(return "", err}if existing != nil {+ if existing.StorageBackendID == "" && meta.StorageBackendID != "" {+ if _, err := s.repo.BindStorageBackend(ctx, existing.ID, meta.StorageBackendID); err != nil {+ return "", err+ }+ }return types.BuildResourcePath(existing.Handle), nil}@@ -69,6 +76,9 @@ func (s *resourceCatalog) Register(if scoped {providerPath = inner}+ if backendID == "" {+ backendID = meta.StorageBackendID+ }provider := types.ParseProviderScheme(providerPath)if provider == "" {return "", fmt.Errorf("resource physical path has unsupported provider scheme")@@ -103,6 +113,11 @@ func (s *resourceCatalog) Register(}existing, lookupErr := s.repo.GetByTenantLocation(ctx, tenantID, locationHash)if lookupErr == nil && existing != nil {+ if existing.StorageBackendID == "" && backendID != "" {+ if _, err := s.repo.BindStorageBackend(ctx, existing.ID, backendID); err != nil {+ return "", err+ }+ }return types.BuildResourcePath(existing.Handle), nil}}diff --git a/internal/application/service/resource_storage.go b/internal/application/service/resource_storage.gonew file mode 100644index 000000000..1a06641bd--- /dev/null+++ b/internal/application/service/resource_storage.go@@ -0,0 +1,191 @@+package service++import (+ "context"+ "fmt"+ "net/url"+ "strings"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/google/uuid"+)++// NewResourceCatalogWithStorage snapshots the same environment as initRawFileService.+// A later workspace-default change must not change the destination of global writes.+func NewResourceCatalogWithStorage(+ repo interfaces.ResourceRepository,+ storage interfaces.StorageBackendRepository,+) interfaces.ResourceCatalog {+ global := types.StorageBackendFromEnvironment(0)+ if global != nil {+ global.LegacyAlias = false+ switch global.Provider {+ case "local", "minio":+ // The process-wide drivers do not use the workspace path-prefix settings.+ global.Config.PathPrefix = ""+ case "s3", "oss", "obs":+ if global.Config.PathPrefix == "" {+ global.Config.PathPrefix = "weknora/"+ }+ }+ if global.Provider == "s3" {+ global.Config.ForcePathStyle = false // initRawFileService uses NewS3FileService.+ }+ }+ return &resourceCatalog{repo: repo, storage: storage, globalStorage: global}+}++func (s *resourceCatalog) globalBackendSnapshot(tenantID uint64) *types.StorageBackend {+ backend := *s.globalStorage+ backend.TenantID = tenantID+ // Credentials can rotate, but changing location creates a separate instance.+ // This is deliberately not a legacy alias: startup refreshes those in place.+ identity := fmt.Sprintf("global-storage:%d:%s:%t:%t:%s:%s", tenantID,+ backend.Config.LocationKey(backend.Provider), backend.Config.UseSSL, backend.Config.ForcePathStyle,+ backend.Config.TempBucketName, backend.Config.TempRegion)+ backend.ID = uuid.NewSHA1(uuid.NameSpaceOID, []byte(identity)).String()+ backend.Name = fmt.Sprintf("System %s files (%s)", strings.ToUpper(backend.Provider), backend.ID[:8])+ return &backend+}++func (s *resourceCatalog) globalBackend(ctx context.Context, tenantID uint64) (*types.StorageBackend, error) {+ if s.storage == nil || s.globalStorage == nil {+ return nil, fmt.Errorf("global storage instance is unavailable")+ }+ backend := s.globalBackendSnapshot(tenantID)+ existing, err := s.storage.GetByID(ctx, tenantID, backend.ID)+ if err != nil {+ return nil, err+ }+ if existing == nil {+ if err := s.storage.Create(ctx, backend); err != nil {+ // Concurrent first writes converge on the same instance.+ existing, lookupErr := s.storage.GetByID(ctx, tenantID, backend.ID)+ if lookupErr != nil || existing == nil || existing.Status != types.StorageBackendStatusActive {+ return nil, err+ }+ return existing, nil+ }+ return backend, nil+ }+ if existing.Status != types.StorageBackendStatusActive {+ return nil, fmt.Errorf("global storage instance is disabled")+ }+ if existing.Config != backend.Config {+ existing.Config = backend.Config+ if err := s.storage.Update(ctx, existing); err != nil {+ return nil, err+ }+ }+ return existing, nil+}++func (s *resourceCatalog) RegisterGlobal(+ ctx context.Context, tenantID uint64, physicalPath string, meta interfaces.ResourceRegistration,+) (string, error) {+ backend, err := s.globalBackend(ctx, tenantID)+ if err != nil {+ return "", err+ }+ if !resourceMatchesBackend(physicalPath, backend) {+ return "", fmt.Errorf("resource does not match the global storage instance")+ }+ meta.StorageBackendID = backend.ID+ return s.Register(ctx, tenantID, physicalPath, meta)+}++// ResolveStorageBinding backfills old unscoped resources conservatively. A+// provider alone never justifies using the workspace default or a legacy alias.+func (s *resourceCatalog) ResolveStorageBinding(+ ctx context.Context, reference string,+) (*types.StoredResource, error) {+ resource, err := s.Resolve(ctx, reference)+ if err != nil {+ return resource, err+ }+ if resource.StorageBackendID != "" {+ // Refresh rotated credentials only for the exact current global location.+ // Missing/disabled explicit instances are never recreated during reads.+ if s.globalStorage != nil && s.globalBackendSnapshot(resource.TenantID).ID == resource.StorageBackendID {+ backend, err := s.storage.GetByID(ctx, resource.TenantID, resource.StorageBackendID)+ if err != nil || backend == nil || backend.Status != types.StorageBackendStatusActive {+ return nil, fmt.Errorf("bound global storage instance is unavailable")+ }+ if _, err := s.globalBackend(ctx, resource.TenantID); err != nil {+ return nil, err+ }+ }+ return resource, nil+ }+ if backendID, _, ok := types.ParseStorageBackendPath(resource.PhysicalPath); ok {+ return s.repo.BindStorageBackend(ctx, resource.ID, backendID)+ }+ if s.storage == nil {+ return nil, fmt.Errorf("resource has no storage instance")+ }+ var global *types.StorageBackend+ if s.globalStorage != nil && resourceMatchesBackend(resource.PhysicalPath, s.globalStorage) {+ global, err = s.globalBackend(ctx, resource.TenantID)+ if err != nil {+ return nil, err+ }+ }+ backends, err := s.storage.List(ctx, resource.TenantID)+ if err != nil {+ return nil, err+ }+ var selected *types.StorageBackend+ for _, backend := range backends {+ if !resourceMatchesBackend(resource.PhysicalPath, backend) {+ continue+ }+ // Include disabled instances in ambiguity checks; they are not a reason+ // to silently select a different endpoint for an old path.+ if selected != nil && resourceBackendLocation(selected) != resourceBackendLocation(backend) {+ return nil, fmt.Errorf("resource storage instance is ambiguous")+ }+ if selected == nil || backend.ID < selected.ID {+ selected = backend+ }+ }+ if selected == nil || selected.Status != types.StorageBackendStatusActive {+ return nil, fmt.Errorf("resource storage instance is unavailable")+ }+ if global != nil {+ // Prefer the immutable-location snapshot over startup's mutable env alias.+ selected = global+ }+ return s.repo.BindStorageBackend(ctx, resource.ID, selected.ID)+}++func resourceMatchesBackend(physical string, backend *types.StorageBackend) bool {+ u, err := url.Parse(physical)+ if err != nil || u.Scheme != backend.Provider || u.RawQuery != "" || u.Fragment != "" {+ return false+ }+ if backend.Provider == "local" {+ // local:// paths omit the root/prefix, so different local roots are ambiguous.+ return true+ }+ if u.Host != backend.Config.BucketName &&+ (u.Host == "" || u.Host != backend.Config.TempBucketName) {+ return false+ }+ if backend.Provider == "cos" {+ region, _, _ := strings.Cut(strings.TrimPrefix(u.Path, "/"), "/")+ return region == backend.Config.Region ||+ (u.Host == backend.Config.TempBucketName && region == backend.Config.TempRegion)+ }+ return true+}++func resourceBackendLocation(backend *types.StorageBackend) string {+ c := backend.Config+ if backend.Provider != "local" {+ // Object paths already include the key prefix; it does not affect reads.+ c.PathPrefix = ""+ }+ return fmt.Sprintf("%s|%t|%t|%s|%s", c.LocationKey(backend.Provider),+ c.UseSSL, c.ForcePathStyle, c.TempBucketName, c.TempRegion)+}diff --git a/internal/application/service/resource_storage_test.go b/internal/application/service/resource_storage_test.gonew file mode 100644index 000000000..166d42b05--- /dev/null+++ b/internal/application/service/resource_storage_test.go@@ -0,0 +1,134 @@+package service++import (+ "context"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/repository"+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++func TestGlobalResourceBindingSurvivesCredentialAndLocationChanges(t *testing.T) {+ for name, value := range map[string]string{+ "STORAGE_TYPE": "oss", "OSS_ENDPOINT": "https://oss.example", "OSS_REGION": "region",+ "OSS_BUCKET_NAME": "first-bucket", "OSS_ACCESS_KEY": "first-key", "OSS_SECRET_KEY": "secret",+ "OSS_PATH_PREFIX": "", "OSS_TEMP_BUCKET_NAME": "", "OSS_TEMP_REGION": "",+ } {+ t.Setenv(name, value)+ }+ _, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.StorageBackend{}))+ resources := repository.NewResourceRepository(db)+ storage := repository.NewStorageBackendRepository(db)+ newCatalog := func() *resourceCatalog {+ return NewResourceCatalogWithStorage(resources, storage).(*resourceCatalog)+ }+ ctx := context.Background()+ catalog := newCatalog()+ first, err := catalog.RegisterGlobal(ctx, 7,+ "oss://first-bucket/7/exports/a.png", interfaces.ResourceRegistration{})+ require.NoError(t, err)+ resource, err := catalog.ResolveStorageBinding(ctx, first)+ require.NoError(t, err)+ firstID := resource.StorageBackendID+ require.NotEmpty(t, firstID)++ t.Setenv("OSS_ACCESS_KEY", "rotated-key")+ catalog = newCatalog()+ resource, err = catalog.ResolveStorageBinding(ctx, first)+ require.NoError(t, err)+ require.Equal(t, firstID, resource.StorageBackendID)+ backend, err := storage.GetByID(ctx, 7, firstID)+ require.NoError(t, err)+ require.Equal(t, "rotated-key", backend.Config.AccessKeyID)+ require.False(t, backend.LegacyAlias)+ require.Equal(t, types.StorageBackendSourceEnv, backend.Source)++ t.Setenv("OSS_BUCKET_NAME", "second-bucket")+ catalog = newCatalog()+ second, err := catalog.RegisterGlobal(ctx, 7,+ "oss://second-bucket/7/exports/b.png", interfaces.ResourceRegistration{})+ require.NoError(t, err)+ resource, err = catalog.ResolveStorageBinding(ctx, second)+ require.NoError(t, err)+ require.NotEqual(t, firstID, resource.StorageBackendID)+ resource, err = catalog.ResolveStorageBinding(ctx, first)+ require.NoError(t, err)+ require.Equal(t, firstID, resource.StorageBackendID)+ backend, err = storage.GetByID(ctx, 7, firstID)+ require.NoError(t, err)+ require.Equal(t, "first-bucket", backend.Config.BucketName)+}++func TestBoundGlobalResourceDoesNotRecreateMissingOrDisabledInstance(t *testing.T) {+ for _, state := range []string{"disabled", "deleted"} {+ t.Run(state, func(t *testing.T) {+ t.Setenv("STORAGE_TYPE", "local")+ _, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.StorageBackend{}))+ storage := repository.NewStorageBackendRepository(db)+ catalog := NewResourceCatalogWithStorage(repository.NewResourceRepository(db), storage).(*resourceCatalog)+ ctx := context.Background()+ ref, err := catalog.RegisterGlobal(ctx, 7, "local://7/exports/a.png", interfaces.ResourceRegistration{})+ require.NoError(t, err)+ resource, err := catalog.Resolve(ctx, ref)+ require.NoError(t, err)+ if state == "disabled" {+ require.NoError(t, db.Model(&types.StorageBackend{}).Where("id = ?", resource.StorageBackendID).+ Update("status", types.StorageBackendStatusDisabled).Error)+ } else {+ require.NoError(t, storage.Delete(ctx, 7, resource.StorageBackendID))+ }+ _, err = catalog.ResolveStorageBinding(ctx, ref)+ require.Error(t, err)+ stored, err := catalog.Resolve(ctx, ref)+ require.NoError(t, err)+ require.Equal(t, resource.StorageBackendID, stored.StorageBackendID)+ })+ }+}++func TestGlobalLocalWritesIgnoreWorkspacePathPrefix(t *testing.T) {+ t.Setenv("STORAGE_TYPE", "local")+ t.Setenv("LOCAL_STORAGE_PATH_PREFIX", "workspace-only")+ _, db := newResourceCatalogForTest(t)+ require.NoError(t, db.AutoMigrate(&types.StorageBackend{}))+ storage := repository.NewStorageBackendRepository(db)+ catalog := NewResourceCatalogWithStorage(repository.NewResourceRepository(db), storage)+ baseDir := t.TempDir()+ writer := filesvc.NewGlobalResourceCatalogFileService(filesvc.NewLocalFileService(baseDir, ""), catalog)+ ctx := context.Background()+ ref, err := writer.SaveBytes(ctx, []byte("artifact"), 7, "a.txt", false)+ require.NoError(t, err)+ resource, err := catalog.Resolve(ctx, ref)+ require.NoError(t, err)+ backend, err := storage.GetByID(ctx, 7, resource.StorageBackendID)+ require.NoError(t, err)+ require.NotNil(t, backend)+ require.Empty(t, backend.Config.PathPrefix)+ reader, _, err := NewStorageBackendService(storage, nil, catalog).+ ResolveFileService(ctx, &types.Tenant{ID: 7}, backend.ID, "local", baseDir)+ require.NoError(t, err)+ file, err := reader.GetFile(ctx, ref)+ require.NoError(t, err)+ require.NoError(t, file.Close())+}++func TestLegacyResourceBindingNeverOverwritesExistingBinding(t *testing.T) {+ catalog, db := newResourceCatalogForTest(t)+ ctx := context.Background()+ ref, err := catalog.Register(ctx, 7, "oss://bucket/7/exports/a.png", interfaces.ResourceRegistration{})+ require.NoError(t, err)+ resource, err := catalog.Resolve(ctx, ref)+ require.NoError(t, err)+ repo := repository.NewResourceRepository(db)+ bound, err := repo.BindStorageBackend(ctx, resource.ID, "actual-instance")+ require.NoError(t, err)+ require.Equal(t, "actual-instance", bound.StorageBackendID)+ bound, err = repo.BindStorageBackend(ctx, resource.ID, "stale-candidate")+ require.NoError(t, err)+ require.Equal(t, "actual-instance", bound.StorageBackendID)+}diff --git a/internal/container/container.go b/internal/container/container.goindex 81f775f38..50493e5b4 100644--- a/internal/container/container.go+++ b/internal/container/container.go@@ -322,7 +322,7 @@ func BuildContainer(container *dig.Container) *dig.Container {must(container.Provide(repository.NewStorageBackendRepository))must(container.Provide(repository.NewResourceRepository))must(container.Provide(repository.NewTemporaryDocumentRepository))- must(container.Provide(service.NewResourceCatalog))+ must(container.Provide(service.NewResourceCatalogWithStorage))// TenantStoreOwnership adapter used by the retriever factory functions// to verify that a resolved VectorStore belongs to the caller's tenant.must(container.Provide(retriever.NewVectorStoreRepoOwnership))@@ -1338,7 +1338,10 @@ func initFileService(cfg *config.Config, catalog interfaces.ResourceCatalog) (inif err != nil {return nil, err}- return file.NewResourceCatalogFileService(inner, catalog), nil+ if _, dummy := inner.(*file.DummyFileService); dummy {+ return file.NewResourceCatalogFileService(inner, catalog), nil+ }+ return file.NewGlobalResourceCatalogFileService(inner, catalog), nil}func initRawFileService(_ *config.Config) (interfaces.FileService, error) {diff --git a/internal/im/content_rewrite_test.go b/internal/im/content_rewrite_test.goindex d5135fec8..70376865b 100644--- a/internal/im/content_rewrite_test.go+++ b/internal/im/content_rewrite_test.go@@ -373,7 +373,7 @@ func TestCleanIMContent_AfterStreamReassembly(t *testing.T) {sent, rem := simulateIMStreamFlush(parts)require.Empty(t, rem)joined := strings.Join(sent, "")- out := cleanIMContent(context.Background(), joined, tenant, nil)+ out := cleanIMContent(context.Background(), joined, newIMFileServiceResolver(tenant, nil))assert.Contains(t, out, "/api/v1/files/presigned")assert.NotContains(t, out, "local://10000")}diff --git a/internal/im/full_output_test.go b/internal/im/full_output_test.goindex 12b44c839..d8cba3bde 100644--- a/internal/im/full_output_test.go+++ b/internal/im/full_output_test.go@@ -362,7 +362,7 @@ func TestExecuteQARequestFullOutputSkipsProgressWhenNotSupported(t *testing.T) {func TestFormatIMOutboundAnswerOrFallbackAfterCleanup(t *testing.T) {got := formatIMOutboundAnswerOrFallback(- context.Background(), "<think>only reasoning</think>", nil, nil,+ context.Background(), "<think>only reasoning</think>", nil,)if got != imNoAnswerFallback {t.Fatalf("think-only final content = %q, want fallback %q", got, imNoAnswerFallback)diff --git a/internal/im/global_resource_storage_test.go b/internal/im/global_resource_storage_test.gonew file mode 100644index 000000000..2f1d7f780--- /dev/null+++ b/internal/im/global_resource_storage_test.go@@ -0,0 +1,121 @@+package im++import (+ "fmt"+ "net/url"+ "strings"+ "testing"++ "github.com/Tencent/WeKnora/internal/application/repository"+ appsvc "github.com/Tencent/WeKnora/internal/application/service"+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++func configureIMGlobalOSS(t *testing.T, f *imResourceStorageFixture) interfaces.FileService {+ t.Helper()+ for name, value := range map[string]string{+ "STORAGE_TYPE": "oss", "OSS_ENDPOINT": f.baseURL, "OSS_REGION": "cn-hangzhou",+ "OSS_BUCKET_NAME": "global-artifacts", "OSS_ACCESS_KEY": "global-key", "OSS_SECRET_KEY": "test-secret",+ "OSS_PATH_PREFIX": "", "OSS_TEMP_BUCKET_NAME": "", "OSS_TEMP_REGION": "",+ } {+ t.Setenv(name, value)+ }+ repo := repository.NewStorageBackendRepository(f.db)+ f.catalog = appsvc.NewResourceCatalogWithStorage(repository.NewResourceRepository(f.db), repo)+ f.storage = appsvc.NewStorageBackendService(repo, f.db, f.catalog)+ driver, err := filesvc.NewOssFileService(f.baseURL, "cn-hangzhou", "global-key", "test-secret",+ "global-artifacts", "weknora/")+ require.NoError(t, err)+ f.global = filesvc.NewGlobalResourceCatalogFileService(driver, f.catalog)+ return driver+}++func TestIMGlobalResourcesKeepTheirActualStorage(t *testing.T) {+ for _, workspaceProvider := range []string{"local", "oss"} {+ for _, origin := range []string{"artifact", "temporary document", "legacy artifact"} {+ t.Run(workspaceProvider+"/"+origin, func(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ driver := configureIMGlobalOSS(t, f)+ backend := &types.StorageBackend{+ ID: "workspace-default", TenantID: 7, Name: "Workspace default", Provider: workspaceProvider,+ LegacyAlias: true,+ Config: types.StorageBackendConfig{+ Endpoint: f.baseURL, Region: "cn-hangzhou", BucketName: "workspace-bucket",+ AccessKeyID: "workspace-key", SecretAccessKey: "workspace-secret",+ },+ }+ require.NoError(t, repository.NewStorageBackendRepository(f.db).Create(f.context(), backend))+ require.NoError(t, f.db.Model(&types.Tenant{}).Where("id = ?", 7).+ Update("default_storage_backend_id", backend.ID).Error)+ writer := f.global+ if origin == "legacy artifact" {+ writer = filesvc.NewResourceCatalogFileService(driver, f.catalog)+ }+ ref, err := writer.SaveBytes(f.context(), []byte("generated content"), 7, "report.png",+ origin == "temporary document")+ require.NoError(t, err)+ resource, err := f.catalog.Resolve(f.context(), ref)+ require.NoError(t, err)+ if origin == "legacy artifact" {+ require.Empty(t, resource.StorageBackendID)+ } else {+ require.NotEmpty(t, resource.StorageBackendID, "new writes must record the actual instance")+ }+ s, _, _, _ := newFullOutputHarness("")+ f.wire(s)+ content := ""+ check := func() {+ out := cleanIMContent(f.context(), content, s.newOutboundFileServiceResolver(f.tenant, nil, nil))+ require.NotContains(t, out, "resource://")+ u, err := url.Parse(strings.TrimSuffix(strings.TrimPrefix(out, ", ")"))+ require.NoError(t, err)+ require.Contains(t, u.Path, "global-artifacts/weknora/7/exports/")+ require.Contains(t, u.Query().Get("x-oss-credential"), "global-key/")+ require.NotEmpty(t, u.Query().Get("x-oss-signature"))+ }+ check()+ resource, err = f.catalog.Resolve(f.context(), ref)+ require.NoError(t, err)+ require.NotEmpty(t, resource.StorageBackendID, "legacy resources acquire a concrete binding")+ require.NotEqual(t, backend.ID, resource.StorageBackendID)++ // Simulate a restart with a different process-wide driver. The prior+ // file must retain the instance that actually stores its bytes.+ t.Setenv("STORAGE_TYPE", "local")+ repo := repository.NewStorageBackendRepository(f.db)+ f.catalog = appsvc.NewResourceCatalogWithStorage(repository.NewResourceRepository(f.db), repo)+ f.storage = appsvc.NewStorageBackendService(repo, f.db, f.catalog)+ f.global = filesvc.NewGlobalResourceCatalogFileService(+ filesvc.NewLocalFileService(t.TempDir(), ""), f.catalog)+ f.wire(s)+ check()+ })+ }+ }+}++func TestIMLegacyResourceDoesNotGuessBetweenEndpoints(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ driver := configureIMGlobalOSS(t, f)+ legacy := filesvc.NewResourceCatalogFileService(driver, f.catalog)+ ref, err := legacy.SaveBytes(f.context(), []byte("legacy content"), 7, "image.png", false)+ require.NoError(t, err)+ require.NoError(t, f.db.Create(&types.StorageBackend{+ ID: "ambiguous", TenantID: 7, Name: "Same bucket elsewhere", Provider: "oss",+ Config: types.StorageBackendConfig{+ Endpoint: "https://another.example", Region: "cn-hangzhou", BucketName: "global-artifacts",+ AccessKeyID: "different-key", SecretAccessKey: "different-secret",+ },+ }).Error)+ s, _, _, _ := newFullOutputHarness("")+ f.wire(s)+ content := fmt.Sprintf("", ref)+ out := cleanIMContent(f.context(), content, s.newOutboundFileServiceResolver(f.tenant, nil, nil))+ require.Equal(t, content, out)+ resource, err := f.catalog.Resolve(f.context(), ref)+ require.NoError(t, err)+ require.Empty(t, resource.StorageBackendID)+}diff --git a/internal/im/im_file_service_test.go b/internal/im/im_file_service_test.goindex aaae77d44..2ef565260 100644--- a/internal/im/im_file_service_test.go+++ b/internal/im/im_file_service_test.go@@ -111,16 +111,16 @@ func TestRewriteStorageURLs_MinIOFallbackViaGlobal(t *testing.T) {assert.NotContains(t, out, "](minio://")}-func TestRewriteStorageURLs_ScopedPath(t *testing.T) {+func TestRewriteStorageURLs_ScopedPathRequiresBoundBackend(t *testing.T) {stub := &stubIMFileService{getFileURL: func(_ context.Context, filePath string) (string, error) {- assert.Equal(t, "storage://backend-a/cos://bucket/ap-test/10000/exports/a.png", filePath)- return "https://storage.example/a.png", nil+ t.Fatal("an explicit backend must not fall back to global storage")+ return "", nil},}input := ""output := rewriteStorageURLs(context.Background(), input, newIMFileServiceResolver(&types.Tenant{}, stub))- assert.Contains(t, output, "https://storage.example/a.png")+ assert.Equal(t, input, output)}// When GetFileURL resolves a resource:// alias to a still-internal storage://@@ -163,6 +163,6 @@ func TestCleanIMContent_MinIOFallbackIntegration(t *testing.T) {StorageEngineConfig: &types.StorageEngineConfig{DefaultProvider: "cos"},}in := "see  ok"- out := cleanIMContent(context.Background(), in, tenant, stub)+ out := cleanIMContent(context.Background(), in, newIMFileServiceResolver(tenant, stub))assert.Contains(t, out, "https://minio.example/img.png")}diff --git a/internal/im/resource_access.go b/internal/im/resource_access.gonew file mode 100644index 000000000..972fb7d8c--- /dev/null+++ b/internal/im/resource_access.go@@ -0,0 +1,93 @@+package im++import (+ "context"+ "slices"++ "github.com/Tencent/WeKnora/internal/application/access"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ secutils "github.com/Tencent/WeKnora/internal/utils"+)++// authorizeOutboundResource checks actual file ownership and live KB sharing.+// An answer can echo a user-supplied handle; appearing in that answer never+// grants access to another workspace's storage credentials.+func (s *Service) authorizeOutboundResource(+ ctx context.Context,+ tenant *types.Tenant,+ agent *types.CustomAgent,+ kbIDs []string,+ reference string,+) error {+ if tenant == nil || tenant.ID == 0 || s.resourceCatalog == nil {+ return access.ErrUnauthorized+ }+ caller := types.CallerFromContext(ctx)+ if caller.TenantID != tenant.ID {+ return access.ErrUnauthorized+ }+ physical, resource, err := s.resourceCatalog.ResolvePath(ctx, reference)+ if err != nil {+ return err+ }+ owner := secutils.ParseTenantIDFromStoragePath(physical)+ if resource != nil {+ owner = resource.TenantID+ }+ if owner == 0 {+ return access.ErrForbidden+ }+ if owner == tenant.ID {+ return secutils.ValidateStoragePathTenant(physical, owner)+ }+ bindings, ok := s.resourceCatalog.(interface {+ interfaces.KBResourceLookup+ interfaces.MessageFileBindingLookup+ })+ if !ok || s.kbService == nil || s.kbShareService == nil {+ return access.ErrForbidden+ }+ origins, err := bindings.GetMessageFileBindings(ctx, owner, reference, "")+ if err != nil {+ return err+ }+ if origins == nil {+ return access.ErrForbidden+ }+ for _, kbID := range origins.KnowledgeBaseIDs {+ if !outboundKBInScope(agent, kbIDs, kbID) {+ continue+ }+ kb, err := s.kbService.GetKnowledgeBaseByIDOnly(ctx, kbID)+ if err != nil || kb == nil || kb.TenantID != owner {+ continue+ }+ grant, err := access.ResolveKB(ctx, access.KBRequest{Caller: caller}, kb,+ types.OrgRoleViewer, s.kbShareService, nil)+ if err != nil {+ continue+ }+ if _, err := access.ResolveKBFile(ctx, grant, kbID, reference, s.resourceCatalog, bindings); err == nil {+ return nil+ }+ }+ return access.ErrForbidden+}++func outboundKBInScope(agent *types.CustomAgent, kbIDs []string, kbID string) bool {+ if len(kbIDs) != 0 {+ return slices.Contains(kbIDs, kbID)+ }+ if agent == nil {+ return true+ }+ switch agent.Config.KBSelectionMode {+ case "all":+ return true+ case "none":+ return false+ default:+ return slices.Contains(agent.Config.KnowledgeBases, kbID)+ }+}diff --git a/internal/im/resource_access_test.go b/internal/im/resource_access_test.gonew file mode 100644index 000000000..53f882dd0--- /dev/null+++ b/internal/im/resource_access_test.go@@ -0,0 +1,102 @@+package im++import (+ "context"+ "errors"+ "testing"++ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++type failingIMResourceCatalog struct{ interfaces.ResourceCatalog }++func (s failingIMResourceCatalog) ResolvePath(context.Context, string) (string, *types.StoredResource, error) {+ return "", nil, errors.New("catalog unavailable")+}++type failingIMShareService struct{ interfaces.KBShareService }++func (s failingIMShareService) CheckTenantKBPermission(+ context.Context, string, uint64, types.TenantRole,+) (types.OrgMemberRole, bool, error) {+ return "", false, errors.New("sharing unavailable")+}++func TestIMResourceAccessFailsClosed(t *testing.T) {+ cases := []string{+ "unshared", "binding missing", "knowledge deleted", "borrower removed", "owner removed",+ "organization deleted", "catalog failure", "sharing failure", "missing identity",+ "other selected KB", "no KBs", "explicit KB restriction",+ }+ for _, externalURL := range []string{"", "https://weknora.example"} {+ for _, scenario := range cases {+ t.Run(scenario+externalURL, func(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ t.Setenv("APP_EXTERNAL_URL", externalURL)+ s, _, _, _ := newFullOutputHarness("")+ f.wire(s)+ ctx := f.context()+ var agent *types.CustomAgent+ var kbIDs []string+ switch scenario {+ case "unshared":+ require.NoError(t, f.db.Where("id = ?", "share").Delete(&types.KnowledgeBaseShare{}).Error)+ case "binding missing":+ require.NoError(t, f.db.Where("owner_id = ?", "shared-doc").Delete(&types.ResourceBinding{}).Error)+ case "knowledge deleted":+ require.NoError(t, f.db.Where("id = ?", "shared-doc").Delete(&types.Knowledge{}).Error)+ case "borrower removed", "owner removed":+ id := uint64(7)+ if scenario == "owner removed" {+ id = 9+ }+ require.NoError(t, f.db.Where("tenant_id = ?", id).Delete(&types.OrganizationTenantMember{}).Error)+ case "organization deleted":+ require.NoError(t, f.db.Where("id = ?", "org").Delete(&types.Organization{}).Error)+ case "catalog failure":+ s.resourceCatalog = failingIMResourceCatalog{ResourceCatalog: f.catalog}+ case "sharing failure":+ s.kbShareService = failingIMShareService{}+ case "missing identity":+ ctx = context.Background()+ case "other selected KB":+ agent = &types.CustomAgent{Config: types.CustomAgentConfig{+ KBSelectionMode: "selected", KnowledgeBases: []string{"other-kb"},+ }}+ case "no KBs":+ agent = &types.CustomAgent{Config: types.CustomAgentConfig{KBSelectionMode: "none"}}+ case "explicit KB restriction":+ kbIDs = []string{"other-kb"}+ }+ resource, err := f.catalog.Resolve(ctx, f.refs[2])+ require.NoError(t, err)+ for _, reference := range []string{f.refs[2], resource.PhysicalPath} {+ content := ""+ out := cleanIMContent(ctx, content, s.newOutboundFileServiceResolver(f.tenant, agent, kbIDs))+ require.Equal(t, content, out, "an answer mentioning a resource cannot authorize access")+ }+ var grants int64+ require.NoError(t, f.db.Model(&types.ResourceAccessGrant{}).Count(&grants).Error)+ require.Zero(t, grants, "denied resources must not mint short-link capabilities")+ })+ }+ }+}++func TestIMResourceAccessRechecksSharingWithCachedStorage(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ s, _, _, _ := newFullOutputHarness("")+ f.wire(s)+ agent := &types.CustomAgent{Config: types.CustomAgentConfig{+ KBSelectionMode: "selected", KnowledgeBases: []string{"shared-kb"},+ }}+ resolver := s.newOutboundFileServiceResolver(f.tenant, agent, nil)+ content := ""+ first := cleanIMContent(f.context(), content, resolver)+ require.Contains(t, first, "x-oss-signature=")+ require.NoError(t, f.db.Where("id = ?", "share").Delete(&types.KnowledgeBaseShare{}).Error)+ require.Equal(t, content, cleanIMContent(f.context(), content, resolver),+ "a cached storage client must not bypass a revoked share on the next stream update")+}diff --git a/internal/im/resource_storage_test.go b/internal/im/resource_storage_test.gonew file mode 100644index 000000000..902fbb398--- /dev/null+++ b/internal/im/resource_storage_test.go@@ -0,0 +1,297 @@+package im++import (+ "context"+ "errors"+ "fmt"+ "net/http"+ "net/http/httptest"+ "net/url"+ "regexp"+ "strings"+ "sync"+ "testing"+ "time"++ "github.com/Tencent/WeKnora/internal/application/repository"+ appsvc "github.com/Tencent/WeKnora/internal/application/service"+ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"+ "github.com/Tencent/WeKnora/internal/event"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+ "gorm.io/driver/sqlite"+ "gorm.io/gorm"+ "gorm.io/gorm/logger"+)++// Use the real catalog, backend repository, resolver and OSS signer. Only the+// storage HTTP server and IM delivery are local stand-ins; no cloud account or+// platform credentials are needed to verify which instance signs each image.+type imResourceStorageFixture struct {+ db *gorm.DB+ catalog interfaces.ResourceCatalog+ storage interfaces.StorageBackendResolver+ tenants interfaces.TenantService+ shares interfaces.KBShareService+ global interfaces.FileService+ tenant *types.Tenant+ answer string+ refs []string+ baseURL string+}++func newIMResourceStorageFixture(t *testing.T) *imResourceStorageFixture {+ t.Helper()+ t.Setenv("STORAGE_TYPE", "local")+ t.Setenv("APP_EXTERNAL_URL", "")+ t.Setenv("SSRF_WHITELIST", "127.0.0.1")+ server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ if r.Method != http.MethodHead && r.Method != http.MethodPut {+ w.WriteHeader(http.StatusMethodNotAllowed)+ return+ }+ w.WriteHeader(http.StatusOK)+ }))+ t.Cleanup(server.Close)+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})+ require.NoError(t, err)+ sqlDB, err := db.DB()+ require.NoError(t, err)+ sqlDB.SetMaxOpenConns(1)+ t.Cleanup(func() { require.NoError(t, sqlDB.Close()) })+ require.NoError(t, db.AutoMigrate(+ &types.Tenant{}, &types.StorageBackend{}, &types.StoredResource{},+ &types.ResourceBinding{}, &types.ResourceAccessGrant{},+ &types.KnowledgeBase{}, &types.Knowledge{}, &types.Organization{},+ &types.OrganizationTenantMember{}, &types.KnowledgeBaseShare{},+ ))+ for _, id := range []uint64{7, 9} {+ require.NoError(t, db.Create(&types.Tenant{ID: id, Name: fmt.Sprintf("Workspace %d", id)}).Error)+ }+ storageRepo := repository.NewStorageBackendRepository(db)+ catalog := appsvc.NewResourceCatalog(repository.NewResourceRepository(db))+ f := &imResourceStorageFixture{+ db: db, catalog: catalog, storage: appsvc.NewStorageBackendService(storageRepo, db, catalog),+ tenants: appsvc.NewTenantService(repository.NewTenantRepository(db), storageRepo),+ global: filesvc.NewResourceCatalogFileService(filesvc.NewLocalFileService(t.TempDir(), ""), catalog),+ tenant: &types.Tenant{ID: 7}, baseURL: server.URL,+ }+ f.shares = appsvc.NewKBShareService(repository.NewKBShareRepository(db),+ repository.NewOrganizationRepository(db), repository.NewKnowledgeBaseRepository(db), nil, nil, nil)+ require.NoError(t, db.Create(&types.Organization{ID: "org", Name: "Shared workspace", OwnerTenantID: 9}).Error)+ for _, id := range []uint64{7, 9} {+ require.NoError(t, db.Create(&types.OrganizationTenantMember{+ ID: fmt.Sprintf("member-%d", id), OrganizationID: "org", TenantID: id, Role: types.OrgRoleViewer,+ }).Error)+ }+ require.NoError(t, db.Create(&types.KnowledgeBase{ID: "shared-kb", TenantID: 9, Name: "Shared KB"}).Error)+ require.NoError(t, db.Create(&types.Knowledge{ID: "shared-doc", TenantID: 9, KnowledgeBaseID: "shared-kb"}).Error)+ require.NoError(t, db.Create(&types.KnowledgeBaseShare{+ ID: "share", KnowledgeBaseID: "shared-kb", OrganizationID: "org",+ SourceTenantID: 9, Permission: types.OrgRoleViewer,+ }).Error)+ for i, owner := range []uint64{7, 7, 9} {+ backend := &types.StorageBackend{+ ID: fmt.Sprintf("oss-%d", i), TenantID: owner, Name: fmt.Sprintf("OSS %d", i), Provider: "oss",+ Config: types.StorageBackendConfig{+ Endpoint: server.URL, Region: "cn-hangzhou", BucketName: fmt.Sprintf("bucket-%d", i),+ AccessKeyID: fmt.Sprintf("instance-key-%d", i), SecretAccessKey: "test-only-secret",+ },+ }+ require.NoError(t, storageRepo.Create(context.Background(), backend))+ physical := fmt.Sprintf("storage://%s/oss://bucket-%d/%d/exports/image.png", backend.ID, i, owner)+ ref, err := catalog.Register(context.Background(), owner, physical,+ interfaces.ResourceRegistration{Kind: "image", OriginalName: "image.png"})+ require.NoError(t, err)+ if owner == 9 {+ require.NoError(t, catalog.Bind(context.Background(), ref,+ types.ResourceOwnerKnowledge, "shared-doc", types.ResourceRelationExtractedImage))+ }+ f.refs = append(f.refs, ref)+ f.answer += fmt.Sprintf("\n", i, ref)+ }+ return f+}++func (f *imResourceStorageFixture) wire(s *Service) {+ s.defaultFileSvc = f.global+ s.resourceCatalog = f.catalog+ s.storageResolver = f.storage+ s.tenantService = f.tenants+ s.kbService = &resourceKBLookup{db: f.db}+ s.kbShareService = f.shares+}++type resourceKBLookup struct {+ interfaces.KnowledgeBaseService+ db *gorm.DB+}++func (s *resourceKBLookup) GetKnowledgeBaseByIDOnly(ctx context.Context, id string) (*types.KnowledgeBase, error) {+ var kb types.KnowledgeBase+ if err := s.db.WithContext(ctx).Where("id = ?", id).First(&kb).Error; err != nil {+ return nil, err+ }+ return &kb, nil+}++func (f *imResourceStorageFixture) context() context.Context {+ return withIMIdentity(context.Background(), &IMChannel{TenantID: f.tenant.ID},+ &IncomingMessage{Platform: PlatformWeCom, UserID: "test-user"})+}++func (f *imResourceStorageFixture) checkSignedImages(t *testing.T, content string) {+ t.Helper()+ require.NotContains(t, content, "resource://")+ images := regexp.MustCompile(`!\[[^\]]*\]\(([^)]+)\)`).FindAllStringSubmatch(content, -1)+ require.Len(t, images, 3)+ for i, match := range images {+ u, err := url.Parse(match[1])+ require.NoError(t, err)+ require.Equal(t, strings.TrimPrefix(f.baseURL, "http://"), u.Host)+ require.Contains(t, u.Path, fmt.Sprintf("bucket-%d/", i))+ require.Contains(t, u.Query().Get("x-oss-credential"), fmt.Sprintf("instance-key-%d/", i))+ require.NotEmpty(t, u.Query().Get("x-oss-signature"))+ }+}++func TestIMDeliveryUsesResourceStorageAcrossPlatformsAndModes(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ checkIMDeliveryModes(t, f, f.checkSignedImages)+}++func TestIMDeliveryDoesNotSignUnsharedResourcesAcrossPlatformsAndModes(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ require.NoError(t, f.db.Where("id = ?", "share").Delete(&types.KnowledgeBaseShare{}).Error)+ f.answer = ""+ checkIMDeliveryModes(t, f, func(t *testing.T, content string) {+ require.Equal(t, f.answer, content)+ })+}++func checkIMDeliveryModes(t *testing.T, f *imResourceStorageFixture, check func(*testing.T, string)) {+ t.Helper()+ platforms := []Platform{+ PlatformWeCom, PlatformFeishu, PlatformLark, PlatformDingtalk,+ PlatformSlack, PlatformTelegram, PlatformMattermost, PlatformWeChat, PlatformQQBot, PlatformYunzhijia,+ }+ modes := []string{"stream", "full", "full without progress", "stream start failure", "stream finalize failure"}+ for _, platform := range platforms {+ for _, mode := range modes {+ t.Run(string(platform)+"/"+mode, func(t *testing.T) {+ s, adapter, _, _ := newFullOutputHarness(f.answer)+ f.wire(s)+ messages := &deliveryMessageService{}+ s.messageService = messages+ channel := &IMChannel{OutputMode: "stream"}+ var sender Adapter = adapter+ switch mode {+ case "full":+ channel.OutputMode = "full"+ case "full without progress":+ channel.OutputMode = "full"+ sender = &fullOutputNoProgressAdapter{fullOutputAdapter: adapter}+ case "stream start failure":+ adapter.startErr = errors.New("stream unavailable")+ case "stream finalize failure":+ adapter.finalizeErr = errors.New("update failed")+ }+ ctx, cancel := context.WithCancel(f.context())+ defer cancel()+ s.executeQARequest(&qaRequest{+ ctx: ctx, cancel: cancel, tenant: f.tenant, channel: channel, adapter: sender,+ msg: &IncomingMessage{Platform: platform, UserID: "test-user", Content: "Show the images"},+ session: &types.Session{ID: "test-session"}, userKey: "test-user",+ })+ content := adapter.finalContent+ if adapter.plainReplies > 0 {+ content = adapter.plainContent+ }+ check(t, content)+ require.NotNil(t, messages.saved)+ require.Equal(t, strings.TrimSpace(f.answer), strings.TrimSpace(messages.saved.Content),+ "persist stable references, not signed URLs")+ })+ }+ }+}++func TestIMResourceStoragePreservesShortLinksAndRejectsUnavailableInstances(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ s, _, _, _ := newFullOutputHarness(f.answer)+ f.wire(s)+ ctx := f.context()+ t.Setenv("APP_EXTERNAL_URL", "https://weknora.example")+ out := cleanIMContent(ctx, f.answer, s.newOutboundFileServiceResolver(f.tenant, nil, nil))+ require.Equal(t, 3, strings.Count(out, "https://weknora.example/r/"))+ require.NotContains(t, out, "resource://")++ t.Setenv("APP_EXTERNAL_URL", "")+ require.NoError(t, f.db.Model(&types.StorageBackend{}).Where("id = ?", "oss-0").+ Update("status", types.StorageBackendStatusDisabled).Error)+ require.NoError(t, f.db.Where("id = ?", "oss-1").Delete(&types.StorageBackend{}).Error)+ out = cleanIMContent(ctx, f.answer, s.newOutboundFileServiceResolver(f.tenant, nil, nil))+ require.Contains(t, out, f.refs[0])+ require.Contains(t, out, f.refs[1])+ require.NotContains(t, out, f.refs[2], "the available shared instance still resolves")+ require.Contains(t, out, "x-oss-signature=")+}++type resourceStreamingSession struct {+ interfaces.SessionService+ answer string+ updated <-chan struct{}+}++func (s *resourceStreamingSession) KnowledgeQA(ctx context.Context, req *types.QARequest, bus *event.EventBus) error {+ if err := bus.Emit(ctx, event.Event{+ Type: event.EventAgentFinalAnswer, SessionID: req.Session.ID,+ Data: event.AgentFinalAnswerData{Content: s.answer},+ }); err != nil {+ return err+ }+ select {+ case <-s.updated:+ case <-ctx.Done():+ return ctx.Err()+ }+ return bus.Emit(ctx, event.Event{+ Type: event.EventAgentFinalAnswer, SessionID: req.Session.ID,+ Data: event.AgentFinalAnswerData{Done: true},+ })+}++type resourceStreamingAdapter struct {+ *fullOutputAdapter+ once sync.Once+ updated chan struct{}+ content string+}++func (a *resourceStreamingAdapter) UpdateStreamContent(+ ctx context.Context,+ msg *IncomingMessage,+ streamID, content string,+) error {+ a.content = content+ a.once.Do(func() { close(a.updated) })+ return a.fullOutputAdapter.UpdateStreamContent(ctx, msg, streamID, content)+}++func TestIMStreamUpdatesUseResourceStorageBeforeCompletion(t *testing.T) {+ f := newIMResourceStorageFixture(t)+ s, base, _, _ := newFullOutputHarness(f.answer)+ f.wire(s)+ adapter := &resourceStreamingAdapter{fullOutputAdapter: base, updated: make(chan struct{})}+ s.sessionService = &resourceStreamingSession{answer: f.answer, updated: adapter.updated}+ ctx, cancel := context.WithTimeout(f.context(), 5*time.Second)+ defer cancel()+ err := s.handleMessageStream(ctx,+ &IncomingMessage{Platform: PlatformWeCom, UserID: "test-user", Content: "Show the images"},+ &types.Session{ID: "test-session"}, nil, nil, nil, nil, adapter, adapter, "test-user", f.tenant)+ require.NoError(t, err)+ require.Positive(t, adapter.updates)+ f.checkSignedImages(t, adapter.content)+ f.checkSignedImages(t, adapter.finalContent)+}diff --git a/internal/im/service.go b/internal/im/service.goindex 838afb7e5..f61c700b8 100644--- a/internal/im/service.go+++ b/internal/im/service.go@@ -141,8 +141,8 @@ func holdbackCutoff(chunk string) int {}// formatIMOutboundAnswer strips thinking/tool blocks and applies IM content cleanup.-func formatIMOutboundAnswer(ctx context.Context, raw string, tenant *types.Tenant, defaultFileSvc interfaces.FileService, storageResolvers ...interfaces.StorageBackendResolver) string {- return cleanIMContent(ctx, FormatIMDisplayContent(raw, StreamDisplayFinal), tenant, defaultFileSvc, storageResolvers...)+func formatIMOutboundAnswer(ctx context.Context, raw string, resolver *storageurl.FileServiceResolver) string {+ return cleanIMContent(ctx, FormatIMDisplayContent(raw, StreamDisplayFinal), resolver)}// formatIMOutboundAnswerOrFallback guarantees that cleanup cannot turn a@@ -152,11 +152,9 @@ func formatIMOutboundAnswer(ctx context.Context, raw string, tenant *types.Tenanfunc formatIMOutboundAnswerOrFallback(ctx context.Context,raw string,- tenant *types.Tenant,- defaultFileSvc interfaces.FileService,- storageResolvers ...interfaces.StorageBackendResolver,+ resolver *storageurl.FileServiceResolver,) string {- content := formatIMOutboundAnswer(ctx, raw, tenant, defaultFileSvc, storageResolvers...)+ content := formatIMOutboundAnswer(ctx, raw, resolver)if strings.TrimSpace(content) == "" {return imNoAnswerFallback}@@ -184,11 +182,13 @@ func imQAFailureReply(err error) string {// cleanIMContent applies all IM-specific content transformations:// 1. Collapse <image> XML blocks back to plain markdown// 2. Strip <kb/> and <web/> citation tags-// 3. Rewrite provider:// URLs to HTTP URLs (scheme-aware per tenant config)-func cleanIMContent(ctx context.Context, content string, tenant *types.Tenant, defaultFileSvc interfaces.FileService, storageResolvers ...interfaces.StorageBackendResolver) string {+// 3. Rewrite storage references to HTTP URLs using their owning storage instance+func cleanIMContent(ctx context.Context, content string, resolver *storageurl.FileServiceResolver) string {content = stripImageXMLTags(content)content = stripIMCitationTags(content)- resolver := newIMFileServiceResolver(tenant, defaultFileSvc, storageResolvers...).WithContext(ctx)+ if resolver != nil {+ resolver.WithContext(ctx)+ }content = rewriteStorageURLs(ctx, content, resolver)return content}@@ -204,6 +204,21 @@ func newIMFileServiceResolver(return storageurl.NewFileServiceResolver(tenant, defaultSvc, storageResolvers...)}+// Every platform and output mode uses the same resource-aware resolver. Keep+// it scoped to the reply so shared KB images select their owner's backend and+// multiple images on the same instance reuse its client during streaming.+func (s *Service) newOutboundFileServiceResolver(+ tenant *types.Tenant,+ agent *types.CustomAgent,+ kbIDs []string,+) *storageurl.FileServiceResolver {+ return newIMFileServiceResolver(tenant, s.defaultFileSvc, s.storageResolver).+ WithResources(s.resourceCatalog, s.tenantService).+ WithAuthorization(func(ctx context.Context, reference string) error {+ return s.authorizeOutboundResource(ctx, tenant, agent, kbIDs, reference)+ })+}+func buildIMFileServiceForProvider(tenant *types.Tenant,provider string,@@ -298,7 +313,8 @@ type Service struct {knowledgeService interfaces.KnowledgeService// kbService is used by slash-commands (/info) to list and inspect knowledge bases.- kbService interfaces.KnowledgeBaseService+ kbService interfaces.KnowledgeBaseService+ kbShareService interfaces.KBShareService// oauthManager builds MCP OAuth authorization URLs so IM users can authorize// OAuth-enabled MCP services out-of-band (IM cannot resolve the in-conversation@@ -315,6 +331,7 @@ type Service struct {defaultFileSvc interfaces.FileServicedocumentReader interfaces.DocumentReaderstorageResolver interfaces.StorageBackendResolver+ resourceCatalog interfaces.ResourceCatalog// cmdRegistry holds all registered slash-commands.cmdRegistry *CommandRegistry@@ -858,6 +875,8 @@ func NewService(redisClient *redis.Client,appCfg *config.Config,storageResolver interfaces.StorageBackendResolver,+ resourceCatalog interfaces.ResourceCatalog,+ kbShareService interfaces.KBShareService,) *Service {// Resolve IM configuration with defaults.workers, maxQueue, maxPerUser, globalMaxWorkers, rlWindow, rlMax := resolveIMConfig(appCfg)@@ -883,6 +902,8 @@ func NewService(defaultFileSvc: defaultFileSvc,documentReader: documentReader,storageResolver: storageResolver,+ resourceCatalog: resourceCatalog,+ kbShareService: kbShareService,oauthManager: oauthManager,cmdRegistry: registry,channels: make(map[string]*channelState),@@ -2005,7 +2026,8 @@ func (s *Service) executeQARequest(req *qaRequest) {outCtx := imOutboundContext(ctx)reply := &ReplyMessage{- Content: formatIMOutboundAnswerOrFallback(outCtx, answer, req.tenant, s.defaultFileSvc, s.storageResolver),+ Content: formatIMOutboundAnswerOrFallback(outCtx, answer,+ s.newOutboundFileServiceResolver(req.tenant, req.agent, kbIDs)),IsFinal: true,}if err := req.adapter.SendReply(outCtx, req.msg, reply); err != nil {@@ -2053,7 +2075,8 @@ func (s *Service) handleMessageFullOutput(// QA (and /stop) may have cancelled ctx. Platform updates must still run so// the thinking card is replaced instead of hanging forever.outCtx := imOutboundContext(ctx)- finalContent := formatIMOutboundAnswerOrFallback(outCtx, answer, tenant, s.defaultFileSvc, s.storageResolver)+ finalContent := formatIMOutboundAnswerOrFallback(outCtx, answer,+ s.newOutboundFileServiceResolver(tenant, customAgent, kbIDs))finalizeErr := streamer.FinalizeStream(outCtx, msg, streamID, finalContent)if finalizeErr != nil {@@ -2829,6 +2852,7 @@ func (s *Service) handleMessageStream(ctx context.Context, msg *IncomingMessage,// XML tags that straddle a chunk boundary (see holdbackCutoff).ticker := time.NewTicker(streamFlushInterval)defer ticker.Stop()+ fileResolver := s.newOutboundFileServiceResolver(tenant, customAgent, kbIDs)flush := func() {bufMu.Lock()@@ -2845,7 +2869,7 @@ func (s *Service) handleMessageStream(ctx context.Context, msg *IncomingMessage,displaySource = displaySource[:cut]}- display := cleanIMContent(ctx, displaySource, tenant, s.defaultFileSvc, s.storageResolver)+ display := cleanIMContent(ctx, displaySource, fileResolver)if err := streamer.UpdateStreamContent(ctx, msg, streamID, display); err != nil {logger.Warnf(ctx, "[IM] UpdateStreamContent failed: %v", err)}@@ -2885,7 +2909,7 @@ loop:bufMu.Unlock()outCtx := imOutboundContext(ctx)- finalDisplay := cleanIMContent(outCtx, FormatIMFinalFromParts(parts), tenant, s.defaultFileSvc, s.storageResolver)+ finalDisplay := cleanIMContent(outCtx, FormatIMFinalFromParts(parts), fileResolver)if noVisibleContent || finalDisplay == "" {fallback := imNoAnswerFallbackif finalErr != nil {@@ -2949,7 +2973,8 @@ func (s *Service) fallbackNonStream(ctx context.Context, msg *IncomingMessage, soutCtx := imOutboundContext(ctx)return adapter.SendReply(outCtx, msg, &ReplyMessage{- Content: formatIMOutboundAnswerOrFallback(outCtx, answer, tenant, s.defaultFileSvc, s.storageResolver),+ Content: formatIMOutboundAnswerOrFallback(outCtx, answer,+ s.newOutboundFileServiceResolver(tenant, customAgent, kbIDs)),IsFinal: true,})}diff --git a/internal/storageurl/resolver.go b/internal/storageurl/resolver.goindex 550552ca7..33fe29990 100644--- a/internal/storageurl/resolver.go+++ b/internal/storageurl/resolver.go@@ -21,7 +21,13 @@ func LocalStorageBaseDir() string {return baseDir}-// FileServiceResolver resolves and caches one FileService per storage provider.+type fileServiceKey struct {+ tenantID uint64+ backendID string+ provider string+}++// FileServiceResolver resolves and caches one FileService per owner and storage instance.// The cache is scoped to a single request or outbound message so a long answer// with many images does not re-create an SDK client per reference.//@@ -30,13 +36,17 @@ type FileServiceResolver struct {tenant *types.TenantdefaultSvc interfaces.FileServicestorageResolver interfaces.StorageBackendResolver+ resourceCatalog interfaces.ResourceCatalog+ tenantService interfaces.TenantServicectx context.Context- cache map[string]interfaces.FileService+ cache map[fileServiceKey]interfaces.FileService+ owners map[uint64]*types.Tenant+ authorize func(context.Context, string) error}// NewFileServiceResolver builds a resolver for tenant. defaultSvc is the-// process-wide FileService used for `resource://` handles and as the fallback-// when tenant storage config is missing.+// process-wide fallback for legacy references without an explicit backend.+// WithResources enables owner/instance routing for resource:// handles.func NewFileServiceResolver(tenant *types.Tenant,defaultSvc interfaces.FileService,@@ -46,7 +56,8 @@ func NewFileServiceResolver(tenant: tenant,defaultSvc: defaultSvc,ctx: context.Background(),- cache: make(map[string]interfaces.FileService),+ cache: make(map[fileServiceKey]interfaces.FileService),+ owners: make(map[uint64]*types.Tenant),}if len(storageResolvers) > 0 {resolver.storageResolver = storageResolvers[0]@@ -54,6 +65,25 @@ func NewFileServiceResolver(return resolver}+// WithResources enables routing resource handles through their recorded owner+// and storage instance. Callers must already be authorized to expose the+// references; this only selects storage and does not grant resource access.+func (r *FileServiceResolver) WithResources(+ catalog interfaces.ResourceCatalog,+ tenants interfaces.TenantService,+) *FileServiceResolver {+ r.resourceCatalog = catalog+ r.tenantService = tenants+ return r+}++// WithAuthorization gates every reference before any storage credentials are+// selected. Model output and editable Markdown are not authorization evidence.+func (r *FileServiceResolver) WithAuthorization(authorize func(context.Context, string) error) *FileServiceResolver {+ r.authorize = authorize+ return r+}+// WithContext sets the context used for backend lookups and their logs.func (r *FileServiceResolver) WithContext(ctx context.Context) *FileServiceResolver {if ctx != nil {@@ -64,7 +94,16 @@ func (r *FileServiceResolver) WithContext(ctx context.Context) *FileServiceResol// ResolveFileService implements Resolver.func (r *FileServiceResolver) ResolveFileService(filePath string) interfaces.FileService {+ if r.authorize != nil {+ if err := r.authorize(r.ctx, filePath); err != nil {+ logger.Warnf(r.ctx, "resource URL access denied: src=%s err=%v", filePath, err)+ return nil+ }+ }if _, ok := types.ParseResourcePath(filePath); ok {+ if r.resourceCatalog != nil {+ return r.resolveResource(filePath)+ }return r.defaultSvc}backendID, _, _ := types.ParseStorageBackendPath(filePath)@@ -77,20 +116,73 @@ func (r *FileServiceResolver) ResolveFileService(filePath string) interfaces.Filreturn nil}}- cacheKey := backendID + ":" + provider+ return r.resolveStorage(r.tenant, backendID, provider, backendID == "")+}++func (r *FileServiceResolver) resolveResource(reference string) interfaces.FileService {+ resolve := r.resourceCatalog.Resolve+ if bindings, ok := r.resourceCatalog.(interfaces.ResourceStorageBindingResolver); ok {+ resolve = bindings.ResolveStorageBinding+ }+ resource, err := resolve(r.ctx, reference)+ if err != nil || resource == nil || resource.TenantID == 0 {+ logger.Warnf(r.ctx, "resolve resource storage failed: src=%s err=%v", reference, err)+ return nil+ }+ tenant := r.tenant+ if tenant == nil || tenant.ID != resource.TenantID {+ tenant = r.owners[resource.TenantID]+ if tenant == nil && r.tenantService != nil {+ tenant, err = r.tenantService.GetTenantByID(r.ctx, resource.TenantID)+ }+ if err != nil || tenant == nil || tenant.ID != resource.TenantID {+ logger.Warnf(r.ctx, "resolve resource owner failed: src=%s tenant_id=%d err=%v",+ reference, resource.TenantID, err)+ return nil+ }+ r.owners[resource.TenantID] = tenant+ }+ backendID := resource.StorageBackendID+ if backendID == "" {+ backendID, _, _ = types.ParseStorageBackendPath(resource.PhysicalPath)+ }+ if backendID == "" {+ return nil+ }+ provider := resource.Provider+ if provider == "" {+ provider = types.ParseProviderScheme(resource.PhysicalPath)+ }+ // A registered resource belongs to this owner's backend. Failure must not+ // sign its physical path with unrelated process-global credentials.+ return r.resolveStorage(tenant, backendID, provider, false)+}++func (r *FileServiceResolver) resolveStorage(+ tenant *types.Tenant,+ backendID, provider string,+ allowFallback bool,+) interfaces.FileService {+ cacheKey := fileServiceKey{backendID: backendID, provider: provider}+ if tenant != nil {+ cacheKey.tenantID = tenant.ID+ }if svc, ok := r.cache[cacheKey]; ok {return svc}- if r.storageResolver != nil && r.tenant != nil {- svc, _, err := r.storageResolver.ResolveFileService(r.ctx, r.tenant, backendID, provider, LocalStorageBaseDir())- if err == nil {+ if r.storageResolver != nil && tenant != nil {+ svc, _, err := r.storageResolver.ResolveFileService(r.ctx, tenant, backendID, provider, LocalStorageBaseDir())+ if err == nil && svc != nil {r.cache[cacheKey] = svcreturn svc}logger.Warnf(r.ctx, "resolve storage backend failed: backend_id=%s provider=%s err=%v",backendID, provider, err)}- svc := BuildFileServiceForProvider(r.tenant, provider, r.defaultSvc)+ if !allowFallback {+ return nil+ }+ svc := BuildFileServiceForProvider(tenant, provider, r.defaultSvc)if svc != nil {r.cache[cacheKey] = svc}diff --git a/internal/storageurl/resolver_test.go b/internal/storageurl/resolver_test.gonew file mode 100644index 000000000..789495f2e--- /dev/null+++ b/internal/storageurl/resolver_test.go@@ -0,0 +1,198 @@+package storageurl++import (+ "context"+ "errors"+ "fmt"+ "testing"+ "time"++ filesvc "github.com/Tencent/WeKnora/internal/application/service/file"+ "github.com/Tencent/WeKnora/internal/types"+ "github.com/Tencent/WeKnora/internal/types/interfaces"+ "github.com/stretchr/testify/require"+)++type resolverResourceCatalog struct {+ interfaces.ResourceCatalog+ resources map[string]*types.StoredResource+}++func (c *resolverResourceCatalog) Resolve(_ context.Context, ref string) (*types.StoredResource, error) {+ resource := c.resources[ref]+ if resource == nil {+ return nil, errors.New("resource not found")+ }+ return resource, nil+}++func (c *resolverResourceCatalog) ResolvePath(ctx context.Context, ref string) (string, *types.StoredResource, error) {+ if _, ok := types.ParseResourcePath(ref); !ok {+ return ref, nil, nil+ }+ resource, err := c.Resolve(ctx, ref)+ if err != nil {+ return "", nil, err+ }+ return resource.PhysicalPath, resource, nil+}++func (c *resolverResourceCatalog) CreateAccessGrant(context.Context, string, time.Duration) (string, error) {+ return "resource-grant", nil+}++type resolverTenantService struct {+ interfaces.TenantService+ get func(uint64) (*types.Tenant, error)+}++func (s *resolverTenantService) GetTenantByID(_ context.Context, id uint64) (*types.Tenant, error) {+ return s.get(id)+}++type resolverStorageService struct {+ interfaces.StorageBackendResolver+ resolve func(context.Context, *types.Tenant, string, string) (interfaces.FileService, string, error)+}++func (s *resolverStorageService) ResolveFileService(+ ctx context.Context,+ tenant *types.Tenant,+ backendID, provider, _ string,+) (interfaces.FileService, string, error) {+ return s.resolve(ctx, tenant, backendID, provider)+}++func TestResourceURLsUseBoundStorageDespiteGlobalDefault(t *testing.T) {+ for _, globalType := range []string{"local", "minio", "oss"} {+ t.Run(globalType, func(t *testing.T) {+ t.Setenv("STORAGE_TYPE", globalType)+ t.Setenv("APP_EXTERNAL_URL", "")+ catalog := &resolverResourceCatalog{resources: map[string]*types.StoredResource{}}+ for i, backendID := range []string{"oss-a", "oss-b", "oss-a"} {+ ref := types.BuildResourcePath(fmt.Sprintf("Handle%016d", i))+ catalog.resources[ref] = &types.StoredResource{+ TenantID: 7, StorageBackendID: backendID, Provider: "oss",+ PhysicalPath: fmt.Sprintf("storage://%s/oss://bucket-%s/7/exports/%d.png", backendID, backendID, i),+ }+ }+ global := &stubFileService{}+ lookups := map[string]int{}+ storage := &resolverStorageService{resolve: func(+ _ context.Context,+ tenant *types.Tenant,+ backendID, provider string,+ ) (interfaces.FileService, string, error) {+ require.Equal(t, uint64(7), tenant.ID)+ require.Equal(t, "oss", provider)+ lookups[backendID]+++ driver := &stubFileService{getFileURL: func(_ context.Context, path string) (string, error) {+ require.Contains(t, path, "oss://bucket-"+backendID+"/")+ return "https://" + backendID + ".example/image.png", nil+ }}+ scoped := filesvc.NewBackendScopedFileService(backendID, driver)+ return filesvc.NewResourceCatalogFileService(scoped, catalog), provider, nil+ }}+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, storage).WithResources(catalog, nil)+ w := NewRewriter(resolver, "TEST")+ for i, backendID := range []string{"oss-a", "oss-b", "oss-a"} {+ ref := types.BuildResourcePath(fmt.Sprintf("Handle%016d", i))+ require.Equal(t, "",+ w.String(context.Background(), ""))+ }+ require.Zero(t, global.calls, "bound resources must never use the global driver")+ require.Equal(t, map[string]int{"oss-a": 1, "oss-b": 1}, lookups,+ "cache by storage instance, not just provider")+ })+ }+}++func TestResourceURLsUseOwnerTenantAndPreserveShortLinks(t *testing.T) {+ for _, externalURL := range []string{"", "https://weknora.example"} {+ t.Run(externalURL, func(t *testing.T) {+ t.Setenv("APP_EXTERNAL_URL", externalURL)+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ catalog := &resolverResourceCatalog{resources: map[string]*types.StoredResource{+ ref: {+ TenantID: 9, StorageBackendID: "owner-oss", Provider: "oss",+ PhysicalPath: "storage://owner-oss/oss://bucket/9/image.png",+ },+ }}+ owner := &types.Tenant{ID: 9}+ tenants := &resolverTenantService{get: func(id uint64) (*types.Tenant, error) {+ require.Equal(t, owner.ID, id)+ return owner, nil+ }}+ global := &stubFileService{}+ storage := &resolverStorageService{resolve: func(+ _ context.Context,+ tenant *types.Tenant,+ backendID, provider string,+ ) (interfaces.FileService, string, error) {+ require.Same(t, owner, tenant)+ require.Equal(t, "owner-oss", backendID)+ require.Equal(t, "oss", provider)+ driver := &stubFileService{getFileURL: func(context.Context, string) (string, error) {+ return "https://owner-oss.example/image.png", nil+ }}+ return filesvc.NewResourceCatalogFileService(driver, catalog), provider, nil+ }}+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, storage).WithResources(catalog, tenants)+ want := "https://owner-oss.example/image.png"+ if externalURL != "" {+ want = externalURL + "/r/resource-grant"+ }+ require.Equal(t, want, NewRewriter(resolver, "TEST").Ref(context.Background(), ref))+ require.Zero(t, global.calls)+ })+ }+}++func TestResourceURLResolutionFailureDoesNotFallBackToGlobal(t *testing.T) {+ const ref = "resource://AbCdEfGhIjKlMnOpQrStUv"+ failures := []string{"resource missing", "owner missing", "backend missing", "backend disabled", "resolver missing"}+ for _, failure := range failures {+ t.Run(failure, func(t *testing.T) {+ t.Setenv("APP_EXTERNAL_URL", "")+ catalog := &resolverResourceCatalog{resources: map[string]*types.StoredResource{}}+ if failure != "resource missing" {+ catalog.resources[ref] = &types.StoredResource{+ TenantID: 9, StorageBackendID: "bound-oss", Provider: "oss",+ PhysicalPath: "storage://bound-oss/oss://bucket/9/image.png",+ }+ }+ tenants := &resolverTenantService{get: func(id uint64) (*types.Tenant, error) {+ if failure == "owner missing" {+ return nil, errors.New(failure)+ }+ return &types.Tenant{ID: id}, nil+ }}+ storage := &resolverStorageService{resolve: func(+ context.Context, *types.Tenant, string, string,+ ) (interfaces.FileService, string, error) {+ return nil, "", errors.New(failure)+ }}+ global := &stubFileService{}+ var backends interfaces.StorageBackendResolver = storage+ if failure == "resolver missing" {+ backends = nil+ }+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, backends).WithResources(catalog, tenants)+ require.Equal(t, ref, NewRewriter(resolver, "TEST").Ref(context.Background(), ref))+ require.Zero(t, global.calls)+ })+ }+}++func TestExplicitStorageBackendFailureDoesNotFallBackToGlobal(t *testing.T) {+ global := &stubFileService{}+ storage := &resolverStorageService{resolve: func(+ context.Context, *types.Tenant, string, string,+ ) (interfaces.FileService, string, error) {+ return nil, "", errors.New("backend unavailable")+ }}+ resolver := NewFileServiceResolver(&types.Tenant{ID: 7}, global, storage)+ const ref = "storage://bound-oss/oss://bucket/7/image.png"+ require.Equal(t, ref, NewRewriter(resolver, "TEST").Ref(context.Background(), ref))+ require.Zero(t, global.calls)+}diff --git a/internal/types/interfaces/resource.go b/internal/types/interfaces/resource.goindex 04b79a817..f4d14d416 100644--- a/internal/types/interfaces/resource.go+++ b/internal/types/interfaces/resource.go@@ -25,6 +25,8 @@ type ResourceRepository interface {GetByID(ctx context.Context, id string) (*types.StoredResource, error)GetByHandle(ctx context.Context, handle string) (*types.StoredResource, error)GetByTenantLocation(ctx context.Context, tenantID uint64, locationHash string) (*types.StoredResource, error)+ // BindStorageBackend fills an absent binding without replacing an existing one.+ BindStorageBackend(ctx context.Context, id, backendID string) (*types.StoredResource, error)// GetActiveByContentHash finds a live resource holding the exact same// bytes. Unlike location, content is not unique: several rows may carry// the same hash (duplicates registered before this lookup existed), so@@ -52,12 +54,24 @@ type ResourceRepository interface {// ResourceRegistration describes one physical object at registration time.type ResourceRegistration struct {- Kind string- MimeType string- OriginalName string- Size int64- ContentHash string- Temporary bool+ StorageBackendID string+ Kind string+ MimeType string+ OriginalName string+ Size int64+ ContentHash string+ Temporary bool+}++// GlobalResourceRegistrar records the concrete instance used by the process-wide writer.+type GlobalResourceRegistrar interface {+ RegisterGlobal(ctx context.Context, tenantID uint64, physicalPath string, meta ResourceRegistration) (string, error)+}++// ResourceStorageBindingResolver resolves legacy, unbound resources only when+// their physical location identifies a single storage instance.+type ResourceStorageBindingResolver interface {+ ResolveStorageBinding(ctx context.Context, reference string) (*types.StoredResource, error)}// ResourceCatalog maps public resource references to internal storagediff --git a/website-docs/03-features/12-im-integration.md b/website-docs/03-features/12-im-integration.mdindex a2904a876..d8afa1784 100644--- a/website-docs/03-features/12-im-integration.md+++ b/website-docs/03-features/12-im-integration.md@@ -61,8 +61,11 @@ IM 集成将智能体接入企业微信、飞书、钉钉、Slack、Telegram 等答案里引用知识库图片时,正文中是 `resource://` 或 `local://` / `minio://` 等内部引用,IM 客户端无法直接拉取。`rewriteStorageURLs`(`internal/im/service.go`)在发送前把它们换成可访问的 http(s) URL:+- 各 IM 渠道共用这条转换链路。`resource://` 按资源记录中的所属空间和存储实例生成链接;同一回答可引用多个实例,共享知识库图片使用资源所属空间的实例,无需把全局 `STORAGE_TYPE` 改成相同类型。绑定实例缺失、停用或解析失败时保留原引用并记录 WARN,不回退到全局存储;+- 跨空间图片在签名前检查实际知识库绑定、当前共享权限和智能体知识库范围;仅在答案中出现引用不会获得访问权。共享撤销后不再签发新链接;已签发链接仍按原有效期过期;+- 聊天附件和生成文件在写入时记录实际使用的全局存储实例。历史未绑定资源仅在物理路径能唯一匹配存储位置时补齐绑定,不使用空间默认存储猜测;- 解析结果**不是** http(s) 时(例如仍是内部 `storage://` 路径),保留原引用并打一条可操作的 WARN,而不是把 IM 端注定加载失败的链接发出去;-- 成功改写记 INFO 日志(含签名 URL,便于排障,代价是有日志权限的人可在有效期内使用该链接)。+- 成功改写的 INFO 日志只记录原引用;签名 URL 仅在 DEBUG 日志中输出。要让图片正常显示,二选一:diff --git a/website-docs/03-features/21-file-access.md b/website-docs/03-features/21-file-access.mdindex 1b05446e6..91c63ecc0 100644--- a/website-docs/03-features/21-file-access.md+++ b/website-docs/03-features/21-file-access.md@@ -48,6 +48,10 @@ Web 前端将 `resource://` 和 `provider://` 引用转换为鉴权代理地址IM 平台无法携带 WeKnora 凭证,需要可公开访问的 HTTP(S) URL。发送消息前,系统根据存储与部署配置生成外链:+`resource://` 使用资源实际绑定的存储实例,共享资源使用其所属空间的实例。知识库已绑定 OSS 等对象存储时,无需同步修改全局 `STORAGE_TYPE`。绑定实例不可用时保留原引用并记录告警,不使用其他实例或全局存储代替。++跨空间图片生成外链前会检查资源的知识库绑定、当前共享权限和智能体知识库范围。聊天附件、生成文件在写入时记录所用的全局存储实例;历史未绑定资源只在存储位置能唯一确定时补齐绑定,无法确定时保留原引用。+1. **存储后端本身公网可达**——对象存储用公网 endpoint,或把 `MINIO_ENDPOINT` 设成公网 host。此时回退到存储预签名 URL,不需要额外配置;2. **配置 `APP_EXTERNAL_URL`**——引用被改写成 `<APP_EXTERNAL_URL>/r/<token>`,请求经 nginx 的 `location ^~ /r/` 反代回 app。官方前端镜像已内置该 location,自建反代必须补上,否则请求落进 SPA fallback 返回空白页。