@letta-ai/letta-code 0.33.4 → 0.33.5

package/letta.js

@@ -5653,7 +5653,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@letta-ai/letta-code",
-    version: "0.33.4",
+    version: "0.33.5",
     lettaStartupLogProtocol: 1,
     description: "Letta Code is a CLI tool for interacting with stateful Letta agents from the terminal.",
     type: "module",
@@ -5785,7 +5785,7 @@ var init_package = __esm(() => {
     dependencies: {
       "@earendil-works/pi-ai": "^0.87.1",
       "@janhapke/sharp-electron": "0.35.3-electron.1",
-      "@letta-ai/letta-agent-sdk": "^0.8.17",
+      "@letta-ai/letta-agent-sdk": "0.8.21",
       "@letta-ai/letta-client": "^1.10.2",
       "@letta-ai/trajectory": "0.2.0",
       "@modelcontextprotocol/sdk": "1.30.0",
@@ -111416,7 +111416,6 @@ var init_names = __esm(() => {
     "Songbird",
     "Slider",
     "Aguilar",
-    "Dogmeat",
     "Codsworth",
     "Nick Valentine",
     "Yes Man",
@@ -203018,40 +203017,31 @@ Pass a URL ending at the PR number, such as \`https://github.com/owner/repo/pull
 var init_WatchPR = () => {};
 
 // src/tools/descriptions/Workflow.md
-var Workflow_default = `Execute a workflow script that orchestrates multiple subagents deterministically. Use for multi-step orchestration where control flow should be deterministic (loops, conditionals, fan-out) rather than model-driven.
+var Workflow_default = `Execute a workflow script that orchestrates multiple subagents deterministically (loops, conditionals, fan-out) rather than model-driven.
 
-Workflows run in the background — this tool validates the script and returns immediately with a task ID (\`workflow_N\`) and output file path; a <task-notification> arrives when the workflow completes, carrying the script's return value. Do not poll or sleep for it: keep working or end your turn, and never fabricate the result before the notification arrives. Read the output file only when you need interim progress; TaskStop aborts the run.
+Workflows run in the background: this tool returns immediately with a task ID, and a <task-notification> carrying the script's return value arrives when the workflow completes. Do not poll or sleep for it, and never fabricate the result before it arrives. TaskStop aborts the run.
 
-ONLY call this tool when the user has explicitly opted into multi-agent orchestration. Workflows can spawn dozens of subagent sessions and cost real money; the user must request that scale, not have it inferred. Explicit opt-in means: the user directly asked for a workflow or multi-agent orchestration in their own words ("use a workflow", "fan out agents", "orchestrate this with subagents"), asked for a comprehensive audit/sweep at a scale that plainly requires it, or invoked a skill whose instructions call this tool. For any other task — even one that would benefit from parallelism — describe what a workflow could do and ask first.
+ONLY call this tool when the user has explicitly opted into multi-agent orchestration — they asked for a workflow or multi-agent orchestration in their own words ("use a workflow", "fan out agents"), or invoked a skill whose instructions call this tool. Workflows can spawn many subagents and cost real money. For any other task, even one that would benefit from parallelism, describe what a workflow could do and ask first.
 
-Every script must begin with \`export const meta = {...}\`: a PURE LITERAL (no variables, calls, or interpolation) giving the workflow's \`name\` (kebab-case), a one-line \`description\`, and optionally \`phases\` — one \`{ title, detail? }\` per phase() call. Scripts are plain JavaScript, not TypeScript. The script runs in the CLI process with the CLI's privileges and the user approves it by reading it, so keep it to orchestration (deciding what runs, combining results); reading, searching, and writing belong in subagents, where the tool allowlist applies.
-
-The canonical multi-stage pattern — pipeline by default, each item verifies as soon as its review completes:
+Scripts are plain JavaScript and must begin with \`export const meta = {...}\`, a pure literal (no variables, calls, or interpolation). Pass the work list via \`args\`. Prefer \`pipeline()\` so each item moves to its next stage as soon as it is ready; \`agent()\` resolves to \`null\` on failure, so guard and filter:
 
   export const meta = {
-    name: 'review-changes',
-    description: 'Review changed files across dimensions, verify each finding',
+    name: 'review-files',
+    description: 'Review each file for bugs, verify each finding',
     phases: [{ title: 'Review' }, { title: 'Verify' }],
   }
-  const DIMENSIONS = [{key: 'bugs', prompt: '...'}, {key: 'perf', prompt: '...'}]
-  const findingsSchema = {type: 'object', properties: {findings: {type: 'array', items: {type: 'object', properties: {file: {type: 'string'}, summary: {type: 'string'}}, required: ['file', 'summary']}}}, required: ['findings']}
-  const verdictSchema = {type: 'object', properties: {real: {type: 'boolean'}, why: {type: 'string'}}, required: ['real', 'why']}
+  const findings = {type: 'object', properties: {bugs: {type: 'array', items: {type: 'string'}}}, required: ['bugs']}
+  const verdict = {type: 'object', properties: {real: {type: 'boolean'}}, required: ['real']}
   const results = await pipeline(
-    DIMENSIONS,
-    d => agent(d.prompt, {label: \`review:\${d.key}\`, phase: 'Review', schema: findingsSchema}),
-    review => review ? parallel(review.findings.map(f => () =>
-      agent(\`Adversarially verify: \${f.summary}\`, {label: \`verify:\${f.file}\`, phase: 'Verify', schema: verdictSchema})
-        .then(v => ({...f, verdict: v})))) : []
+    args.files,
+    f => agent(\`Review \${f} for bugs.\`, { phase: 'Review', schema: findings }),
+    (review, f) => parallel((review?.bugs ?? []).map(bug => () =>
+      agent(\`Is this a real bug in \${f}? \${bug}\`, { phase: 'Verify', schema: verdict })
+        .then(v => v?.real ? { file: f, bug } : null))),
   )
-  return { confirmed: results.filter(Boolean).flat().filter(Boolean).filter(f => f.verdict?.real) }
-
-Script hooks: agent(prompt, opts?) spawns one subagent and resolves to final text. Prefer opts.schema (JSON Schema) for a validated object; invalid/missing results retry and then resolve to null with the validation error in the journal. opts.json still parses without validating; schema wins if both are supplied. Options: label, phase, schema, json, model, effort, allowedTools, systemPrompt, timeoutMs, maxToolCalls. pipeline(items, ...stages) runs each item through all stages independently with NO barrier between stages; each stage receives (prevResult, originalItem, index); a throwing stage drops that item to null. parallel(thunks) runs zero-arg functions concurrently and IS a barrier — use only when a stage genuinely needs all prior results together. phase(title) groups subsequent agents in progress output (inside concurrent stages use opts.phase instead — the global phase races). log(message) emits a progress line. args is the invocation's args input, verbatim.
-
-Subagents run in isolated agent-free ephemeral conversations with read-only tools by default (Read, Grep, Glob) and no access to your memory or conversation — put ALL context they need in the prompt. Their model defaults to the invoking conversation's model; opts.model or the tool's model input accept any handle or alias from \`letta model list\`. They are told their final text IS the return value, so they return raw data. Concurrency is capped (excess agent() calls queue); a lifetime cap of 1000 agents per run is the runaway-loop backstop. Each subagent is also guarded: a 10-minute default timeout (override with opts.timeoutMs), at most 1000 unique tool calls by default (override with the positive safe integer opts.maxToolCalls), and a stop after three identical consecutive tool calls — a guarded call resolves to null and the journal records which guard fired.
+  return results.filter(Boolean).flat().filter(Boolean)
 
-Every run persists its script and a journal of each subagent's outcome under ~/.letta/workflows/executions/<id>/ (the paths are in the tool result). Before diagnosing an empty or unexpected result, read that run's journal.jsonl; it records each agent's actual return value. Workflow subagents require the API backend.
-
-Before authoring a script, load the \`workflow-authoring\` skill — the workflow authoring reference: script API and gotchas, pipeline-vs-barrier rules, quality patterns (adversarial verify, judge panel, loop-until-dry), and worked examples.
+Before authoring a script, load the \`workflow-authoring\` skill — the script API, pipeline-vs-barrier rules, quality patterns, worked examples, and how to diagnose a run.
 `;
 var init_Workflow = () => {};
 
@@ -213029,7 +213019,7 @@ class CodexAppServerClient {
     await this.request("initialize", {
       clientInfo: {
         name: "letta-code",
-        version: "0.33.4"
+        version: "0.33.5"
       },
       capabilities: null
     });
@@ -220357,6 +220347,7 @@ function registerWorkflowExecution(params) {
     startedAt: params.startedAt ?? Date.now(),
     phases: (params.meta.phases ?? []).map((p2) => p2.title),
     agents: new Map,
+    decisionTokens: 0,
     logs: []
   });
   notify();
@@ -220375,6 +220366,9 @@ function recordWorkflowProgress(taskId, event) {
       if (record4.logs.length > MAX_LOG_LINES)
         record4.logs.shift();
       break;
+    case "decision_usage":
+      record4.decisionTokens += event.totalTokens;
+      break;
     case "agent": {
       const previous = record4.agents.get(event.callIndex);
       const phase = event.phase ?? previous?.phase ?? null;
@@ -220446,7 +220440,7 @@ function snapshot(record4, now2) {
     agentsDone: agents.filter((a2) => a2.status === "done").length,
     agentsFailed: agents.filter((a2) => a2.status === "error").length,
     agentsRunning: agents.filter((a2) => a2.status === "running").length,
-    totalTokens: agents.reduce((sum2, a2) => sum2 + (a2.totalTokens ?? 0), 0),
+    totalTokens: record4.decisionTokens + agents.reduce((sum2, a2) => sum2 + (a2.totalTokens ?? 0), 0),
     phases: phaseOrder.map((title) => ({
       title,
       agents: byPhase.get(title) ?? []
@@ -220647,6 +220641,22 @@ import { existsSync as existsSync45, readFileSync as readFileSync35 } from "node
 import { createRequire as createRequire6 } from "node:module";
 import { dirname as dirname26, join as join64 } from "node:path";
 import { fileURLToPath as fileURLToPath7, pathToFileURL as pathToFileURL3 } from "node:url";
+function supportsPublishedResume(version2) {
+  if (!version2 || !MIN_RESUME_SDK_VERSION)
+    return false;
+  const match2 = /^(\d+)\.(\d+)\.(\d+)$/.exec(version2);
+  const minimum3 = MIN_RESUME_SDK_VERSION.split(".").map(Number);
+  if (!match2)
+    return false;
+  const parts = match2.slice(1).map(Number);
+  for (let index = 0;index < parts.length; index++) {
+    const part = parts[index];
+    const required5 = minimum3[index];
+    if (part !== required5)
+      return (part ?? 0) > (required5 ?? 0);
+  }
+  return true;
+}
 function preferRunningCliForSubagents() {
   if (process.env.LETTA_CLI_PATH)
     return;
@@ -220655,6 +220665,17 @@ function preferRunningCliForSubagents() {
     process.env.LETTA_CLI_PATH = entry;
   }
 }
+function packageVersion(entry) {
+  for (let dir = dirname26(entry);; dir = dirname26(dir)) {
+    try {
+      const manifest = JSON.parse(readFileSync35(join64(dir, "package.json"), "utf8"));
+      if (manifest.name === SDK_PACKAGE)
+        return manifest.version;
+    } catch {}
+    if (dir === dirname26(dir))
+      return;
+  }
+}
 function packageEntry(packageDir) {
   try {
     const manifest = JSON.parse(readFileSync35(join64(packageDir, "package.json"), "utf8"));
@@ -220722,6 +220743,7 @@ async function loadAgentSdk() {
         continue;
       }
       return {
+        supportsAgentFreeResume: process.env.LETTA_WORKFLOW_AGENT_FREE_RESUME === "1" && Boolean(envPath) && specifier === specifiers[0] || specifier.startsWith("file:") && supportsPublishedResume(packageVersion(fileURLToPath7(specifier))),
         createLocalClient: () => {
           const client = new sdk.LettaAgentClient({
             backend: "local",
@@ -220751,12 +220773,26 @@ async function loadAgentSdk() {
 ${attempts.map((a2) => `  tried ${a2}`).join(`
 `)}`);
 }
-var SDK_PACKAGE;
+var SDK_PACKAGE, MIN_RESUME_SDK_VERSION = "0.8.20";
 var init_sdk_loader = __esm(() => {
   SDK_PACKAGE = ["@letta-ai", "letta-agent-sdk"].join("/");
 });
 
 // src/tools/workflow/sdk-spawner.ts
+async function latestWorkerRun(conversationId) {
+  const client = await getClient();
+  const messages = await client.conversations.messages.list(conversationId, {
+    limit: 100,
+    order: "desc"
+  });
+  const runId = messages.getPaginatedItems().map((message) => message.run_id).find((id2) => typeof id2 === "string" && id2.startsWith("run-"));
+  if (!runId)
+    return null;
+  return client.runs.retrieve(runId);
+}
+async function retrieveWorkerConversation(id2) {
+  return apiRequest("GET", `/v1/conversations/${encodeURIComponent(id2)}`);
+}
 function parseJsonReply(text2) {
   const trimmed = text2.trim();
   const fenced = /^```(?:json)?\s*([\s\S]*?)\s*```$/.exec(trimmed);
@@ -220842,14 +220878,20 @@ function usageTokensFromEvent(event) {
   const total = event.total_tokens;
   return typeof total === "number" && Number.isFinite(total) ? total : undefined;
 }
-async function drainTurn(query3, usage, stop, maxToolCalls, onUsage) {
+async function drainTurn(query3, usage, stop, maxToolCalls, onUsage, onStarted) {
   let assistantText2 = "";
   let resultText;
   let success = false;
   let error4;
   let structuredOutput;
+  let startedNotified = false;
   const guard = createToolCallGuard(maxToolCalls);
   for await (const message of query3) {
+    const id2 = query3.conversationId ?? message.conversationId;
+    if (!startedNotified && id2) {
+      startedNotified = true;
+      onStarted?.(id2);
+    }
     if (message.type === "assistant")
       assistantText2 += message.content ?? "";
     if (message.type === "stream_event") {
@@ -220900,16 +220942,44 @@ function buildQueryOptions(options, model, config, callIndex) {
     name: options.label ?? `Workflow worker ${callIndex + 1}`,
     system: system2,
     permissionMode: "unrestricted",
-    allowedTools: options.allowedTools ?? config.allowedTools ?? DEFAULT_ALLOWED_TOOLS,
+    allowedTools: options.allowedTools ?? (options.conversationId ? [] : config.allowedTools ?? DEFAULT_ALLOWED_TOOLS),
     skillSources: [],
     ...config.cwd ? { cwd: config.cwd } : {},
+    disableMemoryGuard: true,
     ...options.effort ? { modelSettings: { reasoning_effort: options.effort } } : {}
   };
 }
 function createSdkSpawner(client, config) {
   return async (request, signal, hooks) => {
     const { prompt, options } = request;
-    const model = options.model ? config.resolveModel?.(options.model) ?? null : config.model;
+    const resumeId = options.conversationId;
+    if (resumeId !== undefined && !/^conv-[A-Za-z0-9_-]+$/.test(resumeId)) {
+      throw new Error("agent() conversationId must be a conv-... ID.");
+    }
+    if (resumeId && !config.supportsAgentFreeResume) {
+      throw new Error("Workflow worker continuation requires an Agent SDK release with agent-free query() resume support.");
+    }
+    const persisted = resumeId ? await (config.retrieveConversation ?? retrieveWorkerConversation)(resumeId) : null;
+    if (persisted && (persisted.agent_id !== null || persisted.parent_agent_id !== config.parentAgentId)) {
+      throw new Error("Worker conversation is not agent-free or belongs to another parent agent.");
+    }
+    if (persisted && resumeId) {
+      const latest = await (config.latestRun ?? latestWorkerRun)(resumeId);
+      if (!latest || latest.conversation_id !== resumeId || !["completed", "failed", "cancelled"].includes(latest.status ?? "")) {
+        throw new Error("Cannot confirm worker's latest run is terminal; reconcile it before continuing.");
+      }
+    }
+    if (persisted && (!persisted.model || typeof persisted.model !== "string")) {
+      throw new Error("Worker conversation has no persisted model; cannot continue safely.");
+    }
+    const selectedModel = options.model ? config.resolveModel?.(options.model) ?? null : config.model;
+    if (persisted && options.systemPrompt !== undefined) {
+      throw new Error("agent() continuation cannot override the worker system prompt.");
+    }
+    if (persisted && options.model && selectedModel !== persisted.model) {
+      throw new Error("agent() continuation model must match the persisted worker model.");
+    }
+    const model = persisted ? persisted.model : selectedModel;
     if (!model) {
       return {
         value: null,
@@ -220928,8 +220998,15 @@ function createSdkSpawner(client, config) {
     const usage = {};
     const query3 = client.query({
       prompt,
-      options: buildQueryOptions(options, model, config, request.callIndex)
+      options: {
+        ...buildQueryOptions(options, model, config, request.callIndex),
+        ...resumeId ? { conversationId: resumeId } : {}
+      }
     });
+    if (resumeId && query3.conversationId && query3.conversationId !== resumeId) {
+      query3.close();
+      throw new Error("SDK resumed an unexpected worker conversation; refusing continuation.");
+    }
     let settleStopped;
     const stopped = new Promise((resolve30) => {
       settleStopped = resolve30;
@@ -220959,44 +221036,68 @@ function createSdkSpawner(client, config) {
         drainTurn(query3, usage, stop, options.maxToolCalls ?? DEFAULT_MAX_SUBAGENT_TOOL_CALLS, (totalTokens) => {
           if (!finished2)
             hooks?.onUsage?.(totalTokens);
+        }, (id2) => {
+          if (resumeId && id2 !== resumeId) {
+            stop("SDK resumed an unexpected worker conversation");
+          } else if (!finished2) {
+            hooks?.onStarted?.(id2);
+          }
         }),
         stopped
       ]);
+      if (resumeId && query3.conversationId !== resumeId) {
+        throw new Error("SDK did not resume the requested worker conversation.");
+      }
       const stats = {
         durationMs: Date.now() - startedAt,
         ...turn.totalTokens !== undefined ? { totalTokens: turn.totalTokens } : {},
         ...query3.conversationId ? { conversationId: query3.conversationId } : {}
       };
       if (!turn.success) {
-        return {
+        const outcome2 = {
           value: null,
           failed: true,
           error: turn.error ?? "subagent turn failed",
           ...stats
         };
+        return outcome2;
       }
       if (options.schema) {
-        return { value: turn.structuredOutput, failed: false, ...stats };
+        const outcome2 = {
+          value: turn.structuredOutput,
+          failed: false,
+          ...stats
+        };
+        return outcome2;
       }
       if (options.json) {
         try {
-          return {
+          const outcome2 = {
             value: parseJsonReply(turn.finalText),
             failed: false,
             ...stats
           };
+          return outcome2;
         } catch {
-          return {
+          const outcome2 = {
             value: null,
             failed: true,
             error: `Subagent reply was not valid JSON: ${turn.finalText.slice(0, 200)}`,
             ...stats
           };
+          return outcome2;
         }
       }
-      return { value: turn.finalText, failed: false, ...stats };
+      const outcome = { value: turn.finalText, failed: false, ...stats };
+      return outcome;
     } catch (error4) {
-      return { value: null, failed: true, error: String(error4) };
+      const outcome = {
+        value: null,
+        failed: true,
+        error: String(error4),
+        ...query3.conversationId || resumeId ? { conversationId: query3.conversationId ?? resumeId } : {}
+      };
+      return outcome;
     } finally {
       finished2 = true;
       clearTimeout(timeout);
@@ -221007,10 +221108,140 @@ function createSdkSpawner(client, config) {
 }
 var DEFAULT_ALLOWED_TOOLS, DEFAULT_SUBAGENT_TIMEOUT_MS, DEFAULT_MAX_SUBAGENT_TOOL_CALLS = 1000, MAX_IDENTICAL_TOOL_CALLS = 3, SUBAGENT_PREAMBLE = `You are a subagent inside a deterministic workflow. You are not talking to a human: your final output is consumed by a script. Return raw data with no preamble, no markdown framing, and no questions.`, JSON_PREAMBLE = `Your final message must be a single JSON value and nothing else: no prose, no markdown code fence.`;
 var init_sdk_spawner = __esm(() => {
+  init_client4();
+  init_request();
   DEFAULT_ALLOWED_TOOLS = ["Read", "Grep", "Glob"];
   DEFAULT_SUBAGENT_TIMEOUT_MS = 10 * 60 * 1000;
 });
 
+// src/tools/workflow/decide.ts
+function isRecord9(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function validateRequest(input) {
+  if (!isRecord9(input))
+    throw new Error("decide() requires a request object.");
+  const { state, questions, provider, session_id, trace, user } = input;
+  if (Object.hasOwn(input, "model"))
+    throw new Error("decide() does not accept a model option.");
+  if (!(typeof state === "string" || isRecord9(state) || Array.isArray(state))) {
+    throw new Error("decide() state must be a string, object, or array.");
+  }
+  if (!isRecord9(questions) || Object.keys(questions).length === 0) {
+    throw new Error("decide() questions must be a non-empty object.");
+  }
+  for (const [id2, question] of Object.entries(questions)) {
+    if (!isRecord9(question) || typeof question.instructions !== "string" || !question.instructions.trim()) {
+      throw new Error(`decide() question ${id2} requires instructions.`);
+    }
+    if (question.type === "choice") {
+      if (!isRecord9(question.criteria) || Object.keys(question.criteria).length === 0 || Object.keys(question.criteria).length > 255 || !Object.values(question.criteria).every((value) => typeof value === "string")) {
+        throw new Error(`decide() choice ${id2} requires a non-empty criteria map (at most 255 options).`);
+      }
+    } else if (question.type === "score") {
+      if (!Array.isArray(question.criteria) || question.criteria.length === 0 || !question.criteria.every((value) => typeof value === "string")) {
+        throw new Error(`decide() score ${id2} requires a non-empty criteria array.`);
+      }
+    } else if (question.type !== "noul") {
+      throw new Error(`decide() question ${id2} has an unsupported type.`);
+    }
+  }
+  if (provider !== undefined && !isRecord9(provider))
+    throw new Error("decide() provider must be an object.");
+  if (isRecord9(provider) && provider.allow_fallbacks === true) {
+    throw new Error("decide() does not allow model/provider fallbacks.");
+  }
+  if (session_id !== undefined && (typeof session_id !== "string" || session_id.length > 256)) {
+    throw new Error("decide() session_id must be a string of at most 256 characters.");
+  }
+  if (trace !== undefined && !isRecord9(trace))
+    throw new Error("decide() trace must be an object.");
+  if (user !== undefined && typeof user !== "string")
+    throw new Error("decide() user must be a string.");
+  return input;
+}
+function validProbabilityMap(value) {
+  return isRecord9(value) && Object.values(value).every(isFiniteNumber2);
+}
+function validAnswer(answer, question) {
+  if (!isRecord9(answer) || answer.type !== question.type)
+    return false;
+  if (answer.type === "choice") {
+    return typeof answer.choice === "string" && isRecord9(question.criteria) && Object.hasOwn(question.criteria, answer.choice) && (answer.probabilities === undefined || validProbabilityMap(answer.probabilities)) && (answer.confidence === undefined || isFiniteNumber2(answer.confidence));
+  }
+  if (answer.type === "score") {
+    return isFiniteNumber2(answer.score) && isRecord9(answer.legend) && Object.values(answer.legend).every((value) => typeof value === "string") && (answer.probabilities === undefined || validProbabilityMap(answer.probabilities)) && (answer.confidence === undefined || isFiniteNumber2(answer.confidence));
+  }
+  return answer.type === "noul" && isFiniteNumber2(answer.noul) && answer.noul >= 0 && answer.noul <= 1;
+}
+function validateResponse(response, request) {
+  if (!isRecord9(response) || typeof response.model !== "string" || typeof response.id !== "string" || typeof response.provider !== "string" || !isRecord9(response.usage) || !isFiniteNumber2(response.usage.input_tokens) || !isFiniteNumber2(response.usage.output_tokens) || !isFiniteNumber2(response.usage.cost) || !isRecord9(response.answers)) {
+    throw new Error("decide() received a malformed response.");
+  }
+  const answers = response.answers;
+  const questionIds = Object.keys(request.questions);
+  if (Object.keys(answers).length !== questionIds.length || questionIds.some((id2) => !validAnswer(answers[id2], request.questions[id2]))) {
+    throw new InvalidDecisionAnswerError;
+  }
+  return {
+    ...response,
+    answers: Object.fromEntries(questionIds.map((id2) => [
+      id2,
+      { ...answers[id2], calibrated: true }
+    ]))
+  };
+}
+async function submitWorkflowDecision(input, signal, onResult) {
+  const request = validateRequest(input);
+  const body3 = {
+    ...request,
+    model: DEFAULT_JEV_MODEL,
+    provider: { ...request.provider, allow_fallbacks: false }
+  };
+  for (let attempt2 = 0;attempt2 < 2; attempt2++) {
+    if (signal.aborted)
+      throw new Error("Workflow aborted.");
+    const response = await apiRequest("POST", "/v1/alpha/decisions", body3, { signal: AbortSignal.any([signal, AbortSignal.timeout(35000)]) });
+    try {
+      const result3 = validateResponse(response, request);
+      onResult?.({
+        model: result3.model,
+        cost: result3.usage.cost,
+        calibrated: true,
+        valid: true,
+        totalTokens: result3.usage.input_tokens + result3.usage.output_tokens
+      });
+      return result3;
+    } catch (error4) {
+      if (!(error4 instanceof InvalidDecisionAnswerError))
+        throw error4;
+      const usage = response.usage;
+      onResult?.({
+        model: response.model,
+        cost: usage.cost,
+        calibrated: false,
+        valid: false,
+        totalTokens: usage.input_tokens + usage.output_tokens
+      });
+      if (attempt2 === 1)
+        return null;
+    }
+  }
+  return null;
+}
+var DEFAULT_JEV_MODEL = "~typesafe/jev-latest", InvalidDecisionAnswerError;
+var init_decide = __esm(() => {
+  init_request();
+  InvalidDecisionAnswerError = class InvalidDecisionAnswerError extends Error {
+    constructor() {
+      super("decide() received invalid answers for the requested questions.");
+    }
+  };
+});
+
 // src/tools/workflow/workflow-engine.ts
 import vm2 from "node:vm";
 
@@ -221049,18 +221280,57 @@ async function executeWorkflow(spawner, options) {
   };
   const inFlight = new Set;
   const maxTotalAgents = options.maxTotalAgents ?? DEFAULT_MAX_TOTAL_AGENTS;
+  const maxTotalDecisions = options.maxTotalDecisions ?? DEFAULT_MAX_TOTAL_DECISIONS;
   const semaphore = new Semaphore(options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT);
   let currentPhase = null;
   let callCounter = 0;
+  let decisionCounter = 0;
   let agentsSpawned = 0;
   let totalTokens = 0;
-  function agent(prompt, callOptions) {
-    const pending2 = callAgent(prompt, callOptions);
+  function trackCall(pending2) {
     pending2.catch(() => {});
     inFlight.add(pending2);
     pending2.finally(() => inFlight.delete(pending2)).catch(() => {});
     return pending2;
   }
+  function agent(prompt, callOptions) {
+    return trackCall(callAgent(prompt, callOptions));
+  }
+  function decide(state, questions, callOptions) {
+    return trackCall(callDecision(state, questions, callOptions));
+  }
+  async function callDecision(state, questions, callOptions) {
+    if (signal.aborted)
+      throw new Error("Workflow aborted.");
+    if (decisionCounter >= maxTotalDecisions) {
+      throw new Error(`Lifetime decision cap of ${maxTotalDecisions} reached.`);
+    }
+    if (callOptions !== undefined && (!callOptions || typeof callOptions !== "object" || Array.isArray(callOptions))) {
+      throw new Error("decide() options must be an object.");
+    }
+    decisionCounter++;
+    await semaphore.acquire();
+    try {
+      if (signal.aborted)
+        throw new Error("Workflow aborted.");
+      return await submitWorkflowDecision({
+        ...callOptions,
+        state,
+        questions
+      }, signal, (result3) => {
+        totalTokens += result3.totalTokens;
+        emit({ kind: "decision_usage", totalTokens: result3.totalTokens });
+        if (options.journalPath) {
+          appendJournalEntry(options.journalPath, {
+            kind: "decision",
+            ...result3
+          });
+        }
+      });
+    } finally {
+      semaphore.release();
+    }
+  }
   async function callAgent(prompt, callOptions) {
     if (typeof prompt !== "string" || !prompt.trim()) {
       throw new Error("agent() requires a non-empty prompt string.");
@@ -221074,6 +221344,9 @@ async function executeWorkflow(spawner, options) {
       throw new Error("agent() options must be an object.");
     }
     const opts = { ...callOptions };
+    if (opts.conversationId !== undefined && (typeof opts.conversationId !== "string" || !/^conv-[A-Za-z0-9_-]+$/.test(opts.conversationId))) {
+      throw new Error("agent() conversationId must be a conv-... ID.");
+    }
     if (opts.maxToolCalls !== undefined && (!Number.isSafeInteger(opts.maxToolCalls) || opts.maxToolCalls <= 0)) {
       throw new Error("agent() maxToolCalls must be a positive safe integer.");
     }
@@ -221088,6 +221361,15 @@ async function executeWorkflow(spawner, options) {
       emit({ kind: "agent", callIndex, label, phase: phase2, status: "running" });
       agentsSpawned++;
       const outcome = await spawner({ prompt, options: opts, callIndex }, signal, {
+        onStarted: (conversationId) => {
+          if (options.journalPath) {
+            appendJournalEntry(options.journalPath, {
+              kind: "agent_started",
+              callIndex,
+              conversationId
+            });
+          }
+        },
         onUsage: (totalTokens2) => emit({
           kind: "agent",
           callIndex,
@@ -221103,6 +221385,7 @@ async function executeWorkflow(spawner, options) {
           callIndex,
           label,
           prompt,
+          ...opts.conversationId ? { resumedConversationId: opts.conversationId } : {},
           outcome
         });
       }
@@ -221172,6 +221455,7 @@ async function executeWorkflow(spawner, options) {
   }
   const context3 = vm2.createContext({
     agent,
+    decide,
     parallel,
     pipeline: pipeline6,
     phase,
@@ -221219,8 +221503,9 @@ ${stripMetaExport(options.script)}
     settled = true;
   }
 }
-var DEFAULT_MAX_CONCURRENT = 16, DEFAULT_MAX_TOTAL_AGENTS = 1000, MAX_ITEMS_PER_HELPER = 4096;
+var DEFAULT_MAX_CONCURRENT = 16, DEFAULT_MAX_TOTAL_AGENTS = 1000, DEFAULT_MAX_TOTAL_DECISIONS = 1000, MAX_ITEMS_PER_HELPER = 4096;
 var init_workflow_engine = __esm(() => {
+  init_decide();
   init_journal();
   init_meta3();
 });
@@ -221274,7 +221559,8 @@ async function createSdkSpawnerHandle(args, setStage = () => {}) {
       model,
       resolveModel,
       allowedTools: args.allowedTools ?? [...DEFAULT_ALLOWED_TOOLS],
-      cwd: getCurrentWorkingDirectory()
+      cwd: getCurrentWorkingDirectory(),
+      supportsAgentFreeResume: sdk.supportsAgentFreeResume
     });
   } catch (error4) {
     client[Symbol.asyncDispose]?.().catch(() => {
@@ -221297,6 +221583,8 @@ function formatWorkflowProgressLine(event) {
       return `── ${event.title} ──`;
     case "log":
       return `» ${event.message}`;
+    case "decision_usage":
+      return null;
     case "agent": {
       if (event.status === "queued")
         return null;
@@ -221342,7 +221630,7 @@ function formatCompletionResult(run, executionDir) {
   return [
     payload,
     "",
-    `Per-agent results: ${join65(executionDir, "journal.jsonl")} — one line per completed agent with its full return value.`,
+    `Per-call results: ${join65(executionDir, "journal.jsonl")} — one line per completed agent call with its full return value, plus one per decide() API attempt (retries included) with its model, cost, calibration, and tokens.`,
     "If the result above is empty or unexpected, read that file BEFORE diagnosing — do not assume agents returned non-empty results."
   ].join(`
 `);
@@ -221561,7 +221849,7 @@ ${result3}
       `Workflow launched in background. Task ID: ${taskId}`,
       `Summary: ${meta.description}`,
       `Script file: ${scriptPath}`,
-      `Journal: ${journalPath} (one line per completed agent)`,
+      `Journal: ${journalPath} (one line per completed agent, and per decide() API attempt including retries)`,
       `Output file: ${outputFile}`,
       "",
       "You will be notified when it completes. Do not poll or sleep — keep working or end your turn. Read the output file only when you need interim progress; TaskStop aborts the run; the user can watch live status with /workflows."
@@ -398828,7 +399116,7 @@ function createModChangeBatcher(onChange) {
 // src/mods/package-manifest.ts
 import { readFileSync as readFileSync37 } from "node:fs";
 import path35 from "node:path";
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function addError(errors4, errorPath, message) {
@@ -398967,7 +399255,7 @@ function validateCapabilities(value, errors4) {
 function validateEngines(value, errors4) {
   if (value === undefined)
     return;
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     addError(errors4, "letta.engines", "engines must be an object");
     return;
   }
@@ -398992,7 +399280,7 @@ function validateEngines(value, errors4) {
   return Object.keys(engines).length > 0 ? engines : undefined;
 }
 function parseLettaPackageManifest(packageJson) {
-  if (!isRecord9(packageJson)) {
+  if (!isRecord10(packageJson)) {
     return {
       errors: [{ message: "package.json must be an object", path: "package" }],
       manifest: null,
@@ -399003,7 +399291,7 @@ function parseLettaPackageManifest(packageJson) {
   if (rawManifest === undefined) {
     return { errors: [], manifest: null, ok: true };
   }
-  if (!isRecord9(rawManifest)) {
+  if (!isRecord10(rawManifest)) {
     return {
       errors: [{ message: "letta manifest must be an object", path: "letta" }],
       manifest: null,
@@ -399073,7 +399361,7 @@ import {
   writeFileSync as writeFileSync28
 } from "node:fs";
 import path36 from "node:path";
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function createDiagnostic(diagnosticPath, message) {
@@ -399150,7 +399438,7 @@ function readRegistryObject(modsRoot) {
       registryPath
     };
   }
-  if (!isRecord10(registryResult.value)) {
+  if (!isRecord11(registryResult.value)) {
     return {
       diagnostics: [
         createDiagnostic(registryPath, "packages.json must be an object")
@@ -399227,7 +399515,7 @@ function resolvePackageEntry(packageRoot, entry) {
 }
 function validatePackageMetadata(modsRoot, rawEntry, index) {
   const diagnosticPath = `packages[${index}]`;
-  if (!isRecord10(rawEntry)) {
+  if (!isRecord11(rawEntry)) {
     return {
       diagnostics: [
         createDiagnostic(diagnosticPath, "package registry entry must be an object")
@@ -399594,7 +399882,7 @@ function setManagedModPackageEnabled(params) {
   const registry3 = readMutablePackageRegistry(params.modsRoot);
   const match3 = findPackageIndex(params.modsRoot, registry3.packagesValue, params.specifier);
   const rawEntry = registry3.packagesValue[match3.index];
-  if (!isRecord10(rawEntry)) {
+  if (!isRecord11(rawEntry)) {
     throw new Error("Invalid package entry");
   }
   rawEntry.enabled = params.enabled;
@@ -399640,7 +399928,7 @@ function upsertManagedModPackage(params) {
   let removedDuplicates = 0;
   let replaced = false;
   registry3.packagesValue.forEach((rawEntry) => {
-    if (isRecord10(rawEntry) && rawEntry.source === params.source) {
+    if (isRecord11(rawEntry) && rawEntry.source === params.source) {
       if (!replaced) {
         insertionIndex = nextPackages.length;
         nextPackages.push(entry);
@@ -399804,7 +400092,7 @@ var init_runtime_dependencies = __esm(() => {
 });
 
 // src/mods/turn-start-cancel.ts
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null;
 }
 function normalizeTurnStartCancelReason(value) {
@@ -399816,7 +400104,7 @@ function normalizeTurnStartCancelReason(value) {
   return trimmed.length > MAX_TURN_START_CANCEL_REASON_LENGTH ? trimmed.slice(0, MAX_TURN_START_CANCEL_REASON_LENGTH) : trimmed;
 }
 function getTurnStartCancel(event) {
-  if (!isRecord11(event) || !isRecord11(event.cancel))
+  if (!isRecord12(event) || !isRecord12(event.cancel))
     return null;
   const reason = normalizeTurnStartCancelReason(event.cancel.reason);
   return reason ? { reason } : null;
@@ -406461,14 +406749,14 @@ var init_approval_suggestions = __esm(async () => {
 });
 
 // src/websocket/listener/cloud-retry-message.ts
-function isRecord12(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function optionalString4(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
 function parseCloudRetryMessage(value) {
-  if (!isRecord12(value) || value.message_type !== "retry_message") {
+  if (!isRecord13(value) || value.message_type !== "retry_message") {
     return null;
   }
   const attempt2 = value.attempt;
@@ -421465,7 +421753,7 @@ var init_inbound_dispatch = __esm(async () => {
 });
 
 // src/websocket/listener/protocol-logging.ts
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function formatLogValue(value) {
@@ -421489,14 +421777,14 @@ function pushField(fields, key2, value, label = key2) {
     fields.push(`${label}=${formatted}`);
 }
 function summarizeInputPayload(payload) {
-  if (!isRecord13(payload))
+  if (!isRecord14(payload))
     return [];
   const fields = [];
   pushField(fields, "kind", payload.kind);
   if (payload.kind === "create_message") {
     pushField(fields, "messages", payload.messages);
     pushField(fields, "client_tool_allowlist", payload.client_tool_allowlist);
-    if (isRecord13(payload.client_toolset)) {
+    if (isRecord14(payload.client_toolset)) {
       pushField(fields, "client_toolset.base", payload.client_toolset.base);
       pushField(fields, "client_toolset.include", payload.client_toolset.include);
     }
@@ -421513,9 +421801,9 @@ function summarizeRuntimeStartCommand(command) {
   const fields = [];
   pushField(fields, "agent_id", command.agent_id, "agent");
   pushField(fields, "conversation_id", command.conversation_id, "conversation");
-  if (isRecord13(command.create_agent))
+  if (isRecord14(command.create_agent))
     fields.push("create_agent=true");
-  if (isRecord13(command.create_conversation)) {
+  if (isRecord14(command.create_conversation)) {
     fields.push("create_conversation=true");
   }
   pushField(fields, "cwd", command.cwd);
@@ -421524,17 +421812,17 @@ function summarizeRuntimeStartCommand(command) {
   return fields;
 }
 function summarizeV2Command(parsed) {
-  if (!isRecord13(parsed) || typeof parsed.type !== "string")
+  if (!isRecord14(parsed) || typeof parsed.type !== "string")
     return "unknown";
   const fields = [];
-  const runtime = isRecord13(parsed.runtime) ? parsed.runtime : null;
+  const runtime = isRecord14(parsed.runtime) ? parsed.runtime : null;
   if (runtime) {
     fields.push(`runtime=${runtime.agent_id ?? "<unknown>"}/${runtime.conversation_id ?? "<unknown>"}`);
   }
   pushField(fields, "request_id", parsed.request_id);
   if (parsed.type === "input") {
     fields.push(...summarizeInputPayload(parsed.payload));
-  } else if (parsed.type === "change_device_state" && isRecord13(parsed.payload)) {
+  } else if (parsed.type === "change_device_state" && isRecord14(parsed.payload)) {
     pushField(fields, "mode", parsed.payload.mode);
     pushField(fields, "cwd", parsed.payload.cwd);
     pushField(fields, "agent_id", parsed.payload.agent_id);
@@ -421544,7 +421832,7 @@ function summarizeV2Command(parsed) {
   } else if (parsed.type === "runtime_external_tools_update" && Array.isArray(parsed.updates)) {
     fields.push(`updates=${parsed.updates.length}`);
     fields.push(`runtimes=${parsed.updates.reduce((count, update3) => {
-      return count + (isRecord13(update3) && Array.isArray(update3.runtimes) ? update3.runtimes.length : 0);
+      return count + (isRecord14(update3) && Array.isArray(update3.runtimes) ? update3.runtimes.length : 0);
     }, 0)}`);
   } else {
     for (const key2 of [
@@ -424403,7 +424691,7 @@ function decodeJwtClaims(token2, sharedSecret) {
   } catch {
     return { error: unauthorized("invalid websocket jwt") };
   }
-  if (!isRecord14(header) || header.alg !== "HS256") {
+  if (!isRecord15(header) || header.alg !== "HS256") {
     return { error: unauthorized("invalid websocket jwt") };
   }
   const expectedSignature = createHmac("sha256", sharedSecret).update(`${encodedHeader}.${encodedClaims}`).digest();
@@ -424441,7 +424729,7 @@ function audienceMatches(actual, expectedAudience) {
   return false;
 }
 function isJwtClaims(value) {
-  if (!isRecord14(value) || !Number.isSafeInteger(value.exp)) {
+  if (!isRecord15(value) || !Number.isSafeInteger(value.exp)) {
     return false;
   }
   if (value.nbf !== undefined && !Number.isSafeInteger(value.nbf)) {
@@ -424461,7 +424749,7 @@ function isJwtClaims(value) {
   }
   return true;
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function base64UrlDecode(value) {
@@ -444556,8 +444844,8 @@ async function connectMcpServer(config2, options = {}) {
         return {
           content: Array.isArray(result3.content) ? result3.content : [],
           ...typeof result3.isError === "boolean" ? { isError: result3.isError } : {},
-          ...isRecord15(result3.structuredContent) ? { structuredContent: result3.structuredContent } : {},
-          ...isRecord15(result3._meta) ? { _meta: result3._meta } : {}
+          ...isRecord16(result3.structuredContent) ? { structuredContent: result3.structuredContent } : {},
+          ...isRecord16(result3._meta) ? { _meta: result3._meta } : {}
         };
       },
       close: async () => {
@@ -444630,11 +444918,11 @@ function mergeHeaders4(init, headers) {
   };
 }
 function normalizeInputSchema(value) {
-  if (isRecord15(value) && value.type === "object")
+  if (isRecord16(value) && value.type === "object")
     return value;
   return { type: "object", properties: {} };
 }
-function isRecord15(value) {
+function isRecord16(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var DEFAULT_CLIENT_INFO;
@@ -444646,7 +444934,7 @@ var init_mcp_client = __esm(() => {
   init_streamableHttp();
   DEFAULT_CLIENT_INFO = {
     name: "letta-code",
-    version: "0.33.4"
+    version: "0.33.5"
   };
 });
 
@@ -447314,7 +447602,7 @@ import {
 } from "node:fs";
 import { tmpdir as tmpdir12 } from "node:os";
 import path45 from "node:path";
-function isRecord16(value) {
+function isRecord17(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isPathInsideOrEqual2(childPath, parentPath) {
@@ -447330,7 +447618,7 @@ function readPackageJson(packageJsonPath) {
   } catch (error5) {
     throw new Error(`Could not read package.json: ${error5 instanceof Error ? error5.message : String(error5)}`);
   }
-  if (!isRecord16(parsed)) {
+  if (!isRecord17(parsed)) {
     throw new Error("package.json must be an object");
   }
   return parsed;
@@ -447340,7 +447628,7 @@ function formatRepository(repository) {
     const trimmed2 = repository.trim();
     return trimmed2 || undefined;
   }
-  if (!isRecord16(repository))
+  if (!isRecord17(repository))
     return;
   const url2 = repository.url;
   if (typeof url2 !== "string")
@@ -447870,7 +448158,7 @@ function hasRuntimeDependencies(packageJson) {
   if (!packageJson)
     return false;
   const dependencies4 = packageJson.dependencies;
-  return isRecord16(dependencies4) && Object.keys(dependencies4).length > 0;
+  return isRecord17(dependencies4) && Object.keys(dependencies4).length > 0;
 }
 function readPackageJsonIfExists(packageDirectory) {
   const packageJsonPath = path45.join(packageDirectory, "package.json");
@@ -511968,4 +512256,4 @@ function registerBunOAuthFlows() {
 registerBunOAuthFlows();
 await init_src5().then(() => exports_src2);
 
-//# debugId=E297E0391CF07BFB64756E2164756E21
+//# debugId=4BF692CA3D7D262964756E2164756E21