@stigmer/runner 3.12.3 → 3.12.5

package/src/workflow-engine/__tests__/loader.test.ts

@@ -1528,6 +1528,57 @@ do:
       }
     });
 
+    // The server converter persists on_timeout as the proto enum NAME
+    // (HumanInputTimeoutPolicy.String()), so every applied workflow carries
+    // that form in its validated YAML. stigmer/stigmer#779: the loader used
+    // to cast it unvalidated, and the orchestrator's switch silently treated
+    // the unrecognized string as fail.
+    const humanInputYamlWithOnTimeout = (onTimeout: string) => `
+document:
+  dsl: '1.0.0'
+  name: test
+do:
+  - timedApproval:
+      call: human_input
+      with:
+        prompt: "Approve within time limit"
+        timeout: 3600
+        on_timeout: ${onTimeout}
+`;
+
+    it("call: human_input normalizes proto enum-name on_timeout values to the internal policy words", () => {
+      const cases = [
+        ["HUMAN_INPUT_TIMEOUT_FAIL", "fail"],
+        ["HUMAN_INPUT_TIMEOUT_APPROVE", "approve"],
+        ["HUMAN_INPUT_TIMEOUT_DENY", "deny"],
+      ] as const;
+      for (const [wireForm, internalForm] of cases) {
+        const model = loadWorkflowFromYaml(humanInputYamlWithOnTimeout(wireForm));
+        const task = model.do[0].task;
+        expect(task.kind).toBe("human_input");
+        if (task.kind === "human_input") {
+          expect(task.humanInput.onTimeout).toBe(internalForm);
+        }
+      }
+    });
+
+    it("call: human_input rejects the not-implemented escalate policy at load time", () => {
+      for (const form of ["HUMAN_INPUT_TIMEOUT_ESCALATE", "escalate"]) {
+        expect(() => loadWorkflowFromYaml(humanInputYamlWithOnTimeout(form)))
+          .toThrow(/timedApproval.*escalate.*not implemented/);
+      }
+    });
+
+    it("call: human_input rejects unknown on_timeout values instead of silently failing at timeout", () => {
+      expect(() => loadWorkflowFromYaml(humanInputYamlWithOnTimeout("sometimes")))
+        .toThrow(/timedApproval.*unknown on_timeout value 'sometimes'.*fail, approve, deny/);
+    });
+
+    it("call: human_input rejects non-string on_timeout values", () => {
+      expect(() => loadWorkflowFromYaml(humanInputYamlWithOnTimeout("42")))
+        .toThrow(/timedApproval.*on_timeout/);
+    });
+
     it("call: human_input with payload and ui_hint", () => {
       const yaml = `
 document:

package/src/workflow-engine/__tests__/tasks/call-function.test.ts

@@ -208,6 +208,111 @@ describe("CallFunctionTaskBuilder", () => {
   // The config resolver must never pre-evaluate them — the pre-fix
   // behavior substituted the evaluated boolean back into the config and
   // crashed the validate activity with `expr.includes is not a function`.
+  describe("llm on_invalid policy orchestration (#686)", () => {
+    const schemaTaskDef = (extra: Record<string, unknown>): CallFunctionTaskDef => ({
+      kind: "call:function",
+      call: "llm",
+      with: {
+        model: "gpt-4o-mini",
+        prompt: "Classify",
+        response_schema: { type: "object", properties: { answer: { type: "number" } } },
+        ...extra,
+      },
+    });
+
+    const invalidResult = {
+      result: undefined, model: "gpt-4o-mini", provider: "openai",
+      input_tokens: 0, output_tokens: 0, parse_error: "answer: Required",
+    };
+    const validResult = {
+      result: { answer: 42 }, model: "gpt-4o-mini", provider: "openai",
+      input_tokens: 10, output_tokens: 5,
+    };
+
+    it("ON_INVALID_RETRY re-prompts with the validation errors and succeeds", async () => {
+      mockCallFunction
+        .mockResolvedValueOnce(invalidResult)
+        .mockResolvedValueOnce(validResult);
+
+      const builder = new CallFunctionTaskBuilder(
+        "classify", schemaTaskDef({ on_invalid: "ON_INVALID_RETRY", max_retries: 2 }),
+      );
+      const result = await builder.build()(null, createState(), makeCtx());
+
+      expect(result).toMatchObject({ structured: { answer: 42 } });
+      expect(mockCallFunction).toHaveBeenCalledTimes(2);
+      const retryConfig = mockCallFunction.mock.calls[1][1] as Record<string, unknown>;
+      expect(retryConfig.prompt).toContain("Classify");
+      expect(retryConfig.prompt).toContain("answer: Required");
+      expect(retryConfig.prompt).toContain("RETRY");
+    });
+
+    it("ON_INVALID_RETRY exhausts max_retries then fails without a fallback_task", async () => {
+      mockCallFunction.mockResolvedValue(invalidResult);
+
+      const builder = new CallFunctionTaskBuilder(
+        "classify", schemaTaskDef({ on_invalid: "ON_INVALID_RETRY", max_retries: 2 }),
+      );
+
+      await expect(builder.build()(null, createState(), makeCtx()))
+        .rejects.toThrow(/validation failed after 3 attempt\(s\).*answer: Required/);
+      // first attempt + max_retries retries
+      expect(mockCallFunction).toHaveBeenCalledTimes(3);
+    });
+
+    it("ON_INVALID_RETRY defaults max_retries to 1 (proto contract)", async () => {
+      mockCallFunction.mockResolvedValue(invalidResult);
+
+      const builder = new CallFunctionTaskBuilder(
+        "classify", schemaTaskDef({ on_invalid: "ON_INVALID_RETRY" }),
+      );
+
+      await expect(builder.build()(null, createState(), makeCtx())).rejects.toThrow();
+      expect(mockCallFunction).toHaveBeenCalledTimes(2);
+    });
+
+    it("exhausted retries branch to fallback_task when set", async () => {
+      mockCallFunction.mockResolvedValue(invalidResult);
+
+      const builder = new CallFunctionTaskBuilder(
+        "classify",
+        schemaTaskDef({ on_invalid: "ON_INVALID_RETRY", max_retries: 1, fallback_task: "human_review" }),
+      );
+      const result = await builder.build()(null, createState(), makeCtx());
+
+      expect(result).toEqual({
+        __flow_directive__: "human_review",
+        validation_errors: ["answer: Required"],
+      });
+      expect(mockCallFunction).toHaveBeenCalledTimes(2);
+    });
+
+    it("ON_INVALID_FALLBACK branches immediately without retrying", async () => {
+      mockCallFunction.mockResolvedValue(invalidResult);
+
+      const builder = new CallFunctionTaskBuilder(
+        "classify",
+        schemaTaskDef({ on_invalid: "ON_INVALID_FALLBACK", fallback_task: "human_review" }),
+      );
+      const result = await builder.build()(null, createState(), makeCtx());
+
+      expect(result).toMatchObject({ __flow_directive__: "human_review" });
+      expect(mockCallFunction).toHaveBeenCalledTimes(1);
+    });
+
+    it("a parse_error without a soft policy passes through as normal output (activity owns the failure)", async () => {
+      // Default policy: the activity throws LLM_SCHEMA_VALIDATION itself and
+      // never returns parse_error — the engine must not add a second layer.
+      mockCallFunction.mockResolvedValue(validResult);
+
+      const builder = new CallFunctionTaskBuilder("classify", schemaTaskDef({}));
+      const result = await builder.build()(null, createState(), makeCtx());
+
+      expect(result).toMatchObject({ structured: { answer: 42 } });
+      expect(mockCallFunction).toHaveBeenCalledTimes(1);
+    });
+  });
+
   describe("deferred expression fields", () => {
     it("passes validate rules[].expression through unresolved while input and message interpolate", async () => {
       mockCallFunction.mockResolvedValue({ valid: true, errors: [] });

package/src/workflow-engine/__tests__/tasks/human-input.test.ts

@@ -246,6 +246,123 @@ describe("executeHumanInputTask", () => {
     });
   });
 
+  // HumanInputTaskConfig.outcomes contract (human_input.proto): with custom
+  // outcomes, timeout auto-approve resolves to the FIRST outcome and timeout
+  // auto-deny to the LAST — downstream `then` routing and outcome switches
+  // must see declared outcome names, never the internal approve/deny words a
+  // reviewer was never offered. stigmer/stigmer#779 made this path reachable
+  // for the first time.
+  describe("timeout outcome mapping with custom outcomes", () => {
+    const outcomes = [
+      { name: "proceed", label: "Proceed", then: "deployStep" },
+      { name: "needs_revision", label: "Needs revision", then: "gatherMore" },
+      { name: "reject", label: "Reject" },
+    ];
+
+    it("maps timeout auto-approve to the FIRST outcome and routes its then", async () => {
+      const awaitFn: AwaitHumanInputFn = async () => ({
+        outcome: "approve",
+        auto_resolved: true,
+        reason: "timeout",
+      });
+
+      const taskDef: HumanInputTaskDef = {
+        kind: "human_input",
+        humanInput: { prompt: "Review", timeout: 5, onTimeout: "approve", outcomes },
+      };
+
+      const state = createState();
+      const result = await executeHumanInputTask(taskDef, "gate", state, makeCtx(awaitFn));
+
+      expect(result).toEqual({
+        outcome: "proceed",
+        auto_resolved: true,
+        reason: "timeout",
+        __flow_directive__: "deployStep",
+      });
+      expect(state.data.gate).toEqual({
+        outcome: "proceed",
+        auto_resolved: true,
+        reason: "timeout",
+      });
+    });
+
+    it("maps timeout auto-deny to the LAST outcome", async () => {
+      const awaitFn: AwaitHumanInputFn = async () => ({
+        outcome: "deny",
+        auto_resolved: true,
+        reason: "timeout",
+      });
+
+      const taskDef: HumanInputTaskDef = {
+        kind: "human_input",
+        humanInput: { prompt: "Review", timeout: 5, onTimeout: "deny", outcomes },
+      };
+
+      const result = await executeHumanInputTask(taskDef, "gate", createState(), makeCtx(awaitFn));
+
+      // "reject" is the last outcome and declares no `then` — no directive.
+      expect(result).toEqual({ outcome: "reject", auto_resolved: true, reason: "timeout" });
+    });
+
+    it("reports the mapped outcome on the approval_resolved event", async () => {
+      const emitted: WorkflowEventDescriptor[][] = [];
+      const emitFn: EmitEventsFn = async (events) => { emitted.push(events); };
+      const awaitFn: AwaitHumanInputFn = async () => ({
+        outcome: "approve",
+        auto_resolved: true,
+        reason: "timeout",
+      });
+
+      const taskDef: HumanInputTaskDef = {
+        kind: "human_input",
+        humanInput: { prompt: "Review", timeout: 5, onTimeout: "approve", outcomes },
+      };
+
+      await executeHumanInputTask(taskDef, "gate", createState(), makeCtx(awaitFn, emitFn));
+
+      const resolved = emitted.flat().find((e) => e.type === "approval_resolved");
+      expect(resolved).toMatchObject({ outcome: "proceed", autoResolved: true });
+    });
+
+    it("leaves reviewer-selected outcomes untouched", async () => {
+      const awaitFn: AwaitHumanInputFn = async () => ({
+        outcome: "needs_revision",
+        reviewer: "alice",
+      });
+
+      const taskDef: HumanInputTaskDef = {
+        kind: "human_input",
+        humanInput: { prompt: "Review", timeout: 5, onTimeout: "approve", outcomes },
+      };
+
+      const result = await executeHumanInputTask(taskDef, "gate", createState(), makeCtx(awaitFn));
+
+      expect(result).toEqual({
+        outcome: "needs_revision",
+        reviewer: "alice",
+        __flow_directive__: "gatherMore",
+      });
+    });
+
+    it("keeps plain approve/deny for binary gates without custom outcomes", async () => {
+      const awaitFn: AwaitHumanInputFn = async () => ({
+        outcome: "approve",
+        auto_resolved: true,
+        reason: "timeout",
+      });
+
+      const taskDef: HumanInputTaskDef = {
+        kind: "human_input",
+        humanInput: { prompt: "Review", timeout: 5, onTimeout: "approve" },
+      };
+
+      const result = await executeHumanInputTask(taskDef, "gate", createState(), makeCtx(awaitFn));
+
+      expect(result).toEqual({ outcome: "approve", auto_resolved: true, reason: "timeout" });
+    });
+  });
+
   describe("event emission", () => {
     it("emits approval_requested before blocking with correct fields", async () => {
       const emitted: WorkflowEventDescriptor[][] = [];

package/src/workflow-engine/loader.ts

@@ -608,6 +608,51 @@ function parseServiceTier(raw: unknown): string | undefined {
   return canonical;
 }
 
+/**
+ * Maps on_timeout values to the runner's internal policy words, mirroring
+ * SERVICE_TIER_SHORTHANDS. The persisted CNCF YAML carries the proto enum
+ * NAMES (the server converter emits `HumanInputTimeoutPolicy.String()`),
+ * while hand-written fixtures use the lowercase words — both are accepted.
+ * Unknown values are authoring errors: a timeout policy must never silently
+ * fall back to fail (stigmer/stigmer#779 — the unvalidated cast let every
+ * enum-name policy reach the orchestrator unrecognized, so gates configured
+ * to auto-approve/deny failed at their first real timeout instead).
+ */
+const ON_TIMEOUT_VOCABULARY: Record<string, "fail" | "approve" | "deny"> = {
+  fail: "fail",
+  approve: "approve",
+  deny: "deny",
+  HUMAN_INPUT_TIMEOUT_FAIL: "fail",
+  HUMAN_INPUT_TIMEOUT_APPROVE: "approve",
+  HUMAN_INPUT_TIMEOUT_DENY: "deny",
+};
+
+function parseOnTimeout(
+  taskName: string,
+  raw: unknown,
+): "fail" | "approve" | "deny" | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  if (typeof raw !== "string") {
+    throw new Error(`human_input task '${taskName}': 'on_timeout' must be a string`);
+  }
+  // The proto declares HUMAN_INPUT_TIMEOUT_ESCALATE but no runtime exists
+  // for it yet; refuse at load rather than misbehave at the gate's timeout.
+  if (raw === "HUMAN_INPUT_TIMEOUT_ESCALATE" || raw === "escalate") {
+    throw new Error(
+      `human_input task '${taskName}': on_timeout policy 'escalate' is not implemented — ` +
+      `use fail, approve, or deny (custom outcomes with 'then' cover reviewer-driven branching)`,
+    );
+  }
+  const policy = ON_TIMEOUT_VOCABULARY[raw];
+  if (!policy) {
+    throw new Error(
+      `human_input task '${taskName}': unknown on_timeout value '${raw}' ` +
+      `(expected: fail, approve, deny, or a HUMAN_INPUT_TIMEOUT_* enum name)`,
+    );
+  }
+  return policy;
+}
+
 function parseHumanInputConfig(taskName: string, raw: unknown): import("./types.js").HumanInputConfig {
   if (!raw || typeof raw !== "object") {
     throw new Error(`human_input task '${taskName}' requires a 'with' configuration block`);
@@ -630,7 +675,7 @@ function parseHumanInputConfig(taskName: string, raw: unknown): import("./types.
       ? obj.approvers.filter((a: unknown) => typeof a === "string") as string[]
       : undefined,
     timeout: typeof obj.timeout === "number" ? obj.timeout : undefined,
-    onTimeout: (obj.on_timeout as "fail" | "approve" | "deny") ?? undefined,
+    onTimeout: parseOnTimeout(taskName, obj.on_timeout),
     // Any JSON shape is a valid payload (expression string, object, array),
     // so only null/undefined mean "no payload" here.
     payload: obj.payload ?? undefined,

package/src/workflow-engine/tasks/call-function.ts

@@ -162,26 +162,87 @@ export class CallFunctionTaskBuilder implements TaskBuilder {
       const executionId =
         (state.env.__stigmer_execution_id as string | undefined) || undefined;
 
-      const result = await ctx.callFunction(
-        callType,
-        resolved,
-        state.env,
-        {
-          workflowExecutionId: executionId,
-        },
-      );
+      const fnMeta = { workflowExecutionId: executionId };
 
       if (callType === "llm") {
-        return normalizeLlmOutput(
-          result as LlmActivityResult,
-          !!resolved.response_schema,
-        );
+        return this.executeLlmCall(resolved, state.env, fnMeta, ctx);
       }
 
-      return result;
+      return ctx.callFunction(callType, resolved, state.env, fnMeta);
     };
   }
 
+  /**
+   * Executes a `call: llm` with schema-validation policy orchestration —
+   * the llm twin of call-agent's output-contract loop (#686).
+   *
+   * With ON_INVALID_RETRY / ON_INVALID_FALLBACK the activity reports a
+   * validation miss as a `parse_error` result instead of throwing; each
+   * retry is its own activity invocation (visible in Temporal history)
+   * re-prompting with the validation errors so the model can self-correct.
+   * Exhausted retries (or immediate FALLBACK) branch to `fallback_task`
+   * via the engine's flow directive; without one, the task fails — the
+   * proto contract. ON_INVALID_FAIL (default) keeps the activity's
+   * throwing path: one attempt, LLM_SCHEMA_VALIDATION on miss.
+   */
+  private async executeLlmCall(
+    resolved: Record<string, unknown>,
+    env: Record<string, unknown>,
+    fnMeta: { workflowExecutionId?: string },
+    ctx: Parameters<TaskExecutorFn>[2],
+  ): Promise<unknown> {
+    const hasSchema = !!resolved.response_schema;
+    const onInvalid = (resolved.on_invalid as string | undefined) ?? "ON_INVALID_FAIL";
+    const softHandling =
+      hasSchema && (onInvalid === "ON_INVALID_RETRY" || onInvalid === "ON_INVALID_FALLBACK");
+
+    // Proto: max_retries "Default: 1", meaningful only for ON_INVALID_RETRY.
+    const maxRetries =
+      onInvalid === "ON_INVALID_RETRY" ? (resolved.max_retries as number | undefined) ?? 1 : 0;
+
+    let attempts = 0;
+    let lastParseError = "";
+
+    do {
+      const attemptConfig =
+        attempts === 0
+          ? resolved
+          : {
+              ...resolved,
+              prompt:
+                `${resolved.prompt}\n\n[RETRY — Your previous response did not match ` +
+                `the required output schema. Validation errors: ${lastParseError}. ` +
+                `Please ensure your response strictly matches the JSON schema provided.]`,
+            };
+
+      const result = (await ctx.callFunction(
+        "llm",
+        attemptConfig,
+        env,
+        fnMeta,
+      )) as LlmActivityResult;
+
+      if (!softHandling || !result.parse_error) {
+        return normalizeLlmOutput(result, hasSchema);
+      }
+
+      lastParseError = result.parse_error;
+      attempts++;
+    } while (onInvalid === "ON_INVALID_RETRY" && attempts <= maxRetries);
+
+    if (typeof resolved.fallback_task === "string" && resolved.fallback_task !== "") {
+      return {
+        __flow_directive__: resolved.fallback_task,
+        validation_errors: [lastParseError],
+      };
+    }
+
+    throw new Error(
+      `LLM output validation failed after ${attempts} attempt(s) ` +
+      `for task '${this.taskName}': ${lastParseError}`,
+    );
+  }
+
   async shouldRun(): Promise<boolean> {
     return true;
   }

package/src/workflow-engine/tasks/human-input.ts

@@ -96,11 +96,14 @@ export async function executeHumanInputTask(
     ]);
   }
 
-  const result: HumanInputResult = await ctx.awaitHumanInput({
-    signalName,
-    timeoutSeconds,
-    onTimeout,
-  });
+  const result: HumanInputResult = applyTimeoutOutcomeContract(
+    await ctx.awaitHumanInput({
+      signalName,
+      timeoutSeconds,
+      onTimeout,
+    }),
+    config.outcomes,
+  );
 
   if (ctx.emitEvents) {
     await ctx.emitEvents([{
@@ -132,6 +135,31 @@ function validateConfig(config: HumanInputConfig, taskName: string): void {
   }
 }
 
+/**
+ * Applies the proto contract for timeout auto-resolution with custom
+ * outcomes (HumanInputTaskConfig.outcomes doc): auto-approve resolves to
+ * the FIRST declared outcome and auto-deny to the LAST, so `then` routing
+ * and downstream outcome switches see declared outcome names — never the
+ * orchestrator's internal approve/deny words, which a reviewer of a
+ * custom-outcome gate was never offered. Binary gates (no custom outcomes)
+ * keep the plain approve/deny result.
+ */
+function applyTimeoutOutcomeContract(
+  result: HumanInputResult,
+  outcomes: HumanInputConfig["outcomes"],
+): HumanInputResult {
+  if (!result.auto_resolved || result.reason !== "timeout" || !outcomes?.length) {
+    return result;
+  }
+  if (result.outcome === "approve") {
+    return { ...result, outcome: outcomes[0].name };
+  }
+  if (result.outcome === "deny") {
+    return { ...result, outcome: outcomes[outcomes.length - 1].name };
+  }
+  return result;
+}
+
 interface ResolvedReviewPayload {
   /** Resolved payload for inline delivery on the approval_requested event. */
   readonly payload?: unknown;

package/src/workflow-engine/types.ts

@@ -336,6 +336,12 @@ export interface HttpCallConfig {
   readonly query?: Record<string, string>;
   readonly output?: string;
   readonly redirect?: string;
+  /**
+   * Request timeout in seconds (proto: HttpCallTaskConfig.timeout_seconds,
+   * 1-300). Aborts the request and fails the task with HTTP_CALL_TIMEOUT;
+   * the engine also widens the activity's startToClose to fit it (#686).
+   */
+  readonly timeout_seconds?: number;
 }
 
 export type EndpointDef = string | { readonly uri: string; readonly authentication?: Record<string, unknown> };

package/src/workflows/engine-core.ts

@@ -67,17 +67,44 @@ const evalProxy = proxyLocalActivities<EvalActivities>({
   startToCloseTimeout: "10s",
 });
 
+const CALL_PROXY_RETRY = {
+  maximumAttempts: 5,
+  initialInterval: "1s",
+  backoffCoefficient: 2,
+  maximumInterval: "1m",
+} as const;
+
 const callProxy = proxyActivities<HttpActivities & GrpcActivities & FunctionActivities>({
   startToCloseTimeout: "5m",
   heartbeatTimeout: "30s",
-  retry: {
-    maximumAttempts: 5,
-    initialInterval: "1s",
-    backoffCoefficient: 2,
-    maximumInterval: "1m",
-  },
+  retry: CALL_PROXY_RETRY,
 });
 
+/**
+ * Task-config timeouts (llm_call.timeout ≤600s, http_call.timeout_seconds
+ * ≤300s) can exceed or crowd the default 5m startToClose, which would kill
+ * the activity before its own well-typed LLM_TIMEOUT / HTTP_CALL_TIMEOUT
+ * failure fires. When a task declares a budget, proxy its call with
+ * startToClose = budget + 30s so the in-activity bound always wins (#686).
+ *
+ * proxyActivities in workflow code is a deterministic proxy construction
+ * (no Temporal commands); the memo just avoids rebuilding per call.
+ */
+const timeoutAwareProxies = new Map<number, typeof callProxy>();
+function callProxyFor(timeoutSeconds: number | undefined): typeof callProxy {
+  if (!timeoutSeconds || !Number.isFinite(timeoutSeconds)) return callProxy;
+  let proxy = timeoutAwareProxies.get(timeoutSeconds);
+  if (!proxy) {
+    proxy = proxyActivities<HttpActivities & GrpcActivities & FunctionActivities>({
+      startToCloseTimeout: `${timeoutSeconds + 30}s`,
+      heartbeatTimeout: "30s",
+      retry: CALL_PROXY_RETRY,
+    });
+    timeoutAwareProxies.set(timeoutSeconds, proxy);
+  }
+  return proxy;
+}
+
 const runProxy = proxyActivities<RunActivities>({
   startToCloseTimeout: "5m",
   heartbeatTimeout: "30s",
@@ -240,7 +267,7 @@ export async function runWorkflowEngine(
     runWorkflow: (config: RunWorkflowExecutionConfig) => orchestrateRunWorkflow(config),
     awaitHumanInput: (config: HumanInputExecutionConfig) => orchestrateHumanInput(config),
     callHttp: (config: HttpCallConfig, runtimeEnv: Record<string, unknown>) =>
-      callProxy.CallHttp(config, runtimeEnv),
+      callProxyFor(config.timeout_seconds).CallHttp(config, runtimeEnv),
     callGrpc: (config: GrpcCallConfig, runtimeEnv: Record<string, unknown>) =>
       callProxy.CallGrpc(config, runtimeEnv),
     callFunction: (
@@ -249,7 +276,11 @@ export async function runWorkflowEngine(
       runtimeEnv: Record<string, unknown>,
       fnMeta: CallFunctionMetadata,
     ) =>
-      callProxy.CallFunction(
+      callProxyFor(
+        call === "llm" && typeof config.timeout === "number"
+          ? config.timeout
+          : undefined,
+      ).CallFunction(
         call,
         config,
         runtimeEnv,

package/dist/activities/execute-cursor/connect-backfill.d.ts

@@ -1,19 +0,0 @@
-/**
- * Connect backfill for MCP servers without discovered capabilities.
- *
- * Thin wrapper around the shared connect-backfill module that preserves
- * the cursor-specific McpResolutionResult interface (which includes
- * cursorConfig). The core backfill logic lives in shared/connect-backfill.ts.
- *
- * Non-fatal: if connect fails for any server, the original servers are
- * kept and execution continues with empty policies (fail-closed).
- */
-import type { McpResolutionResult } from "./mcp-resolver.js";
-import type { StigmerClient } from "../../client/stigmer-client.js";
-import type { McpTransportPosture } from "../../shared/mcp-transport-guard.js";
-import type { McpServerUsage } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb";
-/**
- * Run connect backfill and return an updated cursor-specific
- * McpResolutionResult with rebuilt cursorConfig.
- */
-export declare function backfillMcpServersIfNeeded(client: StigmerClient, currentResult: McpResolutionResult, usages: McpServerUsage[], envVars: Record<string, string>, org: string, transportPosture: McpTransportPosture, onHeartbeat?: () => void, secretKeys?: ReadonlySet<string>): Promise<McpResolutionResult>;

package/dist/activities/execute-cursor/connect-backfill.js

@@ -1,27 +0,0 @@
-/**
- * Connect backfill for MCP servers without discovered capabilities.
- *
- * Thin wrapper around the shared connect-backfill module that preserves
- * the cursor-specific McpResolutionResult interface (which includes
- * cursorConfig). The core backfill logic lives in shared/connect-backfill.ts.
- *
- * Non-fatal: if connect fails for any server, the original servers are
- * kept and execution continues with empty policies (fail-closed).
- */
-import { toCursorMcpConfig } from "./mcp-resolver.js";
-import { backfillMcpServersIfNeeded as sharedBackfill } from "../../shared/connect-backfill.js";
-/**
- * Run connect backfill and return an updated cursor-specific
- * McpResolutionResult with rebuilt cursorConfig.
- */
-export async function backfillMcpServersIfNeeded(client, currentResult, usages, envVars, org, transportPosture, onHeartbeat, secretKeys) {
-    const updatedServers = await sharedBackfill(client, currentResult.resolvedServers, usages, envVars, org, transportPosture, onHeartbeat, secretKeys);
-    if (updatedServers === currentResult.resolvedServers) {
-        return currentResult;
-    }
-    return {
-        cursorConfig: toCursorMcpConfig(updatedServers),
-        resolvedServers: updatedServers,
-    };
-}
-//# sourceMappingURL=connect-backfill.js.map

package/dist/activities/execute-cursor/connect-backfill.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"connect-backfill.js","sourceRoot":"","sources":["../../../src/activities/execute-cursor/connect-backfill.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAItD,OAAO,EAAE,0BAA0B,IAAI,cAAc,EAAE,MAAM,kCAAkC,CAAC;AAEhG;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,MAAqB,EACrB,aAAkC,EAClC,MAAwB,EACxB,OAA+B,EAC/B,GAAW,EACX,gBAAqC,EACrC,WAAwB,EACxB,UAAgC;IAEhC,MAAM,cAAc,GAAG,MAAM,cAAc,CACzC,MAAM,EACN,aAAa,CAAC,eAAe,EAC7B,MAAM,EACN,OAAO,EACP,GAAG,EACH,gBAAgB,EAChB,WAAW,EACX,UAAU,CACX,CAAC;IAEF,IAAI,cAAc,KAAK,aAAa,CAAC,eAAe,EAAE,CAAC;QACrD,OAAO,aAAa,CAAC;IACvB,CAAC;IAED,OAAO;QACL,YAAY,EAAE,iBAAiB,CAAC,cAAc,CAAC;QAC/C,eAAe,EAAE,cAAc;KAChC,CAAC;AACJ,CAAC"}