@stigmer/runner 3.22.0 → 3.22.1

package/src/activities/__tests__/workflow-event-activities.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, beforeEach, vi } from "vitest";
 import { toProtoEvent, initSequenceFromEventLog, emitWorkflowEvents, loadRecoveryContext } from "../workflow-event-activities.js";
+import { StigmerClient } from "../../client/stigmer-client.js";
 import { WorkflowEventType } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/event_pb";
 import { WorkflowTaskKind } from "@stigmer/protos/ai/stigmer/agentic/workflow/v1/enum_pb";
 import { WorkflowTaskStatus } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/enum_pb";
@@ -19,12 +20,9 @@ vi.mock("../../client/stigmer-client.js", () => ({
   })),
 }));
 
-vi.mock("../../config.js", () => ({
-  loadConfig: () => ({
-    stigmerBackendEndpoint: "http://localhost:7234",
-    stigmerToken: "test-token",
-  }),
-}));
+// The client the factory would build from the runner's Config; the mocked
+// constructor above is what it resolves to.
+const client = new StigmerClient({ endpoint: "http://localhost:7234" });
 
 const NOW = "2026-05-22T00:00:00.000Z";
 
@@ -34,7 +32,7 @@ describe("initSequenceFromEventLog", () => {
   });
 
   it("returns 0 and resets the legacy counter when executionId is empty", async () => {
-    const highWaterMark = await initSequenceFromEventLog("");
+    const highWaterMark = await initSequenceFromEventLog(client, "");
     expect(highWaterMark).toBe(0);
 
     const evt = toProtoEvent({
@@ -51,7 +49,7 @@ describe("initSequenceFromEventLog", () => {
   it("returns 0 when server has no events", async () => {
     mockGetEventLogHighWaterMark.mockResolvedValue(BigInt(0));
 
-    const highWaterMark = await initSequenceFromEventLog("wfx_test-1");
+    const highWaterMark = await initSequenceFromEventLog(client, "wfx_test-1");
     expect(highWaterMark).toBe(0);
 
     const evt = toProtoEvent({
@@ -67,7 +65,7 @@ describe("initSequenceFromEventLog", () => {
   it("returns the high-water mark as a plain number (Temporal payload converter cannot carry BigInt)", async () => {
     mockGetEventLogHighWaterMark.mockResolvedValue(BigInt(42));
 
-    const highWaterMark = await initSequenceFromEventLog("wfx_recovery-1");
+    const highWaterMark = await initSequenceFromEventLog(client, "wfx_recovery-1");
     expect(highWaterMark).toBe(42);
     expect(typeof highWaterMark).toBe("number");
   });
@@ -75,7 +73,7 @@ describe("initSequenceFromEventLog", () => {
   it("seeds the legacy counter so pre-patch replays continue from N+1", async () => {
     mockGetEventLogHighWaterMark.mockResolvedValue(BigInt(42));
 
-    await initSequenceFromEventLog("wfx_recovery-1");
+    await initSequenceFromEventLog(client, "wfx_recovery-1");
 
     const e1 = toProtoEvent({
       type: "task_started",
@@ -101,7 +99,7 @@ describe("initSequenceFromEventLog", () => {
   it("handles large sequence numbers", async () => {
     mockGetEventLogHighWaterMark.mockResolvedValue(BigInt(999999));
 
-    const highWaterMark = await initSequenceFromEventLog("wfx_large-seq");
+    const highWaterMark = await initSequenceFromEventLog(client, "wfx_large-seq");
     expect(highWaterMark).toBe(999999);
 
     const evt = toProtoEvent({
@@ -117,13 +115,13 @@ describe("initSequenceFromEventLog", () => {
   it("propagates server errors", async () => {
     mockGetEventLogHighWaterMark.mockRejectedValue(new Error("server unavailable"));
 
-    await expect(initSequenceFromEventLog("wfx_error-1")).rejects.toThrow("server unavailable");
+    await expect(initSequenceFromEventLog(client, "wfx_error-1")).rejects.toThrow("server unavailable");
   });
 });
 
 describe("toProtoEvent", () => {
   beforeEach(async () => {
-    await initSequenceFromEventLog("");
+    await initSequenceFromEventLog(client, "");
   });
 
   describe("sequence numbering", () => {
@@ -199,7 +197,7 @@ describe("toProtoEvent", () => {
         attemptNumber: 1,
       });
 
-      await initSequenceFromEventLog("");
+      await initSequenceFromEventLog(client, "");
 
       const evt = toProtoEvent({
         type: "task_started",
@@ -719,7 +717,7 @@ describe("emitWorkflowEvents", () => {
   });
 
   it("returns silently for empty events array", async () => {
-    await expect(emitWorkflowEvents("exec-1", [])).resolves.toBeUndefined();
+    await expect(emitWorkflowEvents(client, "exec-1", [])).resolves.toBeUndefined();
     expect(mockUpdateStatus).not.toHaveBeenCalled();
   });
 
@@ -731,14 +729,14 @@ describe("emitWorkflowEvents", () => {
       taskKind: "set",
       attemptNumber: 1,
     }];
-    await expect(emitWorkflowEvents("", events)).resolves.toBeUndefined();
+    await expect(emitWorkflowEvents(client, "", events)).resolves.toBeUndefined();
     expect(mockUpdateStatus).not.toHaveBeenCalled();
   });
 
   it("sends workflow-assigned sequence numbers through to the RPC", async () => {
     mockUpdateStatus.mockResolvedValue({});
 
-    await emitWorkflowEvents("exec-1", [{
+    await emitWorkflowEvents(client, "exec-1", [{
       type: "task_started",
       taskName: "t",
       occurredAt: NOW,
@@ -765,7 +763,7 @@ describe("emitWorkflowEvents", () => {
       sequenceNumber: 1,
     }];
 
-    await expect(emitWorkflowEvents("exec-1", events)).rejects.toThrow("server unavailable");
+    await expect(emitWorkflowEvents(client, "exec-1", events)).rejects.toThrow("server unavailable");
   });
 });
 
@@ -792,7 +790,7 @@ describe("loadRecoveryContext", () => {
       },
     });
 
-    const result = await loadRecoveryContext("wfx_test-1");
+    const result = await loadRecoveryContext(client, "wfx_test-1");
 
     expect(result).toHaveLength(2);
     expect(result[0]).toEqual({
@@ -810,7 +808,7 @@ describe("loadRecoveryContext", () => {
   it("returns empty array when execution has no status", async () => {
     mockGetWorkflowExecution.mockResolvedValue({});
 
-    const result = await loadRecoveryContext("wfx_empty-1");
+    const result = await loadRecoveryContext(client, "wfx_empty-1");
     expect(result).toEqual([]);
   });
 
@@ -819,7 +817,7 @@ describe("loadRecoveryContext", () => {
       status: { tasks: [] },
     });
 
-    const result = await loadRecoveryContext("wfx_no-tasks-1");
+    const result = await loadRecoveryContext(client, "wfx_no-tasks-1");
     expect(result).toEqual([]);
   });
 
@@ -836,7 +834,7 @@ describe("loadRecoveryContext", () => {
       },
     });
 
-    const result = await loadRecoveryContext("wfx_statuses-1");
+    const result = await loadRecoveryContext(client, "wfx_statuses-1");
 
     expect(result[0].status).toBe("started");
     expect(result[1].status).toBe("completed");
@@ -848,6 +846,6 @@ describe("loadRecoveryContext", () => {
   it("propagates server errors", async () => {
     mockGetWorkflowExecution.mockRejectedValue(new Error("server unavailable"));
 
-    await expect(loadRecoveryContext("wfx_error-1")).rejects.toThrow("server unavailable");
+    await expect(loadRecoveryContext(client, "wfx_error-1")).rejects.toThrow("server unavailable");
   });
 });

package/src/activities/attach-session.ts

@@ -37,7 +37,6 @@ import { TimingRecorder, emitTimingLog } from "../shared/cold-start-timing.js";
 export function createAttachSessionActivities(config: Config) {
   const client = new StigmerClient({
     endpoint: config.stigmerBackendEndpoint,
-    token: config.stigmerToken,
     tokenRef: config.stigmerTokenRef,
     runnerTokenRef: config.stigmerRunnerTokenRef,
   });

package/src/activities/call-agent-status.ts

@@ -10,22 +10,19 @@
  *   WorkflowExecution when a child agent enters a tool-approval gate.
  * - ClearWorkflowApprovalStatus: clears pending_approvals when the
  *   child agent activity completes (approvals resolved).
+ *
+ * The client is the factory's, built once from the runner's injected
+ * `Config` so it reads the live credential ref per request (config.ts
+ * header); the functions take it as an argument, which is also what a test
+ * hands them.
  */
 
 import { StigmerClient } from "../client/stigmer-client.js";
-import { loadConfig } from "../config.js";
+import type { Config } from "../config.js";
 import { create } from "@bufbuild/protobuf";
 import { WorkflowExecutionStatusSchema, WorkflowPendingApprovalSchema, WorkflowPendingFileReviewSchema } from "@stigmer/protos/ai/stigmer/agentic/workflowexecution/v1/api_pb";
 import { ToolCallStatus, FileChangeSetStatus } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
-function buildClient(): StigmerClient {
-  const config = loadConfig();
-  return new StigmerClient({
-    endpoint: config.stigmerBackendEndpoint,
-    token: config.stigmerToken,
-  });
-}
-
 /**
  * Derives the child's approval gate onto the parent (DD-012: identity-only
  * signal, derive-from-child). The signal carries only the child execution id;
@@ -40,13 +37,13 @@ function buildClient(): StigmerClient {
  * retry: surfacing a resolved gate would show users a stale approval card.
  */
 export async function updateWorkflowTaskApprovalStatus(
+  client: StigmerClient,
   executionId: string,
   _taskName: string,
   childExecutionId: string,
 ): Promise<boolean> {
   if (!executionId || !childExecutionId) return false;
 
-  const client = buildClient();
   const child = await client.getExecution(childExecutionId);
   const pendingApprovals = (child?.status?.pendingApprovals ?? []).map(
     (approval) =>
@@ -74,12 +71,12 @@ export async function updateWorkflowTaskApprovalStatus(
 }
 
 export async function clearWorkflowApprovalStatus(
+  client: StigmerClient,
   executionId: string,
   childExecutionId: string,
 ): Promise<void> {
   if (!executionId || !childExecutionId) return;
 
-  const client = buildClient();
   const status = create(WorkflowExecutionStatusSchema, {
     pendingApprovals: [],
   });
@@ -101,13 +98,13 @@ export async function clearWorkflowApprovalStatus(
  * child's entry (per-child merge, so parallel siblings are never disturbed).
  */
 export async function updateWorkflowFileReviewStatus(
+  client: StigmerClient,
   executionId: string,
   childExecutionId: string,
   changeSetIds: string[],
 ): Promise<void> {
   if (!executionId || !childExecutionId) return;
 
-  const client = buildClient();
   const pendingFileReviews =
     changeSetIds.length > 0
       ? [
@@ -135,12 +132,12 @@ export async function updateWorkflowFileReviewStatus(
  * (the same reason getAgentExecutionProgress reads status.messages).
  */
 export async function getAwaitingFileReviewChangeSetIds(
+  client: StigmerClient,
   childExecutionId: string,
 ): Promise<string[]> {
   if (!childExecutionId) return [];
 
   try {
-    const client = buildClient();
     const execution = await client.getExecution(childExecutionId);
     const changeSets = execution?.status?.fileChangeSets ?? [];
     return changeSets
@@ -169,12 +166,12 @@ export interface AgentProgressSummary {
 }
 
 export async function getAgentExecutionProgress(
+  client: StigmerClient,
   childExecutionId: string,
 ): Promise<AgentProgressSummary | null> {
   if (!childExecutionId) return null;
 
   try {
-    const client = buildClient();
     const execution = await client.getExecution(childExecutionId);
     const status = execution?.status;
     if (!status) return null;
@@ -206,12 +203,23 @@ export async function getAgentExecutionProgress(
   }
 }
 
-export function createCallAgentStatusActivities() {
+export function createCallAgentStatusActivities(config: Config) {
+  const client = new StigmerClient({
+    endpoint: config.stigmerBackendEndpoint,
+    tokenRef: config.stigmerTokenRef,
+    runnerTokenRef: config.stigmerRunnerTokenRef,
+  });
+
   return {
-    UpdateWorkflowTaskApprovalStatus: updateWorkflowTaskApprovalStatus,
-    ClearWorkflowApprovalStatus: clearWorkflowApprovalStatus,
-    UpdateWorkflowFileReviewStatus: updateWorkflowFileReviewStatus,
-    GetAwaitingFileReviewChangeSetIds: getAwaitingFileReviewChangeSetIds,
-    GetAgentExecutionProgress: getAgentExecutionProgress,
+    UpdateWorkflowTaskApprovalStatus: (executionId: string, taskName: string, childExecutionId: string) =>
+      updateWorkflowTaskApprovalStatus(client, executionId, taskName, childExecutionId),
+    ClearWorkflowApprovalStatus: (executionId: string, childExecutionId: string) =>
+      clearWorkflowApprovalStatus(client, executionId, childExecutionId),
+    UpdateWorkflowFileReviewStatus: (executionId: string, childExecutionId: string, changeSetIds: string[]) =>
+      updateWorkflowFileReviewStatus(client, executionId, childExecutionId, changeSetIds),
+    GetAwaitingFileReviewChangeSetIds: (childExecutionId: string) =>
+      getAwaitingFileReviewChangeSetIds(client, childExecutionId),
+    GetAgentExecutionProgress: (childExecutionId: string) =>
+      getAgentExecutionProgress(client, childExecutionId),
   };
 }

package/src/activities/call-agent.ts

@@ -22,7 +22,7 @@
 import { randomUUID } from "node:crypto";
 import { Context, CompleteAsyncError } from "@temporalio/activity";
 import { StigmerClient } from "../client/stigmer-client.js";
-import { loadConfig, type Config } from "../config.js";
+import type { Config } from "../config.js";
 import { resolveObjectPlaceholders } from "../workflow-engine/resolve.js";
 import type { AgentCallConfig } from "../workflow-engine/types.js";
 import { startHeartbeat } from "../shared/heartbeat.js";
@@ -49,7 +49,7 @@ export async function callAgentAction(
   config: AgentCallConfig,
   runtimeEnv: Record<string, unknown>,
   parentWorkflowId: string,
-  appConfig: Config = loadConfig(),
+  appConfig: Config,
 ): Promise<void> {
   const taskToken = Context.current().info.taskToken;
 
@@ -84,16 +84,15 @@ export async function callAgentAction(
 
   const client = new StigmerClient({
     endpoint: appConfig.stigmerBackendEndpoint,
-    token: appConfig.stigmerToken,
     tokenRef: appConfig.stigmerTokenRef,
     // The child-execution create must authenticate as the RUNNER, not the
     // user: it stamps the workflow lineage labels, which cloud's
     // reserved-label guard and environment composer accept only from
     // runner-class callers. The client's credential-selection table routes
     // exactly that create to this credential; null (OSS/local, no mint)
-    // falls through to the control-plane token unchanged. The refs live only
-    // on the runner's INJECTED Config (loadConfig() rebuilds from env and
-    // never carries them), which is why the factory passes it in.
+    // falls through to the control-plane token unchanged. The refs are the
+    // runner's injected Config's (config.ts header), which is why the factory
+    // passes it in.
     runnerTokenRef: appConfig.stigmerRunnerTokenRef,
   });
 

package/src/activities/call-function.ts

@@ -17,6 +17,8 @@
  */
 
 import { ApplicationFailure } from "@temporalio/activity";
+import { StigmerClient } from "../client/stigmer-client.js";
+import type { Config } from "../config.js";
 import { callLlmAction, type LlmCallConfig } from "./call-llm.js";
 import { callEvalAction, type EvalConfig } from "./call-eval.js";
 import { emitEventAction, type EmitEventConfig } from "./emit-event.js";
@@ -30,6 +32,7 @@ export async function callFunctionAction(
   config: Record<string, unknown>,
   runtimeEnv: Record<string, unknown>,
   executionId: string,
+  client: StigmerClient,
 ): Promise<unknown> {
   const resolved = resolveObjectPlaceholders(config, runtimeEnv) as Record<string, unknown>;
 
@@ -39,7 +42,7 @@ export async function callFunctionAction(
     case "eval":
       return callEvalAction(resolved as unknown as EvalConfig, runtimeEnv, executionId);
     case "emit_event":
-      return emitEventAction(resolved as unknown as EmitEventConfig, executionId, runtimeEnv);
+      return emitEventAction(resolved as unknown as EmitEventConfig, executionId, runtimeEnv, client);
     case "notification":
       return notificationAction(resolved as unknown as NotificationConfig, runtimeEnv);
     case "transform":
@@ -59,7 +62,16 @@ export async function callFunctionAction(
   }
 }
 
-export function createCallFunctionActivities() {
+export function createCallFunctionActivities(runnerConfig: Config) {
+  // The signal-delivery client for emit_event, one per factory from the
+  // runner's injected Config: it reads the live credential ref per request
+  // (config.ts header), so a rotation reaches every signal it sends.
+  const client = new StigmerClient({
+    endpoint: runnerConfig.stigmerBackendEndpoint,
+    tokenRef: runnerConfig.stigmerTokenRef,
+    runnerTokenRef: runnerConfig.stigmerRunnerTokenRef,
+  });
+
   return {
     CallFunction: async (
       call: string,
@@ -67,7 +79,7 @@ export function createCallFunctionActivities() {
       runtimeEnv: Record<string, unknown>,
       executionId: string,
     ): Promise<unknown> => {
-      return callFunctionAction(call, config, runtimeEnv, executionId);
+      return callFunctionAction(call, config, runtimeEnv, executionId, client);
     },
   };
 }

package/src/activities/classify-tool-approvals.ts

@@ -420,7 +420,7 @@ export function createClassifyToolApprovalsActivities(config: Config) {
         // serve /v1/proxy/model-registry; that fallback does not port here.)
         return await classifyTools(input, {
           proxyEndpoint: config.proxyEndpoint,
-          stigmerToken: config.stigmerToken,
+          stigmerToken: config.stigmerTokenRef.current,
           primaryModel: config.primaryModel,
         });
       } finally {

package/src/activities/discover-mcp-server.ts

@@ -613,7 +613,6 @@ async function classifyHttpOAuthFailure(
 export function createDiscoverMcpServerActivities(config: Config) {
   const stigmerClient = new StigmerClient({
     endpoint: config.stigmerBackendEndpoint,
-    token: config.stigmerToken,
     tokenRef: config.stigmerTokenRef,
     runnerTokenRef: config.stigmerRunnerTokenRef,
   });

package/src/activities/emit-event.ts

@@ -21,13 +21,16 @@
  * holding a different key. The server re-produces the payload, so each
  * side's codec passes it through.
  *
+ * The signal client is the caller's (`call-function.ts` builds one from the
+ * runner's injected `Config`, so it reads the live credential ref per
+ * request; config.ts header). This module constructs no client of its own.
+ *
  * CloudEvents spec: https://github.com/cloudevents/spec/blob/v1.0.2/cloudevents/spec.md
  */
 
 import { randomUUID } from "node:crypto";
 import type { JsonObject } from "@bufbuild/protobuf";
-import { StigmerClient } from "../client/stigmer-client.js";
-import { loadConfig } from "../config.js";
+import type { StigmerClient } from "../client/stigmer-client.js";
 import { resolveRuntimePlaceholders } from "../workflow-engine/resolve.js";
 
 export interface WebhookDeliveryTarget {
@@ -139,14 +142,6 @@ async function deliverWebhook(
   }
 }
 
-function buildClient(): StigmerClient {
-  const config = loadConfig();
-  return new StigmerClient({
-    endpoint: config.stigmerBackendEndpoint,
-    token: config.stigmerToken,
-  });
-}
-
 async function deliverSignal(
   envelope: Record<string, unknown>,
   target: SignalDeliveryTarget,
@@ -194,7 +189,8 @@ async function deliverSignal(
 export async function emitEventAction(
   config: EmitEventConfig,
   executionId: string,
-  runtimeEnv?: Record<string, unknown>,
+  runtimeEnv: Record<string, unknown> | undefined,
+  client: StigmerClient,
 ): Promise<Record<string, unknown>> {
   if (!config.event) {
     throw new Error("emit_event: 'event' field is required");
@@ -212,17 +208,12 @@ export async function emitEventAction(
   const errors: DeliveryError[] = [];
   const env = runtimeEnv ?? {};
 
-  // One client serves all signal targets of this emit; constructed lazily so
-  // webhook-only emits never pay for a gRPC transport.
-  let client: StigmerClient | undefined;
-
   for (const target of config.delivery) {
     let err: DeliveryError | null = null;
 
     if ("webhook" in target) {
       err = await deliverWebhook(envelope, target.webhook, env);
     } else if ("signal" in target) {
-      client ??= buildClient();
       err = await deliverSignal(envelope, target.signal, client);
     }
 

package/src/activities/execute-cursor/__test-utils__/hermetic-cursor.ts

@@ -147,7 +147,7 @@ export function hermeticCursorConfig(env: HermeticEnvironment): Config {
     temporalNamespace: "default",
     stigmerBackendEndpoint: "http://localhost:7234",
     mcpBridgeEndpoint: null,
-    stigmerToken: null,
+    stigmerTokenRef: { current: null },
     cursorApiKey: FIXTURE.cursorApiKey,
     workspaceRootDir: env.workspaceRootDir,
     mode: "local",

package/src/activities/execute-cursor/adapter.ts

@@ -66,7 +66,6 @@ export function resolveCursorConfig(config: Config): CursorAdapterConfig {
   return {
     proxyEndpoint: config.proxyEndpoint,
     cursorApiKey: config.cursorApiKey,
-    stigmerToken: config.stigmerToken,
     stigmerTokenRef: config.stigmerTokenRef,
     workspaceRootDir: config.workspaceRootDir,
     cloudModeEnabled: config.cloudModeEnabled,

package/src/activities/execute-cursor/turn-setup.ts

@@ -81,7 +81,7 @@ import { installHitlGate, removeHitlGate, type HitlGateHandle } from "./workspac
  */
 export type CursorAdapterConfig = Pick<
   Config,
-  "proxyEndpoint" | "cursorApiKey" | "stigmerToken" | "stigmerTokenRef" | "workspaceRootDir" | "cloudModeEnabled" | "agentResolveTimeoutMs"
+  "proxyEndpoint" | "cursorApiKey" | "stigmerTokenRef" | "workspaceRootDir" | "cloudModeEnabled" | "agentResolveTimeoutMs"
 >;
 
 export type CursorAgentMode = "cloud" | "local";
@@ -309,19 +309,18 @@ export async function resolveEngine(input: TurnInput, sink: TurnSink, config: Cu
 
   await sink.reportProgress("Initializing Cursor agent");
 
-  // In proxy mode, use the stigmer token as the API key — the proxy
-  // validates it and injects the real Cursor API key server-side.
-  // In direct mode, use the user's own CURSOR_API_KEY.
+  // In proxy mode, the SDK's API key is the control-plane credential, read
+  // from the ref now (per turn) — the proxy validates it and injects the real
+  // Cursor API key server-side. In direct mode, the user's own CURSOR_API_KEY.
   const effectiveApiKey = config.proxyEndpoint
-    ? (config.stigmerTokenRef?.current ?? config.stigmerToken ?? config.cursorApiKey)
+    ? config.stigmerTokenRef.current
     : config.cursorApiKey;
   if (!effectiveApiKey || effectiveApiKey === "proxy-managed") {
     const source = config.proxyEndpoint ? "proxy (STIGMER_TOKEN)" : "direct (CURSOR_API_KEY)";
     throw new Error(
       `No Cursor API credential available. Mode=${source}, ` +
         `proxyEndpoint=${config.proxyEndpoint ?? "unset"}, ` +
-        `hasStigmerToken=${!!config.stigmerToken}, ` +
-        `hasTokenRef=${!!config.stigmerTokenRef?.current}`,
+        `hasStigmerToken=${!!config.stigmerTokenRef.current}`,
     );
   }
 

package/src/activities/execute-deep-agent/__test-utils__/hermetic-deep-agent.ts

@@ -145,7 +145,7 @@ export function hermeticDeepAgentConfig(env: HermeticEnvironment, checkpointerTy
     temporalNamespace: "default",
     stigmerBackendEndpoint: "http://localhost:7234",
     mcpBridgeEndpoint: null,
-    stigmerToken: null,
+    stigmerTokenRef: { current: null },
     cursorApiKey: "",
     workspaceRootDir: env.workspaceRootDir,
     mode: "local",

package/src/activities/execute-deep-agent/__tests__/adapter.test.ts

@@ -25,7 +25,7 @@ const CONFIG: Config = {
   temporalNamespace: "default",
   stigmerBackendEndpoint: "http://localhost:7234",
   mcpBridgeEndpoint: null,
-  stigmerToken: "tok",
+  stigmerTokenRef: { current: "tok" },
   cursorApiKey: "",
   workspaceRootDir: "/tmp/adapter-test",
   mode: "local",
@@ -72,7 +72,7 @@ describe("createDeepAgentAdapter", () => {
     expect(resolveDeepAgentConfig(CONFIG)).toEqual({
       checkpointerType: "memory",
       checkpointerProxyEndpoint: null,
-      stigmerToken: "tok",
+      stigmerTokenRef: { current: "tok" },
       proxyEndpoint: null,
       mode: "local",
     });

package/src/activities/execute-deep-agent/__tests__/summarization-verification.test.ts

@@ -112,7 +112,7 @@ describe("computeSummarizationDefaults", () => {
 // ── 2. Checkpoint Serialization Roundtrip ───────────────────────────
 
 describe("summarization state checkpoint serialization", () => {
-  const saver = new HttpCheckpointSaver("https://proxy.test", "test-token");
+  const saver = new HttpCheckpointSaver("https://proxy.test", { current: "test-token" });
 
   it("serializes and deserializes _summarizationEvent through JsonPlusSerializer", async () => {
     const summarizationEvent = {

package/src/activities/execute-deep-agent/adapter.ts

@@ -44,7 +44,7 @@ export function resolveDeepAgentConfig(config: Config): DeepAgentAdapterConfig {
   return {
     checkpointerType: config.checkpointerType,
     checkpointerProxyEndpoint: config.checkpointerProxyEndpoint,
-    stigmerToken: config.stigmerToken,
+    stigmerTokenRef: config.stigmerTokenRef,
     proxyEndpoint: config.proxyEndpoint,
     mode: config.mode,
   };

package/src/activities/execute-deep-agent/turn-setup.ts

@@ -85,7 +85,7 @@ import { modelHasNativeThinking, transformAndCompileSubagents } from "./subagent
  */
 export type DeepAgentAdapterConfig = Pick<
   Config,
-  "checkpointerType" | "checkpointerProxyEndpoint" | "stigmerToken" | "proxyEndpoint" | "mode"
+  "checkpointerType" | "checkpointerProxyEndpoint" | "stigmerTokenRef" | "proxyEndpoint" | "mode"
 >;
 
 /** The deepagents graph as this module holds it; deepagents exports no stable type for the compiled agent. */
@@ -164,7 +164,7 @@ export async function openCheckpointer(input: TurnInput, sink: TurnSink, config:
   const checkpointer = await createCheckpointer({
     type: config.checkpointerType,
     proxyEndpoint: config.checkpointerProxyEndpoint ?? undefined,
-    authToken: config.stigmerToken ?? undefined,
+    authToken: config.stigmerTokenRef,
     sqlitePath: config.checkpointerType === "sqlite" ? await ensureCheckpointDbPath(input.sessionId) : undefined,
   });
   sink.setupTiming.mark("create_checkpointer");
@@ -340,12 +340,14 @@ export async function buildEngine(
 
   // The model. Resolution to the provider API id happens inside
   // buildChatModel; modelName stays the registry id for pricing, the
-  // native-thinking heuristic, and sub-agent inheritance.
+  // native-thinking heuristic, and sub-agent inheritance. The credential is
+  // read from the ref at build, once per turn: a LangChain client carries
+  // its headers for its life, so this is the freshest a turn's model can be.
   const buildModelFor = async (name: string) =>
     (await buildChatModel({
       modelName: name,
       proxyEndpoint: config.proxyEndpoint ?? undefined,
-      stigmerToken: config.stigmerToken ?? undefined,
+      stigmerToken: config.stigmerTokenRef.current ?? undefined,
       headerScope: { executionId },
       serviceTier: input.model.serviceTier,
     })).model;

package/src/activities/generate-session-subject.ts

@@ -376,7 +376,6 @@ export interface GenerateSessionSubjectInput {
 export function createGenerateSessionSubjectActivities(config: Config) {
   const client = new StigmerClient({
     endpoint: config.stigmerBackendEndpoint,
-    token: config.stigmerToken,
     tokenRef: config.stigmerTokenRef,
     runnerTokenRef: config.stigmerRunnerTokenRef,
   });
@@ -391,7 +390,7 @@ export function createGenerateSessionSubjectActivities(config: Config) {
         log(`started: execution=${executionId}`);
         await generateSessionSubject(executionId, client, {
           proxyEndpoint: config.proxyEndpoint,
-          stigmerToken: config.stigmerToken,
+          stigmerToken: config.stigmerTokenRef.current,
           primaryModel: config.primaryModel,
         });
       } finally {

package/src/activities/hydrate-workflow-execution.ts

@@ -31,7 +31,6 @@ export interface HydrateInput {
 export function createHydrateWorkflowActivities(config: Config) {
   const client = new StigmerClient({
     endpoint: config.stigmerBackendEndpoint,
-    token: config.stigmerToken,
     tokenRef: config.stigmerTokenRef,
     runnerTokenRef: config.stigmerRunnerTokenRef,
   });