@standardagents/builder 0.27.6 → 0.27.8-dev.b0d0355

package/dist/runtime.d.ts

@@ -3602,9 +3602,35 @@ interface ProviderLookupResult {
  */
 declare class ProviderRegistryImpl {
     private providerCache;
+    /** Why the last thread-scoped resolution did (not) contribute user env,
+     *  keyed by the env object handed back — surfaced in missing-variable
+     *  errors so a silent user-env failure is diagnosable from the log. */
+    private scopeDiagnostics;
     private providerOverrideFn;
     private providerOverrideRevision;
     setProviderOverride(fn: ProviderOverrideFn | null): void;
+    /**
+     * The env a provider resolves against for a given execution, scoped to the
+     * THREAD rather than just the instance: thread env overrides win, then the
+     * thread OWNER's user env, then instance/Worker env. This is what makes
+     * per-user BYOK providers work — a credential a user installs in their own
+     * account env (e.g. an OAuth token a companion service rotates) is honored
+     * for that user's threads no matter which authorized actor plays the turn.
+     *
+     * Best-effort by design: a missing user id (super-admin/local threads) or
+     * an older AgentBuilder DO without user-env storage simply contributes
+     * nothing, leaving instance-env behavior untouched.
+     */
+    buildThreadScopedEnv(state: {
+        env: Env;
+        thread: {
+            metadata?: {
+                user_id?: string | null;
+                env?: Record<string, unknown> | null;
+                tenvs?: Record<string, unknown> | null;
+            };
+        };
+    }): Promise<Env>;
     /**
      * Get provider for a model.
      *

package/dist/runtime.js

@@ -884,12 +884,64 @@ var init_ProviderRegistry = __esm({
     init_factory();
     ProviderRegistryImpl = class {
       providerCache = /* @__PURE__ */ new Map();
+      /** Why the last thread-scoped resolution did (not) contribute user env,
+       *  keyed by the env object handed back — surfaced in missing-variable
+       *  errors so a silent user-env failure is diagnosable from the log. */
+      scopeDiagnostics = /* @__PURE__ */ new WeakMap();
       providerOverrideFn = null;
       providerOverrideRevision = 0;
       setProviderOverride(fn) {
         this.providerOverrideFn = fn;
         this.providerOverrideRevision += 1;
       }
+      /**
+       * The env a provider resolves against for a given execution, scoped to the
+       * THREAD rather than just the instance: thread env overrides win, then the
+       * thread OWNER's user env, then instance/Worker env. This is what makes
+       * per-user BYOK providers work — a credential a user installs in their own
+       * account env (e.g. an OAuth token a companion service rotates) is honored
+       * for that user's threads no matter which authorized actor plays the turn.
+       *
+       * Best-effort by design: a missing user id (super-admin/local threads) or
+       * an older AgentBuilder DO without user-env storage simply contributes
+       * nothing, leaving instance-env behavior untouched.
+       */
+      async buildThreadScopedEnv(state) {
+        const threadEnv = state.thread.metadata?.env ?? state.thread.metadata?.tenvs ?? null;
+        const userId = state.thread.metadata?.user_id ?? null;
+        let userEnv = null;
+        let diagnostic = userId ? "" : "no thread user_id";
+        if (userId) {
+          try {
+            const agentBuilderId = state.env.AGENT_BUILDER.idFromName("singleton");
+            const agentBuilder = state.env.AGENT_BUILDER.get(agentBuilderId);
+            if (typeof agentBuilder.getUserEnvEntries === "function") {
+              const entries = await agentBuilder.getUserEnvEntries(userId);
+              if (Array.isArray(entries) && entries.length > 0) {
+                userEnv = {};
+                for (const entry of entries) {
+                  if (entry?.name) userEnv[entry.name] = entry.value;
+                }
+                diagnostic = `user env: ${Object.keys(userEnv).length} entries`;
+              } else {
+                diagnostic = `user env empty for ${userId} (entries: ${Array.isArray(entries) ? entries.length : typeof entries})`;
+              }
+            } else {
+              diagnostic = "singleton has no getUserEnvEntries";
+            }
+          } catch (error) {
+            diagnostic = `user env lookup failed: ${error instanceof Error ? error.message : String(error)}`;
+            console.warn("buildThreadScopedEnv:", diagnostic);
+          }
+        }
+        if (!userEnv && !threadEnv) {
+          this.scopeDiagnostics.set(state.env, diagnostic);
+          return state.env;
+        }
+        const merged = { ...state.env, ...userEnv ?? {}, ...threadEnv ?? {} };
+        this.scopeDiagnostics.set(merged, diagnostic);
+        return merged;
+      }
       /**
        * Get provider for a model.
        *
@@ -927,8 +979,9 @@ var init_ProviderRegistry = __esm({
         if (providerDefinition) {
           const resolved = resolveDefinedProviderConfig(providerDefinition, env);
           if (resolved.missing.length > 0) {
+            const scopeNote = this.scopeDiagnostics.get(env);
             throw new Error(
-              `Missing required environment variables for provider '${providerName}': ${resolved.missing.join(", ")}.`
+              `Missing required environment variables for provider '${providerName}': ${resolved.missing.join(", ")}.` + (scopeNote ? ` [thread-scoped env: ${scopeNote}]` : "")
             );
           }
           const config = resolved.providerConfig;
@@ -1801,7 +1854,8 @@ var init_LLMRequest = __esm({
        */
       static async callModel(modelId, context, state, logId) {
         const { ProviderRegistry: ProviderRegistry2 } = await Promise.resolve().then(() => (init_providers(), providers_exports));
-        const { provider, modelName, modelDef, viaPlatform, platformProxyOrigin } = await ProviderRegistry2.getProvider(modelId, state.env, state.thread.instance);
+        const providerEnv = await ProviderRegistry2.buildThreadScopedEnv(state);
+        const { provider, modelName, modelDef, viaPlatform, platformProxyOrigin } = await ProviderRegistry2.getProvider(modelId, providerEnv, state.thread.instance);
         const streamAbort = new AbortController();
         const parentSignal = state.abortController?.signal;
         let onParentAbort;