@theokit/sdk 4.38.0 → 4.39.0

package/dist/{chunk-VUDH4D2M.js → chunk-GIRD3RWH.js}

@@ -1,32 +1,33 @@
 import { extractCodePlugins } from './chunk-2SFBB54R.js';
-import { submit, emitRunEvent } from './chunk-7QDTZJRV.js';
-import { enqueueSessionWrite, hydrateSession, persistTurnToTranscript, flushSessionWrites, appendSessionMessage, getSessionMessages, discardSession, clearSession } from './chunk-A4XXV2C6.js';
-import { FsSessionStore } from './chunk-4NVV3GRU.js';
-import { discoverProviderPlugins, getConfiguredBaseUrl, httpRequest, isFixtureApiKey, shouldUseRealLocalRuntime, CircuitBreaker, buildDefaultSummarizer, parseSseStream, resolveProviderChain, inferProviderFromApiKey, detectPrimaryProvider, tryFirstEvent, relayStream, mapOpenAICompatibleError, renderToolResultContentText } from './chunk-HI6G3SNY.js';
-import { IndexManager, writeSessionSummary, memoryDir, globalEmbeddingCache, appendFact, readFacts, legacyMemoryJsonPath, memoryMdPath, appendFactToMarkdown } from './chunk-4APWS2YF.js';
-import { loadHookConfig, warnOnce, currentPersonalityContext, warnPersonalitySwitchInsideFork } from './chunk-M6UUTNDT.js';
+import { submit, emitRunEvent } from './chunk-LJX2SQV2.js';
+import { enqueueSessionWrite, hydrateSession, persistTurnToTranscript, flushSessionWrites, appendSessionMessage, getSessionMessages, discardSession, clearSession } from './chunk-E2FFG33C.js';
+import { FsSessionStore } from './chunk-KGRIHEDT.js';
+import { discoverProviderPlugins, getConfiguredBaseUrl, httpRequest, isFixtureApiKey, shouldUseRealLocalRuntime, CircuitBreaker, buildDefaultSummarizer, parseSseStream, resolveProviderChain, inferProviderFromApiKey, detectPrimaryProvider, tryFirstEvent, relayStream, renderToolResultContentText } from './chunk-ZYB6B7QJ.js';
+import { IndexManager, writeSessionSummary, memoryDir, appendFact, readFacts, legacyMemoryJsonPath, memoryMdPath, appendFactToMarkdown } from './chunk-4F7JQZOX.js';
+import { loadHookConfig, warnOnce, currentPersonalityContext, warnPersonalitySwitchInsideFork } from './chunk-ML5A5DOJ.js';
 import { resolveChildEnv } from './chunk-7GFX45DD.js';
-import { readVersionedJson, getTheokitHome, writeVersionedJson } from './chunk-UD2T7ISG.js';
+import { readVersionedJson, getTheokitHome, writeVersionedJson } from './chunk-YP67XZES.js';
+import { createOpenAiCompatibleRuntime } from './chunk-QKE556YD.js';
 import { sanitizeToolInput } from './chunk-U54XCYG3.js';
-import { subAgentToolsFromDefinitions, inheritSubAgentCredentials } from './chunk-FV3YEMQ7.js';
+import { withInheritedSubAgentCredentials, subAgentToolsFromDefinitions } from './chunk-RP5HQVLD.js';
 import { setAgentFacade } from './chunk-6X6ID4MO.js';
 import { findGitRoot, DEFAULT_DISCOVERY_SPECS, walkUpForFile, walkUpForGlob } from './chunk-UJ7IQJAG.js';
 import { withToolWhitelist, checkToolWhitelist } from './chunk-7AD3ZTZL.js';
-import { mapWithConcurrency } from './chunk-4WIJSKFA.js';
-import { withFileLock } from './chunk-XJ5TMOGA.js';
+import { mapWithConcurrency } from './chunk-LGILIGV3.js';
+import { defaultBaseDir, expandTilde } from './chunk-JRLXEYR4.js';
+import { withFileLock } from './chunk-BQDUEG4C.js';
 import { withCwdMutex } from './chunk-2XLKLVVR.js';
-import { defaultBaseDir, expandTilde } from './chunk-AOZYORH7.js';
 import { toJsonSchema } from './chunk-4VPXM6UU.js';
-import { atomicWriteJson } from './chunk-LGCEYEU2.js';
-import { loadSubagents } from './chunk-HHUDNTZC.js';
-import { resolveEffectiveContextWindow, CONTEXT_WINDOW_FLOOR, CONTEXT_WINDOW_MARGIN } from './chunk-A6GXYF2Q.js';
+import { atomicWriteJson } from './chunk-KX7JV5KM.js';
+import { loadSubagents } from './chunk-YRXY2A5L.js';
+import { resolveEffectiveContextWindow, CONTEXT_WINDOW_FLOOR, CONTEXT_WINDOW_MARGIN } from './chunk-65ONFZWM.js';
 import { parseModelId } from './chunk-X2FR4OIT.js';
-import { getCatalogModelInfo, registerBuiltins, getProviderProfile, registerProvider, isPatchedModelKey } from './chunk-3XKVRLR2.js';
-import { escapeBlockBody, buildSkillsBlock, discoverSkills, stripSkillFrontmatter } from './chunk-KWXC6ERT.js';
-import { validateArtifactPath, PathTraversalError, safePathJoin } from './chunk-JCXIDFRI.js';
-import { readWorkspaceDir, parseSimpleYaml } from './chunk-QFWQLXCL.js';
-import { AgentRunError, coerceToKnownAgentRunErrorCode, UnknownAgentError, ConfigurationError, AuthenticationError, UnsupportedRunOperationError, AgentDisposedError, NetworkError, TheokitAgentError } from './chunk-ZYOHF37V.js';
-import { diag, redactSecrets } from './chunk-KCZW75PI.js';
+import { getCatalogModelInfo, registerBuiltins, getProviderProfile, registerProvider, isPatchedModelKey } from './chunk-TOTP24P6.js';
+import { escapeBlockBody, buildSkillsBlock, discoverSkills, stripSkillFrontmatter } from './chunk-42IFCKQZ.js';
+import { validateArtifactPath, PathTraversalError, safePathJoin } from './chunk-J3UK2GMN.js';
+import { readWorkspaceDir, parseSimpleYaml } from './chunk-AR5MQZ3J.js';
+import { AgentRunError, coerceToKnownAgentRunErrorCode, UnknownAgentError, ConfigurationError, AuthenticationError, UnsupportedRunOperationError, AgentDisposedError, NetworkError, TheokitAgentError } from './chunk-SG5ZWT6C.js';
+import { diag, redactSecrets } from './chunk-IVSD7L22.js';
 import { stat, mkdir, readFile, readdir, access, unlink } from 'fs/promises';
 import { randomUUID, createHash } from 'crypto';
 import { join, dirname, resolve, relative, isAbsolute } from 'path';
@@ -221,7 +222,7 @@ async function agentGenerate(agent, agentModel, agentApiKey, agentLocal, input,
   const { output, maxRetries, errorStrategy, ...sendOptions } = options;
   const run = await agent.send(input, sendOptions);
   const result = await run.wait();
-  const { generateObjectImpl, GenerateObjectError } = await import('./generate-object-LPSO6GVW.js');
+  const { generateObjectImpl, GenerateObjectError } = await import('./generate-object-XDCBYVK3.js');
   const answer = structurableAnswerOrThrow(result, GenerateObjectError);
   const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
   const facade = getAgentFacade();
@@ -4989,6 +4990,35 @@ var UsageAccumulator = class {
   }
 };
 
+// src/internal/agent-loop/live-events.ts
+var LiveEventLog = class extends Array {
+  /**
+   * Not readonly, and not a constructor parameter — `Array` subclasses are re-instantiated by
+   * `map`/`filter`/`slice` with a length argument, so a constructor with a different signature
+   * breaks those. The sink is attached after construction instead.
+   */
+  #sink;
+  /** Attach the live subscriber. One sink: the run that owns this loop. */
+  subscribe(sink) {
+    this.#sink = sink;
+  }
+  push(...events) {
+    const length = super.push(...events);
+    for (const event of events) {
+      try {
+        this.#sink?.(event);
+      } catch {
+      }
+    }
+    return length;
+  }
+};
+function createEventLog(seed) {
+  const log = new LiveEventLog();
+  log.push(...seed);
+  return log;
+}
+
 // src/internal/agent-loop/message-builders.ts
 function buildSystemEvent(inputs, toolNames) {
   return {
@@ -5016,7 +5046,7 @@ function buildAssistantEvent(inputs, text) {
     message: { role: "assistant", content: [{ type: "text", text }] }
   };
 }
-function buildThinkingEvent(inputs, text, thinkingDurationMs) {
+function buildThinkingEvent(inputs, text, thinkingDurationMs, signature) {
   const event = {
     type: "thinking",
     agent_id: inputs.agentId,
@@ -5026,44 +5056,17 @@ function buildThinkingEvent(inputs, text, thinkingDurationMs) {
   if (thinkingDurationMs !== void 0 && thinkingDurationMs >= 0) {
     event.thinking_duration_ms = thinkingDurationMs;
   }
+  if (signature !== void 0) event.signature = signature;
   return event;
 }
-function buildAssistantTurn(text, toolCalls) {
+function buildAssistantTurn(text, toolCalls, thinking) {
   const content = [];
+  if (thinking !== void 0) content.push(thinking);
   if (text.length > 0) content.push({ type: "text", text });
   for (const call of toolCalls) content.push(call);
   return { role: "assistant", content };
 }
 
-// src/internal/agent-loop/live-events.ts
-var LiveEventLog = class extends Array {
-  /**
-   * Not readonly, and not a constructor parameter — `Array` subclasses are re-instantiated by
-   * `map`/`filter`/`slice` with a length argument, so a constructor with a different signature
-   * breaks those. The sink is attached after construction instead.
-   */
-  #sink;
-  /** Attach the live subscriber. One sink: the run that owns this loop. */
-  subscribe(sink) {
-    this.#sink = sink;
-  }
-  push(...events) {
-    const length = super.push(...events);
-    for (const event of events) {
-      try {
-        this.#sink?.(event);
-      } catch {
-      }
-    }
-    return length;
-  }
-};
-function createEventLog(seed) {
-  const log = new LiveEventLog();
-  log.push(...seed);
-  return log;
-}
-
 // src/internal/agent-loop/loop-context-init.ts
 function buildUserContent(text, images) {
   const content = [{ type: "text", text }];
@@ -5313,6 +5316,7 @@ async function streamLlmTurn(inputs, ctx) {
   emitLlmMetrics(inputs, result, startAt);
   llmSpan?.end();
   const stripped = stripThinkBlocks(collected.accumulatedText);
+  const thinking = result.thinking ?? collected.thinking;
   return {
     text: stripped.visible,
     toolCalls: result.toolCalls,
@@ -5322,18 +5326,21 @@ async function streamLlmTurn(inputs, ctx) {
     outputTokens: result.outputTokens,
     cacheReadTokens: result.cacheReadTokens,
     cacheWriteTokens: result.cacheWriteTokens,
-    reasoningTokens: result.reasoningTokens
+    reasoningTokens: result.reasoningTokens,
+    ...thinking !== void 0 ? { thinking } : {}
   };
 }
 async function collectLlmEvents(generator, inputs, ctx) {
   let accumulatedText = "";
   let errored = false;
   let finishValue;
+  let thinking;
   try {
     const result = await runCollectorLoop(generator, inputs, ctx);
     accumulatedText = result.accumulatedText;
     errored = result.errored;
     finishValue = result.finishValue;
+    thinking = result.thinking;
   } catch (cause) {
     if (inputs.signal?.aborted === true) {
       ctx.finalText = "[aborted]";
@@ -5344,7 +5351,12 @@ async function collectLlmEvents(generator, inputs, ctx) {
     }
     errored = true;
   }
-  return { accumulatedText, errored, finishValue };
+  return {
+    accumulatedText,
+    errored,
+    finishValue,
+    ...thinking !== void 0 ? { thinking } : {}
+  };
 }
 function registerLoopError(ctx, cause) {
   if (ctx.error !== void 0) return;
@@ -5355,11 +5367,26 @@ function registerLoopError(ctx, cause) {
   const code = typeof metaCode === "string" ? metaCode : typeof rawCode === "string" ? rawCode : void 0;
   ctx.error = code !== void 0 ? { message, code, cause } : { message, cause };
 }
+async function consumeStreamEvent(inputs, reasoning, event) {
+  if (event.type === "text_delta") {
+    const text = event.text ?? "";
+    await emitTextDeltaCallback(inputs, text);
+    return text;
+  }
+  if (event.type === "reasoning_delta") {
+    await consumeReasoningDelta(inputs, reasoning, {
+      text: event.text ?? "",
+      ...event.signature !== void 0 ? { signature: event.signature } : {}
+    });
+  }
+  return "";
+}
 async function runCollectorLoop(generator, inputs, ctx) {
   let accumulatedText = "";
-  const reasoning = { text: "", startedAt: void 0 };
+  const reasoning = { text: "", startedAt: void 0, signature: void 0 };
   let errored = false;
   let finishValue;
+  let thinking;
   try {
     while (true) {
       const next = await generator.next();
@@ -5367,24 +5394,22 @@ async function runCollectorLoop(generator, inputs, ctx) {
         finishValue = next;
         break;
       }
-      if (next.value.type === "text_delta") {
-        accumulatedText += next.value.text;
-        await emitTextDeltaCallback(inputs, next.value.text);
-      }
-      if (next.value.type === "reasoning_delta") {
-        await accumulateReasoning(inputs, reasoning, next.value.text);
-      }
       if (next.value.type === "error") {
         registerLoopError(ctx, next.value);
         ctx.finalText = "";
         errored = true;
         break;
       }
+      accumulatedText += await consumeStreamEvent(inputs, reasoning, next.value);
     }
   } finally {
-    await finalizeReasoning(inputs, ctx, reasoning);
+    thinking = await finalizeReasoning(inputs, ctx, reasoning);
   }
-  return { accumulatedText, errored, finishValue };
+  return { accumulatedText, errored, finishValue, ...thinking !== void 0 ? { thinking } : {} };
+}
+async function consumeReasoningDelta(inputs, reasoning, delta) {
+  if (delta.signature !== void 0) reasoning.signature = delta.signature;
+  await accumulateReasoning(inputs, reasoning, delta.text);
 }
 async function accumulateReasoning(inputs, reasoning, text) {
   if (reasoning.startedAt === void 0) reasoning.startedAt = Date.now();
@@ -5392,10 +5417,17 @@ async function accumulateReasoning(inputs, reasoning, text) {
   await emitReasoningDeltaCallback(inputs, text);
 }
 async function finalizeReasoning(inputs, ctx, reasoning) {
-  if (reasoning.text.length === 0) return;
+  if (reasoning.text.length === 0) return void 0;
   const thinkingDurationMs = reasoning.startedAt === void 0 ? 0 : Date.now() - reasoning.startedAt;
-  ctx.events.push(buildThinkingEvent(inputs, reasoning.text, thinkingDurationMs));
+  ctx.events.push(
+    buildThinkingEvent(inputs, reasoning.text, thinkingDurationMs, reasoning.signature)
+  );
   await emitThinkingCompletedCallback(inputs, thinkingDurationMs);
+  return {
+    type: "thinking",
+    text: reasoning.text,
+    ...reasoning.signature !== void 0 ? { signature: reasoning.signature } : {}
+  };
 }
 async function emitTextDeltaCallback(inputs, text) {
   if (inputs.onDelta === void 0) return;
@@ -5425,6 +5457,24 @@ async function emitThinkingCompletedCallback(inputs, thinkingDurationMs) {
   );
 }
 
+// src/internal/agent-loop/loop-thinking-steps.ts
+function thinkingStep(thinking) {
+  return {
+    type: "thinkingMessage",
+    message: {
+      text: thinking.text,
+      ...thinking.signature !== void 0 ? { signature: thinking.signature } : {}
+    }
+  };
+}
+function recordThinkingOnSilentToolRound(ctx, text, thinking) {
+  if (text.length > 0 || thinking === void 0) return;
+  ctx.conversation.push({
+    type: "agentConversationTurn",
+    turn: { steps: [thinkingStep(thinking)] }
+  });
+}
+
 // src/internal/tool-dispatch/repair-middleware.ts
 var DECIMAL_RE = /^-?\d+(\.\d+)?$/;
 function repairToolCall(raw, registry) {
@@ -6476,12 +6526,13 @@ async function runAgentLoop(inputs) {
     sendSpan?.end();
   }
 }
-async function emitAssistantTextStep(inputs, ctx, text) {
+async function emitAssistantTextStep(inputs, ctx, text, thinking) {
   ctx.events.push(buildAssistantEvent(inputs, text));
-  ctx.conversation.push({
-    type: "agentConversationTurn",
-    turn: { steps: [{ type: "assistantMessage", message: { text } }] }
-  });
+  const steps = [
+    ...thinking !== void 0 ? [thinkingStep(thinking)] : [],
+    { type: "assistantMessage", message: { text } }
+  ];
+  ctx.conversation.push({ type: "agentConversationTurn", turn: { steps } });
   ctx.finalText = text;
   if (inputs.onStep === void 0) return;
   const cb = inputs.onStep;
@@ -6617,13 +6668,15 @@ async function continueOrTerminate(inputs, ctx, llmOutput) {
   if (llmOutput.errored) return "error";
   const tCtx = { agentId: inputs.agentId, runId: inputs.runId };
   const text = llmOutput.text.length > 0 ? await transformLlmOutputText(inputs, llmOutput.text, tCtx) : llmOutput.text;
+  const thinking = llmOutput.thinking;
   if (text.length > 0) {
-    await emitAssistantTextStep(inputs, ctx, text);
+    await emitAssistantTextStep(inputs, ctx, text, thinking);
   }
   if (llmOutput.stopReason !== "tool_use" || llmOutput.toolCalls.length === 0) {
     return finishOrReflect(inputs, ctx, llmOutput);
   }
-  ctx.messages.push(buildAssistantTurn(text, llmOutput.toolCalls));
+  recordThinkingOnSilentToolRound(ctx, text, thinking);
+  ctx.messages.push(buildAssistantTurn(text, llmOutput.toolCalls, thinking));
   const rawResults = await dispatchTools(
     // SE12 — forward a read-only text projection of the transcript-so-far to tool
     // handlers via `ctx.messages` (consumed by defineSubAgent's messageFilter).
@@ -6659,7 +6712,9 @@ async function inspectDoomLoop(inputs, ctx, toolCalls) {
     await emitAssistantTextStep(
       inputs,
       ctx,
-      verdict.message ?? "Stopped: repeated identical tool calls made no progress."
+      verdict.message ?? "Stopped: repeated identical tool calls made no progress.",
+      // The doom-loop stop message is the SDK's own text, not a model turn — it has no thinking.
+      void 0
     );
     return "stop";
   }
@@ -6806,7 +6861,20 @@ var StdioMcpClient = class extends BaseMcpClient {
       );
     });
   }
+  /**
+   * theokit#155 — idempotent while the child is LIVE.
+   *
+   * Under `mcpLifecycle: 'session'` the pool hands the same client back on the next turn, and
+   * `initializeMcp` runs every turn. An unconditional `spawnChild()` would overwrite `this.child`,
+   * orphaning a healthy process (its `exit` handler is skipped by the `this.child === child` guard)
+   * and paying the ~146 ms spawn + handshake the option exists to avoid.
+   *
+   * This does NOT touch the #59 reconnect path: `reconnect()` calls `spawnChild()` and
+   * `super.initialize()` directly, so it re-spawns exactly as before. After `close()` — or after a
+   * drop, which clears `child` — this method spawns again, as it must.
+   */
   async initialize() {
+    if (this.child !== void 0) return;
     this.spawnChild();
     await super.initialize();
   }
@@ -7177,16 +7245,15 @@ function declarativeSubagentTools(agents2, parentTools) {
   if (agents2 === void 0 || Object.keys(agents2).length === 0) return [];
   return subAgentToolsFromDefinitions(agents2, parentTools);
 }
-function bindParentCredentials(tools, agentOptions) {
+function resolveInheritedCredentials(agentOptions) {
   const parentPlugins = Array.isArray(agentOptions.plugins) ? agentOptions.plugins : void 0;
   const parentSandbox = agentOptions.local?.sandboxOptions?.enabled;
-  const credentials = {
+  return {
     ...agentOptions.apiKey !== void 0 ? { apiKey: agentOptions.apiKey } : {},
     ...typeof agentOptions.model === "object" ? { model: agentOptions.model } : {},
     ...parentPlugins !== void 0 ? { plugins: parentPlugins } : {},
     ...parentSandbox !== void 0 ? { sandbox: parentSandbox } : {}
   };
-  for (const tool of tools) inheritSubAgentCredentials(tool, credentials);
 }
 function buildCustomToolsInput(agentOptions, sendOptions, pluginManager, personalityToolWhitelist, agentId, personalityName, subagents, effectiveModel) {
   const baseTools = sendOptions?.tools ?? agentOptions.tools ?? [];
@@ -7198,7 +7265,6 @@ function buildCustomToolsInput(agentOptions, sendOptions, pluginManager, persona
     return {};
   }
   const allTools = [...baseTools, ...subagentTools, ...pluginTools, ...reasoningTools];
-  bindParentCredentials(allTools, agentOptions);
   const merged = allTools.map((tool) => ({
     name: tool.name,
     description: tool.description,
@@ -7234,7 +7300,9 @@ function createRealLocalRun(options) {
       supportedOps: supported,
       startTime
     },
-    () => buildLoopInputs(options, id, userText, userImages)
+    () => buildLoopInputs(options, id, userText, userImages),
+    runOwnsMcpClients(options.agentOptions),
+    resolveInheritedCredentials(options.agentOptions)
   );
   handle.bootstrap();
   registerRun(handle);
@@ -7373,11 +7441,14 @@ function disposeSessionMcpClients(agentId) {
     void client.close();
   });
 }
+function runOwnsMcpClients(agentOptions) {
+  return agentOptions.mcpLifecycle !== "session";
+}
 function buildMcpMap(options) {
   const map = /* @__PURE__ */ new Map();
   const inline = options.sendOptions.mcpServers ?? options.agentOptions.mcpServers;
   if (inline === void 0) return map;
-  const pooled = options.agentOptions.mcpLifecycle === "session";
+  const pooled = !runOwnsMcpClients(options.agentOptions);
   if (pooled) sessionMcpPool.reapIdle((c) => void c.close());
   for (const [name, config] of Object.entries(inline)) {
     map.set(
@@ -7389,9 +7460,15 @@ function buildMcpMap(options) {
 }
 var RealLocalRun = class extends FixtureRunBase {
   buildInputs;
-  constructor(options, buildInputs) {
+  /** theokit#155 — whether this turn releases its MCP clients, or the session pool does. */
+  ownsMcpClients;
+  /** theokit#148 — what a delegated child inherits from this parent, scoped to the loop. */
+  inheritedCredentials;
+  constructor(options, buildInputs, ownsMcpClients, inheritedCredentials) {
     super(options);
     this.buildInputs = buildInputs;
+    this.ownsMcpClients = ownsMcpClients;
+    this.inheritedCredentials = inheritedCredentials;
   }
   bootstrap() {
     setTimeout(() => {
@@ -7452,15 +7529,18 @@ var RealLocalRun = class extends FixtureRunBase {
       this.pushTimeline({ kind: "delta", update: delta.update });
     };
     try {
-      const output = inputs.activeTools !== void 0 ? await withToolWhitelist(new Set(inputs.activeTools), () => runAgentLoop(inputs)) : await runAgentLoop(inputs);
+      const runLoop = () => inputs.activeTools !== void 0 ? withToolWhitelist(new Set(inputs.activeTools), () => runAgentLoop(inputs)) : runAgentLoop(inputs);
+      const output = await withInheritedSubAgentCredentials(this.inheritedCredentials, runLoop);
       this.applyAgentLoopOutput(output);
       this.transitionTo(output.finalStatus);
     } catch (cause) {
       this.emitErrorEvent(cause, "Agent loop failed", "", "agent_loop_failed");
       this.transitionTo("error");
     } finally {
-      for (const client of inputs.mcp.values()) {
-        await client.close().catch(() => void 0);
+      if (this.ownsMcpClients) {
+        for (const client of inputs.mcp.values()) {
+          await client.close().catch(() => void 0);
+        }
       }
     }
   }
@@ -8067,184 +8147,6 @@ function cacheKey(userText, queryMode, ctx) {
   const parts = [queryMode, ctx?.namespace ?? "", ctx?.userId ?? "", ctx?.scope ?? "", userText];
   return createHash("sha256").update(parts.join("\0")).digest("hex");
 }
-var MAX_BATCH = 100;
-var MAX_RETRIES = 2;
-async function createOpenAiCompatibleRuntime(cfg, options) {
-  const model = options.model ?? cfg.defaultModel;
-  const apiKey = options.apiKey ?? process.env[cfg.apiKeyEnv];
-  if (apiKey === void 0 || apiKey.length === 0) {
-    throw new AuthenticationError(`${cfg.apiKeyEnv} missing`, {
-      code: "embedding_missing_api_key"
-    });
-  }
-  const envBaseUrl = cfg.baseUrlEnv !== void 0 ? process.env[cfg.baseUrlEnv] : void 0;
-  const baseUrl = options.baseUrl ?? envBaseUrl ?? cfg.defaultBaseUrl;
-  const fetchImpl = options.fetch ?? fetch;
-  const cache = options.cache ?? globalEmbeddingCache;
-  const dimension = cfg.dimensionByModel[model];
-  if (dimension === void 0) {
-    throw new ConfigurationError(
-      `${cfg.id} adapter: model "${model}" is not in the dimension table. Use one of: ${Object.keys(cfg.dimensionByModel).join(", ")}. To add it, update dimensionByModel in the adapter source.`,
-      { code: "embedding_unknown_model" }
-    );
-  }
-  const embeddingsPath = cfg.embeddingsPath ?? "/v1/embeddings";
-  const stats = {
-    cacheHits: 0,
-    cacheMisses: 0,
-    httpCalls: 0,
-    retries: 0
-  };
-  return {
-    id: cfg.id,
-    model,
-    dimension,
-    stats: () => ({ ...stats }),
-    embed: (texts) => embedTexts({
-      texts,
-      cache,
-      stats,
-      model,
-      dimension,
-      apiKey,
-      baseUrl,
-      embeddingsPath,
-      fetchImpl,
-      providerId: cfg.id
-    })
-  };
-}
-async function embedTexts(input) {
-  const { texts, cache, stats, model, dimension } = input;
-  const results = new Array(texts.length);
-  const pending = [];
-  for (let i = 0; i < texts.length; i++) {
-    classifyEntry({
-      index: i,
-      text: texts[i] ?? "",
-      model,
-      dimension,
-      cache,
-      stats,
-      results,
-      pending
-    });
-  }
-  await embedInBoundedBatches(input, pending, results);
-  return results.map((v) => v ?? new Array(dimension).fill(0));
-}
-function classifyEntry(args) {
-  if (args.text.trim().length === 0) {
-    args.results[args.index] = new Array(args.dimension).fill(0);
-    return;
-  }
-  const key = hashKey(args.model, args.text);
-  const cached = args.cache.get(key);
-  if (cached !== void 0) {
-    args.stats.cacheHits += 1;
-    args.results[args.index] = cached;
-    return;
-  }
-  args.stats.cacheMisses += 1;
-  args.pending.push({ index: args.index, text: args.text, key });
-}
-var MAX_CONCURRENT_BATCHES = 3;
-async function embedInBoundedBatches(input, pending, results) {
-  const batches = [];
-  for (let offset = 0; offset < pending.length; offset += MAX_BATCH) {
-    batches.push(pending.slice(offset, offset + MAX_BATCH));
-  }
-  await mapWithConcurrency(
-    batches,
-    MAX_CONCURRENT_BATCHES,
-    (batch) => processBatch(input, batch, results)
-  );
-}
-async function processBatch(input, batch, results) {
-  const vectors = await embedBatch({
-    apiKey: input.apiKey,
-    baseUrl: input.baseUrl,
-    embeddingsPath: input.embeddingsPath,
-    model: input.model,
-    inputs: batch.map((b) => b.text),
-    fetchImpl: input.fetchImpl,
-    stats: input.stats,
-    providerId: input.providerId
-  });
-  for (let j = 0; j < batch.length; j++) {
-    const slot = batch[j];
-    const vector = vectors[j];
-    if (slot === void 0 || vector === void 0) continue;
-    results[slot.index] = vector;
-    input.cache.set(slot.key, vector);
-  }
-}
-async function embedBatch(opts) {
-  const url = `${opts.baseUrl.replace(/\/$/, "")}${opts.embeddingsPath}`;
-  let attempt = 0;
-  while (true) {
-    opts.stats.httpCalls += 1;
-    const response = await postEmbedRequest(opts, url);
-    if (response.ok)
-      return await parseEmbedResponse(response, opts.providerId, opts.embeddingsPath);
-    if (isRetryable(response.status) && attempt < MAX_RETRIES) {
-      attempt += 1;
-      opts.stats.retries += 1;
-      await sleep(linearBackoffMs(attempt));
-      continue;
-    }
-    const text = await response.text().catch(() => "");
-    let body = text;
-    try {
-      body = JSON.parse(text);
-    } catch {
-    }
-    throw mapOpenAICompatibleError({
-      providerId: opts.providerId,
-      status: response.status,
-      body,
-      headers: response.headers,
-      endpoint: opts.embeddingsPath
-    });
-  }
-}
-async function postEmbedRequest(opts, url) {
-  return opts.fetchImpl(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${opts.apiKey}`
-    },
-    body: JSON.stringify({ model: opts.model, input: opts.inputs })
-  });
-}
-async function parseEmbedResponse(response, providerId, endpoint) {
-  const json = await response.json();
-  if (!Array.isArray(json.data)) {
-    throw new NetworkError(`${providerId} ${endpoint} returned no data`, {
-      code: "embedding_invalid_response",
-      metadata: {
-        provider: providerId,
-        endpoint,
-        code: "invalid_request",
-        raw: json
-      }
-    });
-  }
-  return json.data.map((d) => d.embedding);
-}
-function isRetryable(status) {
-  return status === 429 || status >= 500 && status < 600;
-}
-function hashKey(model, text) {
-  return createHash("sha256").update(`${model} ${text}`).digest("hex");
-}
-function linearBackoffMs(attempt) {
-  return 50 * attempt;
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
 
 // src/internal/memory/adapters/azure-openai-embedding.ts
 var DEFAULT_AZURE_OPENAI_EMBEDDING_MODEL = "text-embedding-3-small";
@@ -8267,7 +8169,15 @@ var azureOpenAiMemoryEmbeddingProviderAdapter = {
       baseUrlEnv: "AZURE_OPENAI_ENDPOINT",
       defaultModel: DEFAULT_AZURE_OPENAI_EMBEDDING_MODEL,
       embeddingsPath: "/openai/deployments/{model}/embeddings?api-version=2024-02-01",
-      dimensionByModel: DIMENSION_BY_MODEL
+      dimensionByModel: DIMENSION_BY_MODEL,
+      // theokit#159 — Azure is NOT OpenAI on the wire, despite the name. It authenticates an API
+      // key with the `api-key` header (`Authorization: Bearer` is for Entra ID tokens, not for
+      // AZURE_OPENAI_API_KEY), and the deployment already rides in the path, so `model` has no
+      // place in the body. Sending the OpenAI shape meant every request was rejected.
+      dialect: {
+        authHeaders: (apiKey) => ({ "api-key": apiKey }),
+        body: (_model, inputs) => ({ input: inputs })
+      }
     },
     options
   )
@@ -8294,7 +8204,20 @@ var cohereMemoryEmbeddingProviderAdapter = {
       apiKeyEnv: "COHERE_API_KEY",
       defaultModel: DEFAULT_COHERE_EMBEDDING_MODEL,
       embeddingsPath: "/v2/embed",
-      dimensionByModel: DIMENSION_BY_MODEL2
+      dimensionByModel: DIMENSION_BY_MODEL2,
+      // theokit#159 — `/v2/embed` diverges in BOTH directions: it names the payload `texts`, requires
+      // `input_type`, and answers `{embeddings:{float:[[...]]}}` rather than `{data:[{embedding}]}`.
+      // `search_document` is the right default here because this runtime embeds material for
+      // storage; a query-side embedder would use `search_query`.
+      dialect: {
+        body: (model, inputs) => ({
+          model,
+          texts: [...inputs],
+          input_type: "search_document",
+          embedding_types: ["float"]
+        }),
+        vectors: (json) => json.embeddings?.float
+      }
     },
     options
   )
@@ -8352,6 +8275,9 @@ var geminiMemoryEmbeddingProviderAdapter = {
       defaultBaseUrl: "https://generativelanguage.googleapis.com",
       apiKeyEnv: "GEMINI_API_KEY",
       defaultModel: DEFAULT_GEMINI_EMBEDDING_MODEL,
+      // theokit#159 — the compat surface is under `/v1beta/openai/`, not the default
+      // `/v1/embeddings`; the previous path 404'd on every call.
+      embeddingsPath: "/v1beta/openai/embeddings",
       dimensionByModel: DIMENSION_BY_MODEL4
     },
     options
@@ -9164,7 +9090,7 @@ function localAgentRunUntil(agent, goal, options) {
   async function* wrap() {
     const { runUntilImpl } = await import('./run-until-BK56WG4P.js');
     const buildDeps = async () => {
-      const { judgeCallImpl } = await import('./judge-call-3S3T6O2Z.js');
+      const { judgeCallImpl } = await import('./judge-call-NA2G6ZMJ.js');
       const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
       const create = getAgentFacade().create;
       return {
@@ -9197,7 +9123,7 @@ async function* localAgentStreamToCompletion(agent, message, options) {
 async function localAgentFork(parent, options) {
   const { forkAgentImpl } = await import('./fork-agent-RSV4E3EA.js');
   const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
-  const { withPersonalityContext } = await import('./context-ZDBBPIHY.js');
+  const { withPersonalityContext } = await import('./context-ATJJAFOS.js');
   const create = getAgentFacade().create;
   return withPersonalityContext(
     { slug: parent.personalitySlugSnapshot, isFork: true },
@@ -9578,7 +9504,7 @@ async function executeSendLocked(inputs, message, options) {
 function buildCompletionCheckDeps() {
   return {
     judge: async (ctx, opts) => {
-      const { judgeCallImpl } = await import('./judge-call-3S3T6O2Z.js');
+      const { judgeCallImpl } = await import('./judge-call-NA2G6ZMJ.js');
       const { getAgentFacade } = await import('./agent-factory-registry-ZVTABLEY.js');
       return judgeCallImpl(ctx, opts, { create: getAgentFacade().create });
     }
@@ -10336,7 +10262,7 @@ var Agent = class _Agent {
    * @public
    */
   static async generateObject(options) {
-    const { generateObjectImpl } = await import('./generate-object-LPSO6GVW.js');
+    const { generateObjectImpl } = await import('./generate-object-XDCBYVK3.js');
     return generateObjectImpl(options, {
       create: (opts) => _Agent.create(opts),
       delete: (agentId) => _Agent.delete(agentId)
@@ -10360,7 +10286,7 @@ var Agent = class _Agent {
       delete: (agentId) => _Agent.delete(agentId)
     };
     async function* wrapper() {
-      streamObjectImport ??= import('./stream-object-AFERZU63.js');
+      streamObjectImport ??= import('./stream-object-HWDEEQN4.js');
       const { streamObjectImpl } = await streamObjectImport;
       yield* streamObjectImpl(options, deps);
     }
@@ -10384,7 +10310,7 @@ var Agent = class _Agent {
    * @public
    */
   static async batch(prompts, options) {
-    const { batchImpl } = await import('./batch-LXSALQC3.js');
+    const { batchImpl } = await import('./batch-6KQM3EBA.js');
     return batchImpl(prompts, options, { create: (opts) => _Agent.create(opts) });
   }
   /**
@@ -10522,7 +10448,7 @@ var Agent = class _Agent {
         `No local agent "${agentId}" registered \u2014 compact targets local sessions.`
       );
     }
-    const { compactSessionTranscript, buildDefaultSummarizer: buildDefaultSummarizer2 } = await import('./compact-session-RR3ILTES.js');
+    const { compactSessionTranscript, buildDefaultSummarizer: buildDefaultSummarizer2 } = await import('./compact-session-PYEC3NZV.js');
     const { cwd, model, store } = await openLocalStore(reg);
     return enqueueSessionWrite(
       cwd,
@@ -10558,7 +10484,7 @@ var Agent = class _Agent {
         `No local agent "${agentId}" registered \u2014 injectSessionTurn targets local sessions.`
       );
     }
-    const { injectSessionTurn } = await import('./inject-session-RKNLUE72.js');
+    const { injectSessionTurn } = await import('./inject-session-GQMTDZUN.js');
     const { cwd, model, store } = await openLocalStore(reg);
     await injectSessionTurn({
       store,
@@ -10568,6 +10494,86 @@ var Agent = class _Agent {
       assistantText: turn.assistantText
     });
   }
+  /**
+   * theokit#146 — read a LOCAL agent's persisted transcript as STRUCTURE, for rendering.
+   *
+   * A resumed session already replays correctly to the model, but a host had no way to draw it:
+   * the only projection available folded a tool call to the string `[tool call] NAME`, dropping the
+   * call id and every argument. A card UI got prose, so cross-restart resume was worth less than
+   * starting fresh — which is what at least one consumer did.
+   *
+   * Each returned message carries both projections: `text` (unchanged, what the model replay uses)
+   * and `parts` (`text` / `tool_use` / `tool_result` with ids, names, arguments and the
+   * `toolUseId` that correlates a result back to its call).
+   *
+   * Read-only and local-only: it opens the agent's session store and walks the transcript, exactly
+   * as {@link Agent.compact} and {@link Agent.injectSessionTurn} do. It appends nothing.
+   *
+   * @throws UnknownAgentError when `agentId` names no local agent.
+   * @public
+   */
+  static async transcript(agentId) {
+    let reg = getRegisteredAgent(agentId);
+    if (reg === void 0) {
+      await hydrateRegistryFromDisk(process.cwd());
+      reg = getRegisteredAgent(agentId);
+    }
+    if (reg === void 0 || reg.runtime !== "local") {
+      throw new UnknownAgentError(
+        `No local agent "${agentId}" registered \u2014 transcript targets local sessions.`
+      );
+    }
+    const { readSessionMessages } = await import('./agent-session-store-RHMHP5DG.js');
+    const { store } = await openLocalStore(reg);
+    return readSessionMessages(store, agentId);
+  }
+  /**
+   * theokit#123 — read-only introspection of a registered agent's tools and subagents.
+   *
+   * `Agent.list()` / `Agent.get()` enumerate agents and `agent.skills.list()` covers skills, but
+   * tools and subagents lived only on `RegisteredAgent.options` — an internal contract. A
+   * reflection endpoint (theokit-studio's `theokit dev`) therefore had to report empty lists for
+   * both, and say so with an `unavailable_reason`.
+   *
+   * A PROJECTION, not the options object. Tool handlers and subagent prompts are stripped: a
+   * handler is an executable that cannot cross a process boundary, and a prompt is the agent's
+   * instructions rather than its signature — a reflection endpoint serializes what it is handed.
+   *
+   * @throws UnknownAgentError when `agentId` names no registered agent.
+   * @public
+   */
+  static async describe(agentId) {
+    const agent = await getRegisteredAgentOrThrow(agentId);
+    const { loadSubagents: loadSubagents2 } = await import('./subagents-loader-X33KH2SZ.js');
+    const settingSources = agent.options.local?.settingSources;
+    const subagents = await loadSubagents2(
+      agent.cwd ?? process.cwd(),
+      settingSources === void 0 || settingSources.includes("project"),
+      agent.options.agents
+    );
+    return {
+      agentId: agent.agentId,
+      runtime: agent.runtime,
+      ...agent.model !== void 0 ? { model: agent.model } : {},
+      // Always arrays, so a caller can tell "this agent has none" from "the SDK did not say".
+      //
+      // Honest limit, stated because the alternative is an implied claim: `tools` is still the
+      // DECLARED catalog. Plugin tools and the reasoning `think` tool are assembled per run by
+      // `buildCustomToolsInput`, so they are not knowable from the registry alone. Documented on
+      // `AgentDescription.tools`.
+      tools: (agent.options.tools ?? []).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        inputSchema: tool.inputSchema
+      })),
+      subagents: Object.entries(subagents).map(([name, def]) => ({
+        name,
+        description: def.description,
+        ...def.model !== void 0 ? { model: def.model } : {},
+        ...def.tools !== void 0 ? { tools: def.tools } : {}
+      }))
+    };
+  }
   /**
    * Permanently delete a cloud agent.
    *
@@ -10605,12 +10611,12 @@ async function openLocalStore(reg) {
   const cwd = reg.cwd ?? process.cwd();
   const optModel = reg.options.model;
   const model = reg.model?.id ?? (typeof optModel === "string" ? optModel : optModel?.id) ?? "unknown";
-  const { FsSessionStore: FsSessionStore2 } = await import('./fs-session-store-K5QUPNJZ.js');
-  const { defaultBaseDir: defaultBaseDir2, expandTilde: expandTilde2 } = await import('./session-transcript-MMPWCESR.js');
+  const { FsSessionStore: FsSessionStore2 } = await import('./fs-session-store-O6FNHECD.js');
+  const { defaultBaseDir: defaultBaseDir2, expandTilde: expandTilde2 } = await import('./session-transcript-3B52DKTG.js');
   const baseDir = reg.options.local?.baseDir !== void 0 ? expandTilde2(reg.options.local.baseDir) : defaultBaseDir2();
   return { cwd, model, store: new FsSessionStore2({ baseDir, cwd }) };
 }
 
 export { Agent, AgentBuilder, DEFAULT_AGENTIC_MODEL_ID, MEMORY_EMBEDDING_ADAPTERS, Tool, ToolError, UsageAccumulator, computeCost, generateCronId, getPricingEntry, openRouterMemoryEmbeddingProviderAdapter, resolveApiKey };
-//# sourceMappingURL=chunk-VUDH4D2M.js.map
-//# sourceMappingURL=chunk-VUDH4D2M.js.map
+//# sourceMappingURL=chunk-GIRD3RWH.js.map
+//# sourceMappingURL=chunk-GIRD3RWH.js.map