@wildo-ai/saas-backend-lib 1.1.2 → 1.1.4

package/dist/esm/external-providers/operations/provider-rest-call-client.backend.d.ts

@@ -0,0 +1,56 @@
+/**
+ * `ProviderRestCallClient` — the BINDING-FREE wire client for provider operations (S3a, #331).
+ *
+ * `HttpApiReadClient` is constructed per resource BINDING and reads `binding.remoteCallSemantics`,
+ * `binding.providerRef` and `binding.entityRef`. A provider operation has none of those: it is
+ * addressed by `(providerRef, operationId)` and belongs to no resource. So this is a sibling, not
+ * a subclass and not a widening of that class — widening it would have meant giving every ETL
+ * consumer a binding-shaped hole to work around.
+ *
+ * What is NOT duplicated is everything that matters: the transport, the rate budget and the
+ * provider-access resolver are the SAME modules the read client uses. This class owns only the
+ * three facts that differ — whose semantics apply, which rate window is drawn from, and that
+ * there is no dialect framing to do because the operation declared its own request.
+ *
+ * The single-authority drift pin (`http-api-read-client.single-authority.test.ts`) knows about
+ * this second invoker BY NAME; adding a third reddens it.
+ */
+import type { ExternalProvider_ConnectionTarget } from '@wildo-ai/external-connectors-models';
+import type { ProviderRestCallSemantics } from '@wildo-ai/external-connectors-models';
+import type { ExecutionContext } from '../../runtime/models/execution-context.backend.schemas';
+import { type HttpApiFetchLike, type HttpApiTransportRequest, type HttpApiTransportResponse } from '../../base-classes/services/repositories/http-api/http-api-transport.backend';
+import type { HttpApiProviderAccess, HttpApiProviderAccessResolver } from '../../base-classes/services/repositories/http-api/http-api-provider-access.backend';
+/**
+ * The semantics a provider gets when it declares none. Chosen to be unremarkable rather than
+ * clever: a 30s ceiling is longer than any interactive request should take and short enough that
+ * a hung vendor does not hold a connection for a request lifetime, and two attempts on a
+ * retry-safe call absorb a single transient without turning one user action into a burst.
+ */
+export declare const DEFAULT_PROVIDER_REST_CALL_SEMANTICS: ProviderRestCallSemantics;
+export declare class ProviderRestCallClient {
+    private readonly providerRef;
+    private readonly semantics;
+    private readonly providerAccessResolver;
+    private readonly fetchImpl;
+    private readonly rateBudget;
+    constructor(providerRef: string, semantics: ProviderRestCallSemantics, providerAccessResolver: HttpApiProviderAccessResolver, fetchImpl?: HttpApiFetchLike);
+    /**
+     * WHOSE ACCOUNT this call spends, through the same port the ETL lane uses.
+     *
+     * The target is an argument rather than something read from the execution context, and that is
+     * the whole point: one execution may legitimately spend several tenants' accounts — a single user
+     * action pushing to every organization that user belongs to — so an ambient answer could not vary
+     * where it has to. The context still decides whether the execution MAY act for the named owner.
+     */
+    resolveAccess(target: ExternalProvider_ConnectionTarget, executionContext: ExecutionContext<any>): Promise<HttpApiProviderAccess>;
+    /**
+     * One call, under this provider's semantics unless the operation narrowed them.
+     *
+     * SIGNING HAPPENS HERE, and it is the last thing done to the request before it leaves. A signature
+     * covers the bytes — method, canonical path, sorted query, payload hash, a subset of headers — so
+     * anything that edits the request afterwards invalidates it and the vendor answers a 403 that
+     * names nothing. Signing at the send site is the only placement where nothing can follow.
+     */
+    execute(request: HttpApiTransportRequest, semanticsOverride?: Partial<ProviderRestCallSemantics>, access?: HttpApiProviderAccess): Promise<HttpApiTransportResponse>;
+}
+//# sourceMappingURL=provider-rest-call-client.backend.d.ts.map

package/dist/esm/external-providers/operations/provider-rest-call-client.backend.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-rest-call-client.backend.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/operations/provider-rest-call-client.backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,sCAAsC,CAAC;AAC9F,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAC;AAEtF,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qEAAqE,CAAC;AAC5G,OAAO,EAGL,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC9B,MAAM,2FAA2F,CAAC;AAGnG,OAAO,KAAK,EACV,qBAAqB,EACrB,6BAA6B,EAC9B,MAAM,iGAAiG,CAAC;AAEzG;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,EAAE,yBAGlD,CAAC;AAEF,qBAAa,sBAAsB;IAI/B,OAAO,CAAC,QAAQ,CAAC,WAAW;IAC5B,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IACvC,OAAO,CAAC,QAAQ,CAAC,SAAS;IAN5B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAoB;gBAG5B,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,yBAAyB,EACpC,sBAAsB,EAAE,6BAA6B,EACrD,SAAS,GAAE,gBAAsC;IAOpE;;;;;;;OAOG;IACI,aAAa,CAClB,MAAM,EAAE,iCAAiC,EACzC,gBAAgB,EAAE,gBAAgB,CAAC,GAAG,CAAC,GACtC,OAAO,CAAC,qBAAqB,CAAC;IAIjC;;;;;;;OAOG;IACU,OAAO,CAClB,OAAO,EAAE,uBAAuB,EAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,EACtD,MAAM,CAAC,EAAE,qBAAqB,GAC7B,OAAO,CAAC,wBAAwB,CAAC;CAYrC"}

package/dist/esm/external-providers/operations/provider-rest-call-client.backend.js

@@ -0,0 +1,78 @@
+/**
+ * `ProviderRestCallClient` — the BINDING-FREE wire client for provider operations (S3a, #331).
+ *
+ * `HttpApiReadClient` is constructed per resource BINDING and reads `binding.remoteCallSemantics`,
+ * `binding.providerRef` and `binding.entityRef`. A provider operation has none of those: it is
+ * addressed by `(providerRef, operationId)` and belongs to no resource. So this is a sibling, not
+ * a subclass and not a widening of that class — widening it would have meant giving every ETL
+ * consumer a binding-shaped hole to work around.
+ *
+ * What is NOT duplicated is everything that matters: the transport, the rate budget and the
+ * provider-access resolver are the SAME modules the read client uses. This class owns only the
+ * three facts that differ — whose semantics apply, which rate window is drawn from, and that
+ * there is no dialect framing to do because the operation declared its own request.
+ *
+ * The single-authority drift pin (`http-api-read-client.single-authority.test.ts`) knows about
+ * this second invoker BY NAME; adding a third reddens it.
+ */
+import { HttpApiRateBudget, executeHttpApiTransportCall, } from '../../base-classes/services/repositories/http-api/http-api-transport.backend.js';
+import { defaultHttpApiFetch } from '../../base-classes/services/repositories/http-api/http-api-read-client.backend.js';
+import { signProviderRequest } from '../../external-providers/operations/provider-request-signing.backend.js';
+/**
+ * The semantics a provider gets when it declares none. Chosen to be unremarkable rather than
+ * clever: a 30s ceiling is longer than any interactive request should take and short enough that
+ * a hung vendor does not hold a connection for a request lifetime, and two attempts on a
+ * retry-safe call absorb a single transient without turning one user action into a burst.
+ */
+export const DEFAULT_PROVIDER_REST_CALL_SEMANTICS = {
+    timeoutMs: 30_000,
+    retry: { maxAttempts: 2, backoffMs: 250 },
+};
+export class ProviderRestCallClient {
+    providerRef;
+    semantics;
+    providerAccessResolver;
+    fetchImpl;
+    rateBudget;
+    constructor(providerRef, semantics, providerAccessResolver, fetchImpl = defaultHttpApiFetch) {
+        this.providerRef = providerRef;
+        this.semantics = semantics;
+        this.providerAccessResolver = providerAccessResolver;
+        this.fetchImpl = fetchImpl;
+        // One window per client instance, so the executor's per-provider cache is also what makes the
+        // rate ceiling mean anything: a client rebuilt per call would reset the window every time.
+        this.rateBudget = new HttpApiRateBudget(semantics.maxRequestsPerMinute);
+    }
+    /**
+     * WHOSE ACCOUNT this call spends, through the same port the ETL lane uses.
+     *
+     * The target is an argument rather than something read from the execution context, and that is
+     * the whole point: one execution may legitimately spend several tenants' accounts — a single user
+     * action pushing to every organization that user belongs to — so an ambient answer could not vary
+     * where it has to. The context still decides whether the execution MAY act for the named owner.
+     */
+    resolveAccess(target, executionContext) {
+        return this.providerAccessResolver.resolveAccess(this.providerRef, target, executionContext);
+    }
+    /**
+     * One call, under this provider's semantics unless the operation narrowed them.
+     *
+     * SIGNING HAPPENS HERE, and it is the last thing done to the request before it leaves. A signature
+     * covers the bytes — method, canonical path, sorted query, payload hash, a subset of headers — so
+     * anything that edits the request afterwards invalidates it and the vendor answers a 403 that
+     * names nothing. Signing at the send site is the only placement where nothing can follow.
+     */
+    async execute(request, semanticsOverride, access) {
+        const semantics = semanticsOverride
+            ? {
+                timeoutMs: semanticsOverride.timeoutMs ?? this.semantics.timeoutMs,
+                retry: semanticsOverride.retry ?? this.semantics.retry,
+            }
+            : this.semantics;
+        const outbound = access?.requestSigning
+            ? signProviderRequest({ request, signing: access.requestSigning.declaration, credentials: access.requestSigning.credentials })
+            : request;
+        return executeHttpApiTransportCall(outbound, semantics, this.fetchImpl, this.rateBudget);
+    }
+}
+//# sourceMappingURL=provider-rest-call-client.backend.js.map

package/dist/esm/external-providers/operations/provider-rest-call-client.backend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-rest-call-client.backend.js","sourceRoot":"","sources":["../../../../src/external-providers/operations/provider-rest-call-client.backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAMH,OAAO,EACL,iBAAiB,EACjB,2BAA2B,GAI5B,MAAM,2FAA2F,CAAC;AACnG,OAAO,EAAE,mBAAmB,EAAE,MAAM,6FAA6F,CAAC;AAClI,OAAO,EAAE,mBAAmB,EAAE,MAAM,mFAAmF,CAAC;AAMxH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAA8B;IAC7E,SAAS,EAAE,MAAM;IACjB,KAAK,EAAE,EAAE,WAAW,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE;CAC1C,CAAC;AAEF,MAAM,OAAO,sBAAsB;IAId;IACA;IACA;IACA;IANF,UAAU,CAAoB;IAE/C,YACmB,WAAmB,EACnB,SAAoC,EACpC,sBAAqD,EACrD,YAA8B,mBAAmB;QAHjD,gBAAW,GAAX,WAAW,CAAQ;QACnB,cAAS,GAAT,SAAS,CAA2B;QACpC,2BAAsB,GAAtB,sBAAsB,CAA+B;QACrD,cAAS,GAAT,SAAS,CAAwC;QAElE,8FAA8F;QAC9F,2FAA2F;QAC3F,IAAI,CAAC,UAAU,GAAG,IAAI,iBAAiB,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC;IAC1E,CAAC;IAED;;;;;;;OAOG;IACI,aAAa,CAClB,MAAyC,EACzC,gBAAuC;QAEvC,OAAO,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,IAAI,CAAC,WAAW,EAAE,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC/F,CAAC;IAED;;;;;;;OAOG;IACI,KAAK,CAAC,OAAO,CAClB,OAAgC,EAChC,iBAAsD,EACtD,MAA8B;QAE9B,MAAM,SAAS,GAAG,iBAAiB;YACjC,CAAC,CAAC;gBACA,SAAS,EAAE,iBAAiB,CAAC,SAAS,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS;gBAClE,KAAK,EAAE,iBAAiB,CAAC,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,KAAK;aACvD;YACD,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;QACnB,MAAM,QAAQ,GAAG,MAAM,EAAE,cAAc;YACrC,CAAC,CAAC,mBAAmB,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,cAAc,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,CAAC,cAAc,CAAC,WAAW,EAAE,CAAC;YAC9H,CAAC,CAAC,OAAO,CAAC;QACZ,OAAO,2BAA2B,CAAC,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC3F,CAAC;CACF","sourcesContent":["/**\n * `ProviderRestCallClient` — the BINDING-FREE wire client for provider operations (S3a, #331).\n *\n * `HttpApiReadClient` is constructed per resource BINDING and reads `binding.remoteCallSemantics`,\n * `binding.providerRef` and `binding.entityRef`. A provider operation has none of those: it is\n * addressed by `(providerRef, operationId)` and belongs to no resource. So this is a sibling, not\n * a subclass and not a widening of that class — widening it would have meant giving every ETL\n * consumer a binding-shaped hole to work around.\n *\n * What is NOT duplicated is everything that matters: the transport, the rate budget and the\n * provider-access resolver are the SAME modules the read client uses. This class owns only the\n * three facts that differ — whose semantics apply, which rate window is drawn from, and that\n * there is no dialect framing to do because the operation declared its own request.\n *\n * The single-authority drift pin (`http-api-read-client.single-authority.test.ts`) knows about\n * this second invoker BY NAME; adding a third reddens it.\n */\n\nimport type { ExternalProvider_ConnectionTarget } from '@wildo-ai/external-connectors-models';\nimport type { ProviderRestCallSemantics } from '@wildo-ai/external-connectors-models';\n\nimport type { ExecutionContext } from '~wildo-backend-lib/runtime/models/execution-context.backend.schemas';\nimport {\n  HttpApiRateBudget,\n  executeHttpApiTransportCall,\n  type HttpApiFetchLike,\n  type HttpApiTransportRequest,\n  type HttpApiTransportResponse,\n} from '~wildo-backend-lib/base-classes/services/repositories/http-api/http-api-transport.backend';\nimport { defaultHttpApiFetch } from '~wildo-backend-lib/base-classes/services/repositories/http-api/http-api-read-client.backend';\nimport { signProviderRequest } from '~wildo-backend-lib/external-providers/operations/provider-request-signing.backend';\nimport type {\n  HttpApiProviderAccess,\n  HttpApiProviderAccessResolver,\n} from '~wildo-backend-lib/base-classes/services/repositories/http-api/http-api-provider-access.backend';\n\n/**\n * The semantics a provider gets when it declares none. Chosen to be unremarkable rather than\n * clever: a 30s ceiling is longer than any interactive request should take and short enough that\n * a hung vendor does not hold a connection for a request lifetime, and two attempts on a\n * retry-safe call absorb a single transient without turning one user action into a burst.\n */\nexport const DEFAULT_PROVIDER_REST_CALL_SEMANTICS: ProviderRestCallSemantics = {\n  timeoutMs: 30_000,\n  retry: { maxAttempts: 2, backoffMs: 250 },\n};\n\nexport class ProviderRestCallClient {\n  private readonly rateBudget: HttpApiRateBudget;\n\n  constructor(\n    private readonly providerRef: string,\n    private readonly semantics: ProviderRestCallSemantics,\n    private readonly providerAccessResolver: HttpApiProviderAccessResolver,\n    private readonly fetchImpl: HttpApiFetchLike = defaultHttpApiFetch,\n  ) {\n    // One window per client instance, so the executor's per-provider cache is also what makes the\n    // rate ceiling mean anything: a client rebuilt per call would reset the window every time.\n    this.rateBudget = new HttpApiRateBudget(semantics.maxRequestsPerMinute);\n  }\n\n  /**\n   * WHOSE ACCOUNT this call spends, through the same port the ETL lane uses.\n   *\n   * The target is an argument rather than something read from the execution context, and that is\n   * the whole point: one execution may legitimately spend several tenants' accounts — a single user\n   * action pushing to every organization that user belongs to — so an ambient answer could not vary\n   * where it has to. The context still decides whether the execution MAY act for the named owner.\n   */\n  public resolveAccess(\n    target: ExternalProvider_ConnectionTarget,\n    executionContext: ExecutionContext<any>,\n  ): Promise<HttpApiProviderAccess> {\n    return this.providerAccessResolver.resolveAccess(this.providerRef, target, executionContext);\n  }\n\n  /**\n   * One call, under this provider's semantics unless the operation narrowed them.\n   *\n   * SIGNING HAPPENS HERE, and it is the last thing done to the request before it leaves. A signature\n   * covers the bytes — method, canonical path, sorted query, payload hash, a subset of headers — so\n   * anything that edits the request afterwards invalidates it and the vendor answers a 403 that\n   * names nothing. Signing at the send site is the only placement where nothing can follow.\n   */\n  public async execute(\n    request: HttpApiTransportRequest,\n    semanticsOverride?: Partial<ProviderRestCallSemantics>,\n    access?: HttpApiProviderAccess,\n  ): Promise<HttpApiTransportResponse> {\n    const semantics = semanticsOverride\n      ? {\n        timeoutMs: semanticsOverride.timeoutMs ?? this.semantics.timeoutMs,\n        retry: semanticsOverride.retry ?? this.semantics.retry,\n      }\n      : this.semantics;\n    const outbound = access?.requestSigning\n      ? signProviderRequest({ request, signing: access.requestSigning.declaration, credentials: access.requestSigning.credentials })\n      : request;\n    return executeHttpApiTransportCall(outbound, semantics, this.fetchImpl, this.rateBudget);\n  }\n}\n"]}

package/dist/esm/external-providers/services/__tests__/mock-external-providers-registry.service.d.ts

@@ -10,7 +10,7 @@ import { ExternalProvider_ExchangeProtocol_Kind, LLMProvider_OperationKey, LLMPr
 export declare class MockExternalProvidersRegistryBackendService {
     private readonly profiles;
     getProviderRuntimeContract: import("vitest").Mock<[providerRef: string, kind: ExternalProvider_ExchangeProtocol_Kind], {
-        kind: string;
+        kind: ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER;
         promptFormatPreference: import("@wildo-ai/external-connectors-models").LLMProvider_PromptFormat;
         operations: LLMProvider_OperationKey[];
     }>;

package/dist/esm/external-providers/services/__tests__/mock-external-providers-registry.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mock-external-providers-registry.service.d.ts","sourceRoot":"","sources":["../../../../../../src/external-providers/services/__tests__/mock-external-providers-registry.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EACL,sCAAsC,EACtC,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,sCAAsC,CAAC;AAG9C,qBACa,2CAA2C;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IAEnE,0BAA0B;;;;OAUvB;IAEH,2BAA2B,2EAExB;IAEH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAIvE,KAAK,IAAI,IAAI;CAKd"}
+{"version":3,"file":"mock-external-providers-registry.service.d.ts","sourceRoot":"","sources":["../../../../../src/external-providers/services/__tests__/mock-external-providers-registry.service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,kBAAkB,CAAC;AAE1B,OAAO,EACL,sCAAsC,EACtC,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,sCAAsC,CAAC;AAG9C,qBACa,2CAA2C;IACtD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA0C;IAEnE,0BAA0B;;;;OAUvB;IAEH,2BAA2B,2EAExB;IAEH,cAAc,CAAC,WAAW,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAIvE,KAAK,IAAI,IAAI;CAKd"}

package/dist/esm/external-providers/services/__tests__/mock-external-providers-registry.service.js

@@ -13,7 +13,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
  */
 import 'reflect-metadata';
 import { injectable } from 'inversify';
-import { ExternalProvider_ExchangeProtocol_Kind, LLMProvider_OperationKey, } from '@wildo-ai/external-connectors-models';
+import { ExternalProvider_ExchangeProtocol_Kind, LLMProvider_OperationKey, ProviderProtocolRuntimeKind, } from '@wildo-ai/external-connectors-models';
 import { vi } from 'vitest';
 let MockExternalProvidersRegistryBackendService = class MockExternalProvidersRegistryBackendService {
     profiles = new Map();
@@ -21,7 +21,7 @@ let MockExternalProvidersRegistryBackendService = class MockExternalProvidersReg
         const profile = this.profiles.get(providerRef);
         if (profile && kind === ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER) {
             return {
-                kind: 'llm',
+                kind: ProviderProtocolRuntimeKind.LLM,
                 promptFormatPreference: profile.promptFormatPreference,
                 operations: [LLMProvider_OperationKey.GENERATE_TEXT],
             };

package/dist/esm/external-providers/services/__tests__/mock-external-providers-registry.service.js.map

@@ -1 +1 @@
-{"version":3,"file":"mock-external-providers-registry.service.js","sourceRoot":"","sources":["../../../../../../src/external-providers/services/__tests__/mock-external-providers-registry.service.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;GAMG;AACH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EACL,sCAAsC,EACtC,wBAAwB,GAEzB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAGrB,IAAM,2CAA2C,GAAjD,MAAM,2CAA2C;IACrC,QAAQ,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEnE,0BAA0B,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,WAAmB,EAAE,IAA4C,EAAE,EAAE;QACvG,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC/C,IAAI,OAAO,IAAI,IAAI,KAAK,sCAAsC,CAAC,YAAY,EAAE,CAAC;YAC5E,OAAO;gBACL,IAAI,EAAE,KAAK;gBACX,sBAAsB,EAAE,OAAO,CAAC,sBAAsB;gBACtD,UAAU,EAAE,CAAC,wBAAwB,CAAC,aAAa,CAAC;aACrD,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;IAEH,2BAA2B,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,WAAmB,EAAE,EAAE,CAAC,CAC3D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAC/E,CAAC,CAAC;IAEH,cAAc,CAAC,WAAmB,EAAE,OAA4B;QAC9D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,0BAA0B,CAAC,SAAS,EAAE,CAAC;QAC5C,IAAI,CAAC,2BAA2B,CAAC,SAAS,EAAE,CAAC;IAC/C,CAAC;CACF,CAAA;AA5BY,2CAA2C;IADvD,UAAU,EAAE;GACA,2CAA2C,CA4BvD","sourcesContent":["/**\n * Vitest-oriented mock external providers registry for backend tests.\n *\n * **Naming**: `mock-*.service.ts` — canonical mock module, not a test suite.\n * Plain `.ts` keeps it barrel-compilable, and Vitest also excludes these files\n * explicitly as a defensive guard.\n */\nimport 'reflect-metadata';\nimport { injectable } from 'inversify';\nimport {\n  ExternalProvider_ExchangeProtocol_Kind,\n  LLMProvider_OperationKey,\n  LLMProvider_Profile,\n} from '@wildo-ai/external-connectors-models';\nimport { vi } from 'vitest';\n\n@injectable()\nexport class MockExternalProvidersRegistryBackendService {\n  private readonly profiles = new Map<string, LLMProvider_Profile>();\n\n  getProviderRuntimeContract = vi.fn((providerRef: string, kind: ExternalProvider_ExchangeProtocol_Kind) => {\n    const profile = this.profiles.get(providerRef);\n    if (profile && kind === ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER) {\n      return {\n        kind: 'llm',\n        promptFormatPreference: profile.promptFormatPreference,\n        operations: [LLMProvider_OperationKey.GENERATE_TEXT],\n      };\n    }\n    return undefined;\n  });\n\n  getLLMSemanticOperationKeys = vi.fn((providerRef: string) => (\n    this.profiles.has(providerRef) ? [LLMProvider_OperationKey.GENERATE_TEXT] : []\n  ));\n\n  setMockProfile(providerRef: string, profile: LLMProvider_Profile): void {\n    this.profiles.set(providerRef, profile);\n  }\n\n  reset(): void {\n    this.profiles.clear();\n    this.getProviderRuntimeContract.mockClear();\n    this.getLLMSemanticOperationKeys.mockClear();\n  }\n}\n"]}
+{"version":3,"file":"mock-external-providers-registry.service.js","sourceRoot":"","sources":["../../../../../src/external-providers/services/__tests__/mock-external-providers-registry.service.ts"],"names":[],"mappings":";;;;;;AAAA;;;;;;GAMG;AACH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AACvC,OAAO,EACL,sCAAsC,EACtC,wBAAwB,EAExB,2BAA2B,GAC5B,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAC;AAGrB,IAAM,2CAA2C,GAAjD,MAAM,2CAA2C;IACrC,QAAQ,GAAG,IAAI,GAAG,EAA+B,CAAC;IAEnE,0BAA0B,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,WAAmB,EAAE,IAA4C,EAAE,EAAE;QACvG,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAC/C,IAAI,OAAO,IAAI,IAAI,KAAK,sCAAsC,CAAC,YAAY,EAAE,CAAC;YAC5E,OAAO;gBACL,IAAI,EAAE,2BAA2B,CAAC,GAAG;gBACrC,sBAAsB,EAAE,OAAO,CAAC,sBAAsB;gBACtD,UAAU,EAAE,CAAC,wBAAwB,CAAC,aAAa,CAAC;aACrD,CAAC;QACJ,CAAC;QACD,OAAO,SAAS,CAAC;IACnB,CAAC,CAAC,CAAC;IAEH,2BAA2B,GAAG,EAAE,CAAC,EAAE,CAAC,CAAC,WAAmB,EAAE,EAAE,CAAC,CAC3D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,wBAAwB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,EAAE,CAC/E,CAAC,CAAC;IAEH,cAAc,CAAC,WAAmB,EAAE,OAA4B;QAC9D,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK;QACH,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,0BAA0B,CAAC,SAAS,EAAE,CAAC;QAC5C,IAAI,CAAC,2BAA2B,CAAC,SAAS,EAAE,CAAC;IAC/C,CAAC;CACF,CAAA;AA5BY,2CAA2C;IADvD,UAAU,EAAE;GACA,2CAA2C,CA4BvD","sourcesContent":["/**\n * Vitest-oriented mock external providers registry for backend tests.\n *\n * **Naming**: `mock-*.service.ts` — canonical mock module, not a test suite.\n * Plain `.ts` keeps it barrel-compilable, and Vitest also excludes these files\n * explicitly as a defensive guard.\n */\nimport 'reflect-metadata';\nimport { injectable } from 'inversify';\nimport {\n  ExternalProvider_ExchangeProtocol_Kind,\n  LLMProvider_OperationKey,\n  LLMProvider_Profile,\n  ProviderProtocolRuntimeKind,\n} from '@wildo-ai/external-connectors-models';\nimport { vi } from 'vitest';\n\n@injectable()\nexport class MockExternalProvidersRegistryBackendService {\n  private readonly profiles = new Map<string, LLMProvider_Profile>();\n\n  getProviderRuntimeContract = vi.fn((providerRef: string, kind: ExternalProvider_ExchangeProtocol_Kind) => {\n    const profile = this.profiles.get(providerRef);\n    if (profile && kind === ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER) {\n      return {\n        kind: ProviderProtocolRuntimeKind.LLM,\n        promptFormatPreference: profile.promptFormatPreference,\n        operations: [LLMProvider_OperationKey.GENERATE_TEXT],\n      };\n    }\n    return undefined;\n  });\n\n  getLLMSemanticOperationKeys = vi.fn((providerRef: string) => (\n    this.profiles.has(providerRef) ? [LLMProvider_OperationKey.GENERATE_TEXT] : []\n  ));\n\n  setMockProfile(providerRef: string, profile: LLMProvider_Profile): void {\n    this.profiles.set(providerRef, profile);\n  }\n\n  reset(): void {\n    this.profiles.clear();\n    this.getProviderRuntimeContract.mockClear();\n    this.getLLMSemanticOperationKeys.mockClear();\n  }\n}\n"]}

package/dist/esm/external-providers/services/backend-provider-loader.backend.service.d.ts

@@ -0,0 +1,89 @@
+/**
+ * The host-side provider LOADER: turn a process's declared provider refs into a composed backend
+ * registry, importing only what that process declared (#330).
+ *
+ * ## The defect this replaces
+ *
+ * `BackendProviderRegistryBackendService` used to be initialised from the engine's eagerly composed
+ * catalogue — twenty-two provider modules, six of which import an `@ai-sdk/*` client at module top
+ * level — as a DEFAULT FIELD INITIALISER. Every backend, every minion and every worker therefore
+ * evaluated every provider before the runtime artifact could filter anything, and a Node worker that
+ * declared one email provider still paid for six model SDKs (audit finding BE-1). Worse, the reverse
+ * was impossible: there was no by-ref resolution at all, so a provider shipped as its own npm package
+ * could not be loaded even when the application declared it (BE-2, BE-3).
+ *
+ * ## Resolution order, and why it is this order
+ *
+ * For each ref the artifact declares:
+ *
+ * 1. **The application's own fragment** — a module the application constructed and handed to
+ *    `initialize`. It is the most specific answer and it needs no import.
+ * 2. **The engine's on-demand map** (`ENGINE_BACKEND_PROVIDER_LOADERS`). An engine-shipped ref never
+ *    needs a declared package, which is what lets an application whose artifact predates the import
+ *    map keep working unchanged.
+ * 3. **The artifact's `providerRuntimeImports[ref]`** — a dynamic import of the package specifier
+ *    `wildo config sync` recorded from that provider package's `./companion` contribution, read
+ *    through the fixed `backendProviderFragment` convention.
+ *
+ * ## This function does not refuse
+ *
+ * A ref it cannot resolve is recorded in {@link BackendProviderResolution.unresolved} with the reason,
+ * and resolution continues. The refusal stays where it already was — the artifact filter in
+ * `BackendProviderRegistryBackendService`, which names every missing ref in one message — because two
+ * refusal sites for one condition is how the two drift, and because a caller that resolved nothing
+ * should still hear about ALL of its missing refs rather than the first one. What changes is that the
+ * refusal can now say WHY each ref failed instead of only that it was absent from the catalogue.
+ */
+import { type BackendProviderRegistry, type BackendProviderRegistryFragment } from '@wildo-ai/external-connectors-private/backend-runtime';
+/**
+ * Exactly what the loader reads out of a generated provider-runtime artifact — and nothing else.
+ *
+ * Stated structurally rather than as `ProviderRuntimeArtifact` because FOUR hosts pass one, and they
+ * do not all hold the same nominal type: the backend, minion and worker hold the engine's
+ * `ProviderRuntimeArtifact` (`artifactKind: 'backend'`), while the companion holds the CLI's
+ * `SaasRuntimeProvidersArtifact` (`artifactKind` is a five-member union). Both satisfy this shape.
+ * The alternative was a cast at the companion's call site, which would assert across a package
+ * boundary the very thing nobody had checked — so the contract is narrowed to what is actually used
+ * instead, and every host satisfies it by construction.
+ */
+export interface DeclaredProviderTopology {
+    readonly providerRefs?: ReadonlyArray<string>;
+    readonly providerRuntimeImports?: Readonly<Record<string, string>>;
+    readonly scope?: {
+        readonly providers?: Readonly<Record<string, unknown>>;
+    };
+}
+/** @wildo_source:part:start saas.external-providers.backend-provider-loader facet:layer:backend facet:family:provider-registry facet:audience:app-developer */
+/** How a host asks for the providers it declared. */
+export interface BackendProviderResolutionRequest {
+    /**
+     * The generated topology for THIS process. Absent for a host that has none — a platform
+     * application that initialises its configuration later — which then receives the whole engine
+     * catalogue, exactly as it did before this loader existed.
+     */
+    readonly providerRuntime?: DeclaredProviderTopology;
+    /**
+     * Providers the application constructed itself, rather than declaring by package. Accepts a whole
+     * `BackendProviderRegistry` too: a registry IS a fragment plus its indexes.
+     */
+    readonly applicationFragment?: BackendProviderRegistryFragment;
+    /**
+     * The import used for package-declared providers. Overridable so a test can resolve a fixture
+     * package without publishing one; production passes nothing.
+     */
+    readonly importModule?: (specifier: string) => Promise<unknown>;
+}
+export interface BackendProviderResolution {
+    /** Everything that resolved, composed (so the tier and arm fences have already run). */
+    readonly registry: BackendProviderRegistry;
+    /** `providerRef` -> why it could not be resolved. Empty on a clean resolution. */
+    readonly unresolved: ReadonlyMap<string, string>;
+}
+/**
+ * Resolve the backend provider registry for one host.
+ *
+ * Every declared ref is resolved concurrently: the imports are independent, and a serial loop would
+ * make boot latency the sum of every provider package's evaluation.
+ */
+export declare function resolveBackendProviderRegistry(request: BackendProviderResolutionRequest): Promise<BackendProviderResolution>;
+//# sourceMappingURL=backend-provider-loader.backend.service.d.ts.map

package/dist/esm/external-providers/services/backend-provider-loader.backend.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-provider-loader.backend.service.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/services/backend-provider-loader.backend.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAKL,KAAK,uBAAuB,EAC5B,KAAK,+BAA+B,EAErC,MAAM,uDAAuD,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,YAAY,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAC9C,QAAQ,CAAC,sBAAsB,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACnE,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;KAAE,CAAC;CAC7E;AAED,+JAA+J;AAC/J,qDAAqD;AACrD,MAAM,WAAW,gCAAgC;IAC/C;;;;OAIG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,wBAAwB,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAE,+BAA+B,CAAC;IAC/D;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACjE;AAED,MAAM,WAAW,yBAAyB;IACxC,wFAAwF;IACxF,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,kFAAkF;IAClF,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClD;AAmFD;;;;;GAKG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,yBAAyB,CAAC,CA4DpC"}

package/dist/esm/external-providers/services/backend-provider-loader.backend.service.js

@@ -0,0 +1,164 @@
+/**
+ * The host-side provider LOADER: turn a process's declared provider refs into a composed backend
+ * registry, importing only what that process declared (#330).
+ *
+ * ## The defect this replaces
+ *
+ * `BackendProviderRegistryBackendService` used to be initialised from the engine's eagerly composed
+ * catalogue — twenty-two provider modules, six of which import an `@ai-sdk/*` client at module top
+ * level — as a DEFAULT FIELD INITIALISER. Every backend, every minion and every worker therefore
+ * evaluated every provider before the runtime artifact could filter anything, and a Node worker that
+ * declared one email provider still paid for six model SDKs (audit finding BE-1). Worse, the reverse
+ * was impossible: there was no by-ref resolution at all, so a provider shipped as its own npm package
+ * could not be loaded even when the application declared it (BE-2, BE-3).
+ *
+ * ## Resolution order, and why it is this order
+ *
+ * For each ref the artifact declares:
+ *
+ * 1. **The application's own fragment** — a module the application constructed and handed to
+ *    `initialize`. It is the most specific answer and it needs no import.
+ * 2. **The engine's on-demand map** (`ENGINE_BACKEND_PROVIDER_LOADERS`). An engine-shipped ref never
+ *    needs a declared package, which is what lets an application whose artifact predates the import
+ *    map keep working unchanged.
+ * 3. **The artifact's `providerRuntimeImports[ref]`** — a dynamic import of the package specifier
+ *    `wildo config sync` recorded from that provider package's `./companion` contribution, read
+ *    through the fixed `backendProviderFragment` convention.
+ *
+ * ## This function does not refuse
+ *
+ * A ref it cannot resolve is recorded in {@link BackendProviderResolution.unresolved} with the reason,
+ * and resolution continues. The refusal stays where it already was — the artifact filter in
+ * `BackendProviderRegistryBackendService`, which names every missing ref in one message — because two
+ * refusal sites for one condition is how the two drift, and because a caller that resolved nothing
+ * should still hear about ALL of its missing refs rather than the first one. What changes is that the
+ * refusal can now say WHY each ref failed instead of only that it was absent from the catalogue.
+ */
+import { composeBackendProviders, ENGINE_BACKEND_PROVIDER_LOADERS, readBackendProviderFragment, } from '@wildo-ai/external-connectors-private/backend-runtime';
+/** @wildo_source:part:end saas.external-providers.backend-provider-loader */
+/**
+ * A variable-specifier dynamic import.
+ *
+ * The specifier is data — a package name a generated artifact recorded — so this cannot be a static
+ * import and no bundler can follow it. That is inherent to loading a provider the engine does not
+ * know about, and it is why a host that bundles its backend must keep provider packages external.
+ */
+async function importBySpecifier(specifier) {
+    return import(/* @vite-ignore */ /* webpackIgnore: true */ specifier);
+}
+function readDeclaredRefs(providerRuntime) {
+    const declared = providerRuntime.providerRefs && providerRuntime.providerRefs.length > 0
+        ? providerRuntime.providerRefs
+        // Same fallback the artifact filter keeps: `providerRefs` is optional on the schema, so a
+        // hand-crafted artifact may carry only the scope.
+        : Object.keys(providerRuntime.scope?.providers ?? {});
+    return [...new Set(declared)].sort();
+}
+function describeThrown(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function resolveOneProvider(input) {
+    const { applicationFragment, importModule, providerRef, runtimeImportPath } = input;
+    const applicationModule = applicationFragment?.modules.get(providerRef);
+    if (applicationModule) {
+        return { module: applicationModule };
+    }
+    const engineLoader = ENGINE_BACKEND_PROVIDER_LOADERS.get(providerRef);
+    if (engineLoader) {
+        try {
+            return { module: await engineLoader() };
+        }
+        catch (error) {
+            return { reason: `the engine module failed to load: ${describeThrown(error)}` };
+        }
+    }
+    if (!runtimeImportPath) {
+        return {
+            reason: 'no package declares it — the generated provider runtime carries no import path for '
+                + 'this ref, and the engine does not ship it. Add the provider package as a dependency of the '
+                + 'runtime owner and re-run `wildo config sync`.',
+        };
+    }
+    let namespace;
+    try {
+        namespace = await importModule(runtimeImportPath);
+    }
+    catch (error) {
+        return { reason: `importing "${runtimeImportPath}" failed: ${describeThrown(error)}` };
+    }
+    let fragment;
+    try {
+        fragment = readBackendProviderFragment(namespace, runtimeImportPath);
+    }
+    catch (error) {
+        return { reason: describeThrown(error) };
+    }
+    const packageModule = fragment.modules.get(providerRef);
+    if (!packageModule) {
+        const contributed = [...fragment.modules.keys()].map(String).sort();
+        return {
+            reason: `"${runtimeImportPath}" loaded but contributes no provider "${providerRef}"`
+                + (contributed.length > 0 ? ` (it contributes: ${contributed.join(', ')})` : ' (it contributes nothing)'),
+        };
+    }
+    return { module: packageModule };
+}
+/**
+ * Resolve the backend provider registry for one host.
+ *
+ * Every declared ref is resolved concurrently: the imports are independent, and a serial loop would
+ * make boot latency the sum of every provider package's evaluation.
+ */
+export async function resolveBackendProviderRegistry(request) {
+    const { applicationFragment, importModule = importBySpecifier, providerRuntime } = request;
+    if (!providerRuntime) {
+        /*
+         * No artifact: today's semantics, preserved deliberately. A platform application initialises its
+         * configuration after startup and never receives a generated topology, so narrowing it to the
+         * MAIN tier here would silently drop providers from a host that never asked for the change. It
+         * is lazy now rather than eager, which is all this branch can honestly improve — a host that
+         * declares nothing has told us nothing to filter on.
+         */
+        /*
+         * The application's own modules WIN, and the engine map is asked only for the refs it did not
+         * supply — the same precedence the declared-refs path uses below.
+         *
+         * Not merely for symmetry: `composeProviderRegistry` refuses two fragments that declare one ref,
+         * by design and with no silent override. An application that hands over a registry it composed
+         * ITSELF (the pre-#330 contract: `composeBackendProviders(EngineBackendProviderRegistryFragment,
+         * appFragment)`) carries every engine ref inside it, so composing the two would throw a conflict
+         * on a call that used to work. Filtering here is what keeps this branch behaviour-identical to
+         * the default-field-initialiser it replaced.
+         */
+        const engineOnlyRefs = [...ENGINE_BACKEND_PROVIDER_LOADERS.entries()]
+            .filter(([providerRef]) => !applicationFragment?.modules.has(providerRef));
+        const engineModules = await Promise.all(engineOnlyRefs.map(async ([providerRef, load]) => [providerRef, await load()]));
+        return {
+            registry: composeBackendProviders({ modules: new Map(engineModules) }, ...(applicationFragment ? [applicationFragment] : [])),
+            unresolved: new Map(),
+        };
+    }
+    const declaredRefs = readDeclaredRefs(providerRuntime);
+    const runtimeImports = providerRuntime.providerRuntimeImports ?? {};
+    const outcomes = await Promise.all(declaredRefs.map(async (providerRef) => ({
+        providerRef,
+        outcome: await resolveOneProvider({
+            providerRef,
+            applicationFragment,
+            runtimeImportPath: runtimeImports[providerRef],
+            importModule,
+        }),
+    })));
+    const modules = new Map();
+    const unresolved = new Map();
+    for (const { outcome, providerRef } of outcomes) {
+        if ('module' in outcome) {
+            modules.set(providerRef, outcome.module);
+        }
+        else {
+            unresolved.set(providerRef, outcome.reason);
+        }
+    }
+    return { registry: composeBackendProviders({ modules }), unresolved };
+}
+//# sourceMappingURL=backend-provider-loader.backend.service.js.map

package/dist/esm/external-providers/services/backend-provider-loader.backend.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-provider-loader.backend.service.js","sourceRoot":"","sources":["../../../../src/external-providers/services/backend-provider-loader.backend.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The host-side provider LOADER: turn a process's declared provider refs into a composed backend\n * registry, importing only what that process declared (#330).\n *\n * ## The defect this replaces\n *\n * `BackendProviderRegistryBackendService` used to be initialised from the engine's eagerly composed\n * catalogue — twenty-two provider modules, six of which import an `@ai-sdk/*` client at module top\n * level — as a DEFAULT FIELD INITIALISER. Every backend, every minion and every worker therefore\n * evaluated every provider before the runtime artifact could filter anything, and a Node worker that\n * declared one email provider still paid for six model SDKs (audit finding BE-1). Worse, the reverse\n * was impossible: there was no by-ref resolution at all, so a provider shipped as its own npm package\n * could not be loaded even when the application declared it (BE-2, BE-3).\n *\n * ## Resolution order, and why it is this order\n *\n * For each ref the artifact declares:\n *\n * 1. **The application's own fragment** — a module the application constructed and handed to\n *    `initialize`. It is the most specific answer and it needs no import.\n * 2. **The engine's on-demand map** (`ENGINE_BACKEND_PROVIDER_LOADERS`). An engine-shipped ref never\n *    needs a declared package, which is what lets an application whose artifact predates the import\n *    map keep working unchanged.\n * 3. **The artifact's `providerRuntimeImports[ref]`** — a dynamic import of the package specifier\n *    `wildo config sync` recorded from that provider package's `./companion` contribution, read\n *    through the fixed `backendProviderFragment` convention.\n *\n * ## This function does not refuse\n *\n * A ref it cannot resolve is recorded in {@link BackendProviderResolution.unresolved} with the reason,\n * and resolution continues. The refusal stays where it already was — the artifact filter in\n * `BackendProviderRegistryBackendService`, which names every missing ref in one message — because two\n * refusal sites for one condition is how the two drift, and because a caller that resolved nothing\n * should still hear about ALL of its missing refs rather than the first one. What changes is that the\n * refusal can now say WHY each ref failed instead of only that it was absent from the catalogue.\n */\nimport {\n  composeBackendProviders,\n  ENGINE_BACKEND_PROVIDER_LOADERS,\n  readBackendProviderFragment,\n  type BackendProviderModule,\n  type BackendProviderRegistry,\n  type BackendProviderRegistryFragment,\n  type ProviderRef,\n} from '@wildo-ai/external-connectors-private/backend-runtime';\n\n/**\n * Exactly what the loader reads out of a generated provider-runtime artifact — and nothing else.\n *\n * Stated structurally rather than as `ProviderRuntimeArtifact` because FOUR hosts pass one, and they\n * do not all hold the same nominal type: the backend, minion and worker hold the engine's\n * `ProviderRuntimeArtifact` (`artifactKind: 'backend'`), while the companion holds the CLI's\n * `SaasRuntimeProvidersArtifact` (`artifactKind` is a five-member union). Both satisfy this shape.\n * The alternative was a cast at the companion's call site, which would assert across a package\n * boundary the very thing nobody had checked — so the contract is narrowed to what is actually used\n * instead, and every host satisfies it by construction.\n */\nexport interface DeclaredProviderTopology {\n  readonly providerRefs?: ReadonlyArray<string>;\n  readonly providerRuntimeImports?: Readonly<Record<string, string>>;\n  readonly scope?: { readonly providers?: Readonly<Record<string, unknown>> };\n}\n\n/** @wildo_source:part:start saas.external-providers.backend-provider-loader facet:layer:backend facet:family:provider-registry facet:audience:app-developer */\n/** How a host asks for the providers it declared. */\nexport interface BackendProviderResolutionRequest {\n  /**\n   * The generated topology for THIS process. Absent for a host that has none — a platform\n   * application that initialises its configuration later — which then receives the whole engine\n   * catalogue, exactly as it did before this loader existed.\n   */\n  readonly providerRuntime?: DeclaredProviderTopology;\n  /**\n   * Providers the application constructed itself, rather than declaring by package. Accepts a whole\n   * `BackendProviderRegistry` too: a registry IS a fragment plus its indexes.\n   */\n  readonly applicationFragment?: BackendProviderRegistryFragment;\n  /**\n   * The import used for package-declared providers. Overridable so a test can resolve a fixture\n   * package without publishing one; production passes nothing.\n   */\n  readonly importModule?: (specifier: string) => Promise<unknown>;\n}\n\nexport interface BackendProviderResolution {\n  /** Everything that resolved, composed (so the tier and arm fences have already run). */\n  readonly registry: BackendProviderRegistry;\n  /** `providerRef` -> why it could not be resolved. Empty on a clean resolution. */\n  readonly unresolved: ReadonlyMap<string, string>;\n}\n/** @wildo_source:part:end saas.external-providers.backend-provider-loader */\n\n/**\n * A variable-specifier dynamic import.\n *\n * The specifier is data — a package name a generated artifact recorded — so this cannot be a static\n * import and no bundler can follow it. That is inherent to loading a provider the engine does not\n * know about, and it is why a host that bundles its backend must keep provider packages external.\n */\nasync function importBySpecifier(specifier: string): Promise<unknown> {\n  return import(/* @vite-ignore */ /* webpackIgnore: true */ specifier);\n}\n\nfunction readDeclaredRefs(providerRuntime: DeclaredProviderTopology): string[] {\n  const declared = providerRuntime.providerRefs && providerRuntime.providerRefs.length > 0\n    ? providerRuntime.providerRefs\n    // Same fallback the artifact filter keeps: `providerRefs` is optional on the schema, so a\n    // hand-crafted artifact may carry only the scope.\n    : Object.keys(providerRuntime.scope?.providers ?? {});\n  return [...new Set(declared)].sort();\n}\n\nfunction describeThrown(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nasync function resolveOneProvider(input: {\n  providerRef: string;\n  applicationFragment?: BackendProviderRegistryFragment;\n  runtimeImportPath?: string;\n  importModule: (specifier: string) => Promise<unknown>;\n}): Promise<{ module: BackendProviderModule } | { reason: string }> {\n  const { applicationFragment, importModule, providerRef, runtimeImportPath } = input;\n\n  const applicationModule = applicationFragment?.modules.get(providerRef as ProviderRef);\n  if (applicationModule) {\n    return { module: applicationModule };\n  }\n\n  const engineLoader = ENGINE_BACKEND_PROVIDER_LOADERS.get(providerRef as ProviderRef);\n  if (engineLoader) {\n    try {\n      return { module: await engineLoader() };\n    } catch (error) {\n      return { reason: `the engine module failed to load: ${describeThrown(error)}` };\n    }\n  }\n\n  if (!runtimeImportPath) {\n    return {\n      reason: 'no package declares it — the generated provider runtime carries no import path for '\n        + 'this ref, and the engine does not ship it. Add the provider package as a dependency of the '\n        + 'runtime owner and re-run `wildo config sync`.',\n    };\n  }\n\n  let namespace: unknown;\n  try {\n    namespace = await importModule(runtimeImportPath);\n  } catch (error) {\n    return { reason: `importing \"${runtimeImportPath}\" failed: ${describeThrown(error)}` };\n  }\n\n  let fragment: BackendProviderRegistryFragment;\n  try {\n    fragment = readBackendProviderFragment(namespace, runtimeImportPath);\n  } catch (error) {\n    return { reason: describeThrown(error) };\n  }\n\n  const packageModule = fragment.modules.get(providerRef as ProviderRef);\n  if (!packageModule) {\n    const contributed = [...fragment.modules.keys()].map(String).sort();\n    return {\n      reason: `\"${runtimeImportPath}\" loaded but contributes no provider \"${providerRef}\"`\n        + (contributed.length > 0 ? ` (it contributes: ${contributed.join(', ')})` : ' (it contributes nothing)'),\n    };\n  }\n\n  return { module: packageModule };\n}\n\n/**\n * Resolve the backend provider registry for one host.\n *\n * Every declared ref is resolved concurrently: the imports are independent, and a serial loop would\n * make boot latency the sum of every provider package's evaluation.\n */\nexport async function resolveBackendProviderRegistry(\n  request: BackendProviderResolutionRequest,\n): Promise<BackendProviderResolution> {\n  const { applicationFragment, importModule = importBySpecifier, providerRuntime } = request;\n\n  if (!providerRuntime) {\n    /*\n     * No artifact: today's semantics, preserved deliberately. A platform application initialises its\n     * configuration after startup and never receives a generated topology, so narrowing it to the\n     * MAIN tier here would silently drop providers from a host that never asked for the change. It\n     * is lazy now rather than eager, which is all this branch can honestly improve — a host that\n     * declares nothing has told us nothing to filter on.\n     */\n    /*\n     * The application's own modules WIN, and the engine map is asked only for the refs it did not\n     * supply — the same precedence the declared-refs path uses below.\n     *\n     * Not merely for symmetry: `composeProviderRegistry` refuses two fragments that declare one ref,\n     * by design and with no silent override. An application that hands over a registry it composed\n     * ITSELF (the pre-#330 contract: `composeBackendProviders(EngineBackendProviderRegistryFragment,\n     * appFragment)`) carries every engine ref inside it, so composing the two would throw a conflict\n     * on a call that used to work. Filtering here is what keeps this branch behaviour-identical to\n     * the default-field-initialiser it replaced.\n     */\n    const engineOnlyRefs = [...ENGINE_BACKEND_PROVIDER_LOADERS.entries()]\n      .filter(([providerRef]) => !applicationFragment?.modules.has(providerRef));\n    const engineModules = await Promise.all(\n      engineOnlyRefs.map(async ([providerRef, load]) => [providerRef, await load()] as const),\n    );\n    return {\n      registry: composeBackendProviders(\n        { modules: new Map<ProviderRef, BackendProviderModule>(engineModules) },\n        ...(applicationFragment ? [applicationFragment] : []),\n      ),\n      unresolved: new Map<string, string>(),\n    };\n  }\n\n  const declaredRefs = readDeclaredRefs(providerRuntime);\n  const runtimeImports = providerRuntime.providerRuntimeImports ?? {};\n\n  const outcomes = await Promise.all(declaredRefs.map(async (providerRef) => ({\n    providerRef,\n    outcome: await resolveOneProvider({\n      providerRef,\n      applicationFragment,\n      runtimeImportPath: runtimeImports[providerRef],\n      importModule,\n    }),\n  })));\n\n  const modules = new Map<ProviderRef, BackendProviderModule>();\n  const unresolved = new Map<string, string>();\n  for (const { outcome, providerRef } of outcomes) {\n    if ('module' in outcome) {\n      modules.set(providerRef as ProviderRef, outcome.module);\n    } else {\n      unresolved.set(providerRef, outcome.reason);\n    }\n  }\n\n  return { registry: composeBackendProviders({ modules }), unresolved };\n}\n"]}

package/dist/esm/external-providers/services/backend-provider-registry.backend.service.d.ts

@@ -1,42 +1,41 @@
-import { type BackendProviderModule, type BackendProviderRegistry, type BackendProtocolBinding, type ProviderProtocolRuntimeContract } from '@wildo-ai/external-connectors-private/backend';
+import { type BackendProviderModule, type BackendProviderRegistry, type BackendProtocolBinding, type ProviderProtocolRuntimeContract } from '@wildo-ai/external-connectors-private/backend-runtime';
 import { ExternalProvider_ExchangeProtocol_Kind } from '@wildo-ai/external-connectors-models';
 import type { ProviderRuntimeArtifact } from '../../config/models/provider-runtime-artifact.backend.schemas';
 export declare class BackendProviderRegistryBackendService {
     private registry;
     /** @wildo_source:part:start saas.external-providers.backend-provider-registry.runtime-filter facet:layer:backend facet:family:provider-registry */
     /**
-     * Initialize the backend provider registry that all downstream services
-     * (auth, billing, notifications, …) will resolve through.
+     * Adopt the registry a host RESOLVED, and re-check it against what that host declared.
      *
-     * This is the seam that decides which providers a backend host can actually
-     * reach at runtime. A provider authored only in a NON-backend scope (e.g.
-     * `providers.scopes.frontendServices.<app>`) never enters this registry, so
-     * any backend feature keyed on it (billing, transactional email, server-side
-     * LLM calls) resolves nothing and fails at startup. Author the provider under
-     * `providers.scopes.backend` in `./wildo.saas.config.ts` AND declare a
-     * matching backend contribution (`runtimeTargets: [{ kind: 'backend' }]`) so
-     * `wildo config sync` lists its ref in the generated provider-runtime
-     * artifact — otherwise it is filtered out here.
+     * This is the seam that decides which providers a backend host can actually reach at runtime. A
+     * provider authored only in a NON-backend scope (e.g. `providers.scopes.frontendServices.<app>`)
+     * never enters this registry, so any backend feature keyed on it (billing, transactional email,
+     * server-side LLM calls) resolves nothing and fails at startup. Author the provider under
+     * `providers.scopes.backend` in `./wildo.saas.config.ts` so `wildo config sync` lists its ref in
+     * the generated provider-runtime artifact — otherwise it is filtered out here.
      *
      * Composition model:
      *
-     * 1. The **catalog** is the union of engine-shipped providers
-     *    (`EngineBackendProviderRegistry`) and any application-contributed
-     *    providers (passed in via `registry`). This is what is *available*.
-     * 2. The **runtime artifact** (`providerRuntime`, generated by
-     *    `wildo config sync` and imported by the application bootstrap)
-     *    declares which providers this specific backend process is *allowed*
-     *    to expose, scoped by the authored `providers.scopes.backend`.
-     * 3. The active registry is the catalog filtered to the artifact's
-     *    `providerRefs`. Any ref claimed by the artifact but missing from the
-     *    catalog is a deployment-time error and fails startup loudly — there
-     *    is no silent fallback to the unfiltered catalog.
+     * 1. The **runtime artifact** (`providerRuntime`, generated by `wildo config sync` and imported by
+     *    the application bootstrap) declares which providers this specific process may expose.
+     * 2. `resolveBackendProviderRegistry` LOADS exactly those refs — an application-supplied module
+     *    first, then the engine's on-demand map, then a dynamic import of the package the artifact
+     *    names — and hands the composed result here. Nothing a process did not declare is imported,
+     *    which is the whole point: a worker that declares one email provider evaluates one provider.
+     * 3. This method re-filters that registry to the artifact's `providerRefs` and REFUSES if any ref
+     *    is still missing. That is not redundant with the loader: the loader deliberately does not
+     *    throw, so this stays the one place a deployment gap is reported, and it reports ALL of them at
+     *    once rather than the first import that failed.
      *
-     * When `providerRuntime` is `undefined`, no filtering is applied and the
-     * full catalog is exposed (legacy / pre-materialization callers, and
-     * platform applications that initialize their config later).
+     * When `providerRuntime` is `undefined` no filtering is applied — the host declared no topology, so
+     * there is nothing to filter against, and the loader will have handed over the whole engine
+     * catalogue (platform applications that initialize their config later).
+     *
+     * `unresolvedReasons` carries the loader's per-ref explanation into the refusal below, so an
+     * operator is told WHY a ref did not resolve (no package declares it / the import threw / the
+     * package exports no fragment) instead of only that it was absent.
      */
-    initialize(registry?: BackendProviderRegistry, providerRuntime?: ProviderRuntimeArtifact): void;
+    initialize(registry: BackendProviderRegistry, providerRuntime?: ProviderRuntimeArtifact, unresolvedReasons?: ReadonlyMap<string, string>): void;
     /** @wildo_source:part:end saas.external-providers.backend-provider-registry.runtime-filter */
     getRegistry(): BackendProviderRegistry;
     getProvider(providerRef: string): BackendProviderModule | undefined;

package/dist/esm/external-providers/services/backend-provider-registry.backend.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"backend-provider-registry.backend.service.d.ts","sourceRoot":"","sources":["../../../../../src/external-providers/services/backend-provider-registry.backend.service.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACrC,MAAM,+CAA+C,CAAC;AACvD,OAAO,EAAE,sCAAsC,EAAE,MAAM,sCAAsC,CAAC;AAC9F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4EAA4E,CAAC;AA+B1H,qBACa,qCAAqC;IAChD,OAAO,CAAC,QAAQ,CAA0D;IAE1E,mJAAmJ;IACnJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,UAAU,CACR,QAAQ,GAAE,uBAAuD,EACjE,eAAe,CAAC,EAAE,uBAAuB,GACxC,IAAI;IAQP,8FAA8F;IAE9F,WAAW,IAAI,uBAAuB;IAItC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAInE,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAIzC,wBAAwB,CAAC,YAAY,EAAE,sCAAsC,GAAG,qBAAqB,EAAE;IAMvG,kBAAkB,CAChB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,sCAAsC,GACnD,sBAAsB,GAAG,SAAS;IAMrC,kBAAkB,CAChB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,sCAAsC,GACnD,+BAA+B,GAAG,SAAS;IAI9C,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,sCAAsC,EAAE;CAKhF"}
+{"version":3,"file":"backend-provider-registry.backend.service.d.ts","sourceRoot":"","sources":["../../../../src/external-providers/services/backend-provider-registry.backend.service.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,uBAAuB,EAC5B,KAAK,sBAAsB,EAC3B,KAAK,+BAA+B,EACrC,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAAE,sCAAsC,EAAE,MAAM,sCAAsC,CAAC;AAC9F,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4EAA4E,CAAC;AAkB1H,qBACa,qCAAqC;IAChD,OAAO,CAAC,QAAQ,CAA4D;IAE5E,mJAAmJ;IACnJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,UAAU,CACR,QAAQ,EAAE,uBAAuB,EACjC,eAAe,CAAC,EAAE,uBAAuB,EACzC,iBAAiB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC9C,IAAI;IAQP,8FAA8F;IAE9F,WAAW,IAAI,uBAAuB;IAItC,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,SAAS;IAInE,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAIzC,wBAAwB,CAAC,YAAY,EAAE,sCAAsC,GAAG,qBAAqB,EAAE;IAMvG,kBAAkB,CAChB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,sCAAsC,GACnD,sBAAsB,GAAG,SAAS;IAIrC,kBAAkB,CAChB,WAAW,EAAE,MAAM,EACnB,YAAY,EAAE,sCAAsC,GACnD,+BAA+B,GAAG,SAAS;IAI9C,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,sCAAsC,EAAE;CAGhF"}