@theokit/sdk 4.38.0 → 4.39.1

package/dist/{inject-session-RKNLUE72.js → inject-session-7P4CZGDT.js}

@@ -1,8 +1,9 @@
-import { enqueueSessionWrite } from './chunk-A4XXV2C6.js';
+import { enqueueSessionWrite } from './chunk-7YSRCQDE.js';
 import { invalidateSessionCache } from './chunk-5KOW3GLE.js';
-import { SessionTranscript } from './chunk-AOZYORH7.js';
-import './chunk-LGCEYEU2.js';
-import './chunk-KCZW75PI.js';
+import './chunk-3I4B3OIX.js';
+import { SessionTranscript } from './chunk-JRLXEYR4.js';
+import './chunk-KX7JV5KM.js';
+import './chunk-IVSD7L22.js';
 
 // src/internal/session/inject-session.ts
 async function injectSessionTurn(opts) {
@@ -21,5 +22,5 @@ async function injectSessionTurn(opts) {
 }
 
 export { injectSessionTurn };
-//# sourceMappingURL=inject-session-RKNLUE72.js.map
-//# sourceMappingURL=inject-session-RKNLUE72.js.map
+//# sourceMappingURL=inject-session-7P4CZGDT.js.map
+//# sourceMappingURL=inject-session-7P4CZGDT.js.map

package/dist/inject-session-7P4CZGDT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":[],"mappings":";;;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAM,oBAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAa,iBAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAA,sBAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-7P4CZGDT.js","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}

package/dist/{inject-session-25EC74WV.cjs → inject-session-CC4KBYF6.cjs}

@@ -1,16 +1,17 @@
 'use strict';
 
-var chunk6ZGD7R27_cjs = require('./chunk-6ZGD7R27.cjs');
+var chunkVWI3CDEW_cjs = require('./chunk-VWI3CDEW.cjs');
 var chunkBURYFNOM_cjs = require('./chunk-BURYFNOM.cjs');
-var chunk6OKPJZMX_cjs = require('./chunk-6OKPJZMX.cjs');
-require('./chunk-YVI4YPUP.cjs');
-require('./chunk-BE3W4HYV.cjs');
+require('./chunk-XYOHKCYG.cjs');
+var chunkZ2CUEBXV_cjs = require('./chunk-Z2CUEBXV.cjs');
+require('./chunk-DGLLVCNB.cjs');
+require('./chunk-BCQ3E2ZG.cjs');
 
 // src/internal/session/inject-session.ts
 async function injectSessionTurn(opts) {
-  await chunk6ZGD7R27_cjs.enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {
+  await chunkVWI3CDEW_cjs.enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {
     const prior = await opts.store.readRecords(opts.loc.agentId);
-    const transcript = chunk6OKPJZMX_cjs.SessionTranscript.fromRecords(prior, {
+    const transcript = chunkZ2CUEBXV_cjs.SessionTranscript.fromRecords(prior, {
       cwd: opts.loc.cwd,
       sessionId: opts.sessionId,
       model: opts.loc.model ?? "unknown"
@@ -23,5 +24,5 @@ async function injectSessionTurn(opts) {
 }
 
 exports.injectSessionTurn = injectSessionTurn;
-//# sourceMappingURL=inject-session-25EC74WV.cjs.map
-//# sourceMappingURL=inject-session-25EC74WV.cjs.map
+//# sourceMappingURL=inject-session-CC4KBYF6.cjs.map
+//# sourceMappingURL=inject-session-CC4KBYF6.cjs.map

package/dist/inject-session-CC4KBYF6.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/session/inject-session.ts"],"names":["enqueueSessionWrite","SessionTranscript","invalidateSessionCache"],"mappings":";;;;;;;;;;AAWA,eAAsB,kBAAkB,IAAA,EAMtB;AAChB,EAAA,MAAMA,sCAAoB,IAAA,CAAK,GAAA,CAAI,KAAK,IAAA,CAAK,GAAA,CAAI,SAAS,YAAY;AACpE,IAAA,MAAM,QAAQ,MAAM,IAAA,CAAK,MAAM,WAAA,CAAY,IAAA,CAAK,IAAI,OAAO,CAAA;AAC3D,IAAA,MAAM,UAAA,GAAaC,mCAAA,CAAkB,WAAA,CAAY,KAAA,EAAO;AAAA,MACtD,GAAA,EAAK,KAAK,GAAA,CAAI,GAAA;AAAA,MACd,WAAW,IAAA,CAAK,SAAA;AAAA,MAChB,KAAA,EAAO,IAAA,CAAK,GAAA,CAAI,KAAA,IAAS;AAAA,KAC1B,CAAA;AACD,IAAA,UAAA,CAAW,cAAA,CAAe,KAAK,QAAQ,CAAA;AACvC,IAAA,UAAA,CAAW,mBAAA,CAAoB,EAAE,IAAA,EAAM,IAAA,CAAK,eAAe,CAAA;AAC3D,IAAA,MAAM,IAAA,CAAK,KAAA,CAAM,aAAA,CAAc,IAAA,CAAK,GAAA,CAAI,OAAA,EAAS,UAAA,CAAW,OAAA,EAAQ,CAAE,KAAA,CAAM,KAAA,CAAM,MAAM,CAAC,CAAA;AACzF,IAAAC,wCAAA,CAAuB,IAAA,CAAK,GAAA,CAAI,GAAA,EAAK,IAAA,CAAK,IAAI,OAAO,CAAA;AAAA,EACvD,CAAC,CAAA;AACH","file":"inject-session-CC4KBYF6.cjs","sourcesContent":["/**\n * M51 (agent-builder) — inject a SYNTHETIC user+assistant pair into a session's persisted transcript\n * WITHOUT running an LLM turn. This is the Codex review-exit mechanism (`exit_success.xml` appended to\n * the parent thread history so follow-ups like \"fix finding 2\" work): the pair chains onto the DAG\n * leaf (M50 pattern) and the in-memory cache is invalidated so the NEXT send re-hydrates with it.\n */\nimport type { SessionStore } from \"../../types/session-store.js\";\nimport { SessionTranscript } from \"../persistence/session-transcript.js\";\nimport { enqueueSessionWrite, invalidateSessionCache } from \"./agent-session.js\";\nimport type { CompactLocation } from \"./compact-session.js\";\n\nexport async function injectSessionTurn(opts: {\n  store: SessionStore;\n  loc: CompactLocation;\n  sessionId: string;\n  userText: string;\n  assistantText: string;\n}): Promise<void> {\n  await enqueueSessionWrite(opts.loc.cwd, opts.loc.agentId, async () => {\n    const prior = await opts.store.readRecords(opts.loc.agentId);\n    const transcript = SessionTranscript.fromRecords(prior, {\n      cwd: opts.loc.cwd,\n      sessionId: opts.sessionId,\n      model: opts.loc.model ?? \"unknown\",\n    });\n    transcript.appendUserTurn(opts.userText);\n    transcript.appendAssistantTurn({ text: opts.assistantText });\n    await opts.store.appendRecords(opts.loc.agentId, transcript.records().slice(prior.length));\n    invalidateSessionCache(opts.loc.cwd, opts.loc.agentId);\n  });\n}\n"]}

package/dist/internal/agent-loop/loop-thinking-steps.d.ts

@@ -0,0 +1,28 @@
+/**
+ * theokit#122 — where a round's thinking block becomes a conversation step.
+ *
+ * Extracted from `loop.ts` when it crossed the G8 400-LoC cap. These two belong together: both
+ * answer "the round produced a thinking block — where does it land in the persisted conversation",
+ * and the answer differs by which path closes the round.
+ *
+ * @internal
+ */
+import type { LlmThinkingPart } from "../llm/types.js";
+import type { LoopContext } from "./loop-context-init.js";
+/**
+ * theokit#122 — the round's thinking block as a conversation step.
+ *
+ * Shared by the two paths that can close a round: the assistant-text path and the tool_use path.
+ * The tool_use path is the one that matters — a round of thinking + a tool call with NO preamble
+ * text is the common Anthropic shape, and it is exactly the case the first version of this fix
+ * dropped (the block stayed on the context and was persisted against the NEXT round's text).
+ */
+export declare function thinkingStep(thinking: LlmThinkingPart): ConversationStep;
+/**
+ * theokit#122 — persist the block for a round that called a tool and said nothing.
+ *
+ * Such a round emits no assistant-text step, so without this the block is never recorded for it —
+ * which is exactly how the first version of this fix let round N's signature reach round N+1.
+ * No-op when the round had text (the text path already recorded it) or produced no thinking.
+ */
+export declare function recordThinkingOnSilentToolRound(ctx: LoopContext, text: string, thinking: LlmThinkingPart | undefined): void;

package/dist/internal/agent-loop/message-builders.d.ts

@@ -1,5 +1,5 @@
 import type { SDKAssistantMessage, SDKThinkingMessage, SDKUserMessageEvent } from "../../types/messages.js";
-import type { LlmMessage, LlmToolCallPart } from "../llm/types.js";
+import type { LlmMessage, LlmThinkingPart, LlmToolCallPart } from "../llm/types.js";
 import type { AgentLoopInputs } from "./loop-types.js";
 export declare function buildUserEvent(inputs: AgentLoopInputs): SDKUserMessageEvent;
 export declare function buildAssistantEvent(inputs: AgentLoopInputs, text: string): SDKAssistantMessage;
@@ -8,5 +8,14 @@ export declare function buildAssistantEvent(inputs: AgentLoopInputs, text: strin
  * issue #48: when the reasoning duration was measured, carry it as `thinking_duration_ms`
  * so a `Run.stream()` replay can render how long the model reasoned.
  */
-export declare function buildThinkingEvent(inputs: AgentLoopInputs, text: string, thinkingDurationMs?: number): SDKThinkingMessage;
-export declare function buildAssistantTurn(text: string, toolCalls: LlmToolCallPart[]): LlmMessage;
+export declare function buildThinkingEvent(inputs: AgentLoopInputs, text: string, thinkingDurationMs?: number, signature?: string): SDKThinkingMessage;
+/**
+ * theokit#122 — `thinking` is FIRST, and that ordering is a provider requirement, not a preference.
+ *
+ * Anthropic verifies the signed block on the next request and requires it to lead the assistant
+ * message it belongs to. Omitting it (which this builder did until theokit#122's follow-up) makes
+ * round 2 of any thinking + tools run fail with `400 "thinking blocks cannot be modified"` — the
+ * exact failure the issue exists to remove. An unsigned block is passed through here and dropped at
+ * the wire by `thinkingToWireBlock`, which is where that policy belongs.
+ */
+export declare function buildAssistantTurn(text: string, toolCalls: LlmToolCallPart[], thinking?: LlmThinkingPart): LlmMessage;

package/dist/internal/diagnostics.d.ts

@@ -16,20 +16,33 @@
  *
  * - **`setDiagnosticsSink(fn)`** hands the messages to the application, which decides where to put
  *   them (a status line, a file, a panel). It is what was missing for a TUI to coexist with the SDK.
- * - **With no sink, it goes to `stderr`** — exactly as before this change.
+ * - **With no sink, nothing is emitted.** A library does not own the host's terminal.
  *
- * ## Why the default did NOT change (yet), and why that is deliberate
+ * ## Silent by default, and how 36 suites survived the flip
  *
- * #147 asks for silence by default, and that is the right target. But **58 test files** currently
- * assert these diagnostics reach `stderr` — they encode the contract "the warning IS emitted",
- * which still holds and must not be lost. Flipping the default without migrating them would fail
- * ~53 tests, and migrating them in a hurry, across four different ways of spying on `stderr`, is
- * the recipe for weakening 58 suites at once.
+ * The default WAS `stderr`, and 36 test files spy on `process.stderr.write` to assert a given
+ * warning is emitted. That contract is real and had to survive; migrating all 36 by hand, across
+ * four different spy styles, is how you weaken 36 suites in one commit.
  *
- * So this change delivers the half that UNBLOCKS the consumer — a TUI host can now
- * interceptar, que era o bloqueio relatado ("no way to intercept these; no injectable logger") — e
- * and leaves flipping the default as its own migration, with a measured cost. A host that wants silence
- * hoje instala `setDiagnosticsSink(() => {})`.
+ * So the flip happened at the default, and `vitest.setup.ts` installs a sink that FORWARDS to
+ * `stderr` for the duration of every test. Those assertions still test what they always tested —
+ * "this condition emits a diagnostic" — through the channel a host would use, while production
+ * emits nothing unless asked.
+ *
+ * The cost is stated rather than hidden: no test observes the production default by accident, so
+ * `tests/diagnostics-public-entry.test.ts` pins it explicitly by clearing the sink first.
+ *
+ * ## Coverage is the whole guarantee
+ *
+ * The first sweep migrated the 92 sites under `internal/` and left `src/`'s own modules —
+ * `event-bus.ts`, `batch.ts`, `compaction.ts`, `internal/workflow/step-branch.ts`. A host could
+ * therefore install a sink and still have its frame corrupted by a batch run, which is the reported
+ * defect with a smaller blast radius. Those are routed here too, and
+ * `tests/lint/no-direct-terminal-write.test.ts` is what keeps the next hot path from
+ * reintroducing one. "Mostly interceptable" is not interceptable.
+ *
+ * The remaining direct writers are allowlisted there with a reason, and every one of them is a seam
+ * whose destination the CALLER already chooses (`opts.warn`, `opts.logger`, the Workflow logger).
  *
  * ## What this is NOT
  *

package/dist/internal/llm/anthropic-shared.d.ts

@@ -25,10 +25,6 @@ export interface AnthropicResponseLike {
 export declare function extractAnthropicText(response: AnthropicResponseLike): string;
 export declare function extractAnthropicToolCalls(response: AnthropicResponseLike): LlmToolCallPart[];
 export declare function mapAnthropicStopReason(reason: string | null): LlmStopReason;
-/**
- * Convert an SDK `LlmMessage` to the Anthropic Messages wire shape.
- * Identical across the three Anthropic-compatible clients (D289/D292).
- */
 export declare function toAnthropicWireMessage(message: LlmMessage): Record<string, unknown>;
 /**
  * Build the common body shape for Anthropic Messages requests. Caller
@@ -93,4 +89,8 @@ export declare function buildAnthropicCommonBody(request: LlmRequest): {
         description: string;
         input_schema: unknown;
     }>;
+    thinking?: {
+        type: "enabled";
+        budget_tokens: number;
+    };
 };

package/dist/internal/llm/types.d.ts

@@ -43,7 +43,24 @@ export interface LlmImagePart {
         url: string;
     };
 }
-export type LlmContentPart = LlmTextPart | LlmToolCallPart | LlmToolResultPart | LlmImagePart;
+/**
+ * theokit#122 — an extended-thinking block, carried WITH its provider-issued signature.
+ *
+ * The signature is the whole reason this part exists. Anthropic requires a resumed conversation to
+ * replay each `thinking` block byte-identically, signature included; replaying the text alone is
+ * rejected with `400 "thinking blocks cannot be modified"` (anthropics/claude-code#63147). So a
+ * session that used extended thinking could be persisted but never resumed.
+ *
+ * `signature` is optional because not every provider issues one — the OpenAI-compatible reasoning
+ * channel streams `reasoning`/`reasoning_content` text with no signature at all. A part without a
+ * signature is display-only history; it must not be replayed to Anthropic as a thinking block.
+ */
+export interface LlmThinkingPart {
+    type: "thinking";
+    text: string;
+    signature?: string;
+}
+export type LlmContentPart = LlmTextPart | LlmToolCallPart | LlmToolResultPart | LlmImagePart | LlmThinkingPart;
 export interface LlmMessage {
     role: "system" | "user" | "assistant";
     content: LlmContentPart[];
@@ -122,20 +139,36 @@ export interface LlmRequest {
      */
     toolChoice?: "auto" | "none" | "required";
 }
+/**
+ * What a provider stream reports WHILE it is running. Tool calls are deliberately absent.
+ *
+ * theokit#144: this union used to declare `tool_use` and `stop` variants. Only two providers ever
+ * yielded them (`responses.ts`, `fault-injection.ts`), the loop's collector
+ * (`loop-llm-stream.ts`) never read them, and the tool calls they carried were duplicates of what
+ * `LlmFinish.toolCalls` already returned. So they were not a live tool channel — they were a
+ * declaration of one, which is worse: it told implementers a provider-level channel existed and
+ * cost `@theokit/agents` a workaround (holding every `text_delta` until the stream drained, which
+ * broke live token streaming on text-only turns — issue #47).
+ *
+ * Wiring them instead of deleting them was rejected: `openai.ts` and `anthropic.ts` cannot produce
+ * them at all (their tool calls only resolve at completion), so a live provider-level channel would
+ * exist on some providers and not others — a worse contract than a uniform one.
+ *
+ * **The canonical live tool channel is `onDelta`**: `tool-call-started` / `tool-call-completed`
+ * `InteractionUpdate`s, emitted by `runToolWithLifecycle` (`agent-loop/tool-dispatch.ts`) between
+ * LLM rounds. It is uniform across providers, carries a `callId` correlating the two ends, and
+ * fires before the post-tool answer text. `Run.events()` (theokit#140) merges it with the
+ * structural `SDKMessage`s into one ordered timeline.
+ *
+ * The stop reason is not an event either — it is returned once, on `LlmFinish.stopReason`.
+ */
 export type LlmEvent = {
     type: "text_delta";
     text: string;
 } | {
     type: "reasoning_delta";
     text: string;
-} | {
-    type: "tool_use";
-    id: string;
-    name: string;
-    input: Record<string, unknown>;
-} | {
-    type: "stop";
-    reason: LlmStopReason;
+    signature?: string;
 } | {
     type: "error";
     message: string;
@@ -153,6 +186,13 @@ export interface LlmFinish {
     cacheWriteTokens?: number;
     /** Reasoning tokens (OpenAI o-series). ADR D376. */
     reasoningTokens?: number;
+    /**
+     * theokit#122 — the turn's extended-thinking block, with the provider's signature when it issued
+     * one. Returned on the finish value rather than reconstructed from the `reasoning_delta` text,
+     * because the signature arrives once for the whole block and only the provider adapter knows
+     * which block it belongs to.
+     */
+    thinking?: LlmThinkingPart;
 }
 export interface LlmClient {
     readonly name: string;

package/dist/internal/local-agent/mcp-pool.d.ts

@@ -3,9 +3,13 @@
  *
  * `buildMcpMap` (`real-local-run.ts`) builds a fresh `McpClient` on every run, so each `send` pays
  * spawn + handshake again: 193 / 138 / 134 ms per turn, measured. The reference anchors this at the
- * session — Codex keeps its `McpConnectionManager` in `SessionServices`
- * (`core/src/state/service.rs:116`), next to a field commented *"Session-scoped model client shared
- * across turns"*, and REPLACES the runtime rather than rebuilding it.
+ * session — Codex keeps its `mcp_runtime: Arc<McpRuntime>` in `SessionServices`
+ * (`codex-rs/core/src/state/service.rs:51-58`), next to a field commented *"Session-scoped model
+ * client shared across turns"*, and REPLACES the runtime rather than rebuilding it.
+ *
+ * theokit#155: pooling the client OBJECT was never enough — the turn also has to stop closing what
+ * it does not own. See `runOwnsMcpClients` (`real-local-run.ts`) and the idempotent
+ * `StdioMcpClient.initialize()`.
  *
  * Generic over the client type on purpose: this file knows about keys, reuse and idleness, and
  * nothing about MCP. That keeps it unit-testable without spawning a server, and keeps `McpClient`'s

package/dist/internal/memory/adapters/azure-openai-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const azureOpenAiMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/catalog.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/internal/memory/adapters/cohere-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const cohereMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/deepinfra-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const deepinfraMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/gemini-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const geminiMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/index.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var chunk7U2HAAWB_cjs = require('../../../chunk-7U2HAAWB.cjs');
+require('../../../chunk-6YNYA7GD.cjs');
+var chunk2RW7K6FN_cjs = require('../../../chunk-2RW7K6FN.cjs');
+require('../../../chunk-MUUQ2WFJ.cjs');
+require('../../../chunk-7OLG7VI4.cjs');
+require('../../../chunk-TIMPJL5V.cjs');
+require('../../../chunk-7YBJZS5P.cjs');
+require('../../../chunk-IHFNRNTJ.cjs');
+require('../../../chunk-BCQ3E2ZG.cjs');
+
+
+
+Object.defineProperty(exports, "createOpenAiCompatibleRuntime", {
+  enumerable: true,
+  get: function () { return chunk7U2HAAWB_cjs.createOpenAiCompatibleRuntime; }
+});
+Object.defineProperty(exports, "LruEmbeddingCache", {
+  enumerable: true,
+  get: function () { return chunk2RW7K6FN_cjs.LruEmbeddingCache; }
+});
+Object.defineProperty(exports, "globalEmbeddingCache", {
+  enumerable: true,
+  get: function () { return chunk2RW7K6FN_cjs.globalEmbeddingCache; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/internal/memory/adapters/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/internal/memory/adapters/index.d.cts

@@ -0,0 +1,16 @@
+/**
+ * theokit#160 — the ONE embedding runtime, shared with `@theokit/sdk-memory`.
+ *
+ * The satellite used to carry a full copy of `createOpenAiCompatibleRuntime`, and the peer's catalog
+ * REPLACES core's at runtime when installed — so the copy that ran was not the copy most people
+ * read. That duplication produced theokit#128 (four adapters present in one copy, missing from the
+ * other, for two months), and every fix since had to be applied twice by hand: the `{model}` path
+ * substitution, then all three provider dialects.
+ *
+ * This is the shared leaf both packages now import. Semver-exempt, exactly like the
+ * `internal/persistence` and `internal/security` sub-paths that exist for the same reason: extracted
+ * packages need primitives that are not part of the stable public contract.
+ *
+ * @internal — semver-exempt. Not part of the stable `@theokit/sdk` API.
+ */
+export { createOpenAiCompatibleRuntime, type EmbeddingDialect, type OpenAiCompatibleConfig, } from "./openai-compatible.js";

package/dist/internal/memory/adapters/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * theokit#160 — the ONE embedding runtime, shared with `@theokit/sdk-memory`.
+ *
+ * The satellite used to carry a full copy of `createOpenAiCompatibleRuntime`, and the peer's catalog
+ * REPLACES core's at runtime when installed — so the copy that ran was not the copy most people
+ * read. That duplication produced theokit#128 (four adapters present in one copy, missing from the
+ * other, for two months), and every fix since had to be applied twice by hand: the `{model}` path
+ * substitution, then all three provider dialects.
+ *
+ * This is the shared leaf both packages now import. Semver-exempt, exactly like the
+ * `internal/persistence` and `internal/security` sub-paths that exist for the same reason: extracted
+ * packages need primitives that are not part of the stable public contract.
+ *
+ * @internal — semver-exempt. Not part of the stable `@theokit/sdk` API.
+ */
+export { createOpenAiCompatibleRuntime, type EmbeddingDialect, type OpenAiCompatibleConfig, } from "./openai-compatible.js";

package/dist/internal/memory/adapters/index.js

@@ -0,0 +1,11 @@
+export { createOpenAiCompatibleRuntime } from '../../../chunk-QKE556YD.js';
+import '../../../chunk-SCFW5MJZ.js';
+export { LruEmbeddingCache, globalEmbeddingCache } from '../../../chunk-OXNYIMZZ.js';
+import '../../../chunk-FD2UT76F.js';
+import '../../../chunk-LGILIGV3.js';
+import '../../../chunk-PI4RO4GR.js';
+import '../../../chunk-J3UK2GMN.js';
+import '../../../chunk-SG5ZWT6C.js';
+import '../../../chunk-IVSD7L22.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/internal/memory/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/internal/memory/adapters/jina-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const jinaMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/mistral-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const mistralMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/ollama-embedding.d.cts

@@ -0,0 +1,34 @@
+/**
+ * Ollama embedding adapter (T3.1, ADR D183).
+ *
+ * Targets Ollama's OpenAI-compatible `/v1/embeddings` endpoint and reuses
+ * the shared `createOpenAiCompatibleRuntime` factory. The differentiating
+ * bits:
+ *
+ *  - `authType: "none"` — Ollama local ignores `Authorization`. Sentinel
+ *    `"ollama-local"` is passed as apiKey to satisfy the factory contract
+ *    (mirrors peer-project `OLLAMA_DEFAULT_API_KEY = "ollama-local"`).
+ *  - `OLLAMA_HOST` overrides the default `http://localhost:11434`.
+ *  - `OLLAMA_API_KEY` (optional) overrides the sentinel for Ollama Cloud
+ *    or reverse-proxy auth setups.
+ *  - Default model: `nomic-embed-text` (768 dim, ~274MB). User can opt
+ *    into `all-minilm` (384 dim, ~45MB) or any other locally-installed
+ *    embedding model.
+ *
+ * EC-B MUST FIX (edge-case review 2026-05-21): empty text is rejected
+ * upstream in the shared factory (`classifyEntry` short-circuits to a
+ * zero vector). That behavior is acceptable here because the zero
+ * vector is identical for any empty input — downstream similarity
+ * calcs ignore zero-norm vectors via the existing `cosineSimilarity`
+ * guard. No additional fail-fast needed.
+ *
+ * EC-A MUST FIX (edge-case review 2026-05-21): dimension is locked
+ * by the `DIMENSION_BY_MODEL` table; an unknown model id throws
+ * `ConfigurationError(code: "embedding_unknown_model")` per the
+ * factory's EC-4 contract. Future model versions with different
+ * dimensions are added to the table here without breaking changes.
+ *
+ * @internal
+ */
+export declare const DEFAULT_OLLAMA_EMBEDDING_MODEL = "nomic-embed-text";
+export declare const ollamaMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/openai-compatible.d.cts

@@ -0,0 +1,51 @@
+import type { CreateAdapterOptions, EmbeddingRuntime } from "../embedding-adapter.js";
+export interface OpenAiCompatibleConfig {
+    id: string;
+    defaultBaseUrl: string;
+    apiKeyEnv: string;
+    baseUrlEnv?: string;
+    defaultModel: string;
+    /**
+     * Dimension hint by model id. The chosen model MUST be in this table —
+     * unknown models throw `ConfigurationError(code: "embedding_unknown_model")`
+     * (EC-4 fix). This prevents vec0 virtual-table dimension mismatches that
+     * surface as cryptic errors downstream.
+     */
+    dimensionByModel: Record<string, number>;
+    /**
+     * Path component appended to `baseUrl` for the embeddings endpoint.
+     * Default `"/v1/embeddings"` (OpenAI canonical). REPLACES the default —
+     * does NOT concatenate. Used by DeepInfra (`"/v1/openai/embeddings"`),
+     * etc. (EC-2 fix).
+     */
+    embeddingsPath?: string;
+    /**
+     * theokit#159 — per-provider deviations from the OpenAI wire.
+     *
+     * The runtime was rigidly OpenAI-shaped: one auth header, one body, one response shape. Three of
+     * the ten catalog providers do not speak it, so every call they made was rejected — Azure
+     * authenticates with an `api-key` header and puts the deployment in the path, Cohere's `/v2/embed`
+     * takes `texts` and answers `{embeddings:{float}}`. Advertising a provider that cannot work is
+     * worse than not advertising it.
+     *
+     * Every hook is optional and its default is exactly the previous behaviour, so the seven
+     * providers that DO speak OpenAI are untouched.
+     */
+    dialect?: EmbeddingDialect;
+}
+/**
+ * theokit#159 — the three points where a provider may deviate from the OpenAI embedding wire.
+ *
+ * Deliberately three narrow hooks rather than a general "transform the request" seam: these are the
+ * only axes on which the supported providers actually differ, and a wider seam would invite
+ * per-provider logic that belongs in the adapter.
+ */
+export interface EmbeddingDialect {
+    /** Replaces `authorization: Bearer <key>`. */
+    authHeaders?: (apiKey: string) => Record<string, string>;
+    /** Replaces the `{ model, input }` request body. */
+    body?: (model: string, inputs: ReadonlyArray<string>) => Record<string, unknown>;
+    /** Replaces reading vectors from `json.data[].embedding`. Return `undefined` when unparseable. */
+    vectors?: (json: unknown) => number[][] | undefined;
+}
+export declare function createOpenAiCompatibleRuntime(cfg: OpenAiCompatibleConfig, options: CreateAdapterOptions): Promise<EmbeddingRuntime>;

package/dist/internal/memory/adapters/openai-compatible.d.ts

@@ -19,5 +19,33 @@ export interface OpenAiCompatibleConfig {
      * etc. (EC-2 fix).
      */
     embeddingsPath?: string;
+    /**
+     * theokit#159 — per-provider deviations from the OpenAI wire.
+     *
+     * The runtime was rigidly OpenAI-shaped: one auth header, one body, one response shape. Three of
+     * the ten catalog providers do not speak it, so every call they made was rejected — Azure
+     * authenticates with an `api-key` header and puts the deployment in the path, Cohere's `/v2/embed`
+     * takes `texts` and answers `{embeddings:{float}}`. Advertising a provider that cannot work is
+     * worse than not advertising it.
+     *
+     * Every hook is optional and its default is exactly the previous behaviour, so the seven
+     * providers that DO speak OpenAI are untouched.
+     */
+    dialect?: EmbeddingDialect;
+}
+/**
+ * theokit#159 — the three points where a provider may deviate from the OpenAI embedding wire.
+ *
+ * Deliberately three narrow hooks rather than a general "transform the request" seam: these are the
+ * only axes on which the supported providers actually differ, and a wider seam would invite
+ * per-provider logic that belongs in the adapter.
+ */
+export interface EmbeddingDialect {
+    /** Replaces `authorization: Bearer <key>`. */
+    authHeaders?: (apiKey: string) => Record<string, string>;
+    /** Replaces the `{ model, input }` request body. */
+    body?: (model: string, inputs: ReadonlyArray<string>) => Record<string, unknown>;
+    /** Replaces reading vectors from `json.data[].embedding`. Return `undefined` when unparseable. */
+    vectors?: (json: unknown) => number[][] | undefined;
 }
 export declare function createOpenAiCompatibleRuntime(cfg: OpenAiCompatibleConfig, options: CreateAdapterOptions): Promise<EmbeddingRuntime>;

package/dist/internal/memory/adapters/openai-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const openAiMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/openrouter-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const openRouterMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/adapters/voyage-embedding.d.cts

@@ -0,0 +1,2 @@
+import type { MemoryEmbeddingProviderAdapter } from "../embedding-adapter.js";
+export declare const voyageMemoryEmbeddingProviderAdapter: MemoryEmbeddingProviderAdapter;

package/dist/internal/memory/dreaming/diary.d.ts

@@ -0,0 +1,4 @@
+export declare function diaryPath(cwd: string): string;
+export declare function renderDiaryEntry(entry: DiaryEntry): string;
+export declare function appendDiaryEntry(cwd: string, entry: DiaryEntry): Promise<void>;
+export declare function entryHash(entry: DiaryEntry): string;

package/dist/internal/memory/dreaming/phases.d.ts

@@ -0,0 +1,15 @@
+import type { EmbeddingRuntime } from "../embedding-adapter.js";
+import type { MemoryFact } from "../types.js";
+export interface Cluster {
+    representativeText: string;
+    members: ReadonlyArray<MemoryFact>;
+}
+export interface ClusterResult {
+    clusters: Cluster[];
+}
+/** Light phase — drop facts whose embedding is too similar to one already kept. */
+export declare function lightPhase(facts: ReadonlyArray<MemoryFact>, embedding: EmbeddingRuntime, threshold?: number): Promise<DedupResult>;
+/** REM phase — single-link agglomerative clustering by cosine similarity. */
+export declare function remPhase(facts: ReadonlyArray<MemoryFact>, embedding: EmbeddingRuntime, threshold?: number, maxFactsPerSweep?: number): Promise<ClusterResult>;
+/** Deep phase — render consolidated markdown for the dreamed note. */
+export declare function deepPhase(clusters: ReadonlyArray<Cluster>, timestampMs: number): string;

package/dist/internal/memory/dreaming/run.d.ts

@@ -0,0 +1,10 @@
+export interface DreamingResult {
+    status: "ok" | "skipped" | "error";
+    factsBefore: number;
+    factsAfter: number;
+    duplicatesRemoved: number;
+    clustersCreated: number;
+    notesWritten: number;
+    diaryEntryHash: string | undefined;
+}
+export declare function runDreamingSweep(options: DreamingOptions): Promise<DreamingResult>;

package/dist/internal/memory/migrate-sqlite-to-lance.d.ts

@@ -0,0 +1,15 @@
+export interface MigrateResult {
+    countSqlite: number;
+    countLance: number;
+    /** Set when validation succeeded (or dryRun); false on validation failure. */
+    validated: boolean;
+    /** Per-fact compare results (size = sample count, up to 10). */
+    sampleComparisons: ReadonlyArray<{
+        id: string;
+        match: boolean;
+    }>;
+    /** Lance storage location (final, after migration). */
+    lancePath: string;
+    /** Was the migration committed (false for dry-run). */
+    committed: boolean;
+}

package/dist/internal/memory/sdk-memory-peer-loader.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SDK 2.0 Phase 4 (Stage 4) — Optional peer loader for
+ * `@theokit/sdk-memory`.
+ *
+ * The Memory class public API in `src/memory.ts` keeps its surface
+ * stable but routes through sdk-memory when installed. When sdk-memory
+ * is NOT installed, methods fall back to sdk-core's legacy
+ * `internal/memory/*` implementations — preserving v1.x back-compat.
+ *
+ * Pattern mirrors sdk-handoff's optional-peer dynamic import: try
+ * `await import("@theokit/sdk-memory")` once, cache the result (the
+ * module OR `null` for "definitively missing"), and let the caller
+ * route.
+ *
+ * Iter 76 (Stage 4 #1): foundation helper for the Memory class
+ * delegation refactor. No behavior changes yet — this iter only
+ * adds the loader; iter 77+ wires Memory class methods to use it.
+ *
+ * @internal
+ */
+export {};