stitchkit 0.110.3 → 0.110.4

package/dist/{index-j1cwtyk1.js → index-mpg1t7nv.js}

@@ -35,8 +35,11 @@ import {
   canonicalAgentJson2,
   encodeAgentConversationArchive2,
   decodeAgentConversationArchive2,
-  assistantStatus
-} from "./index-4fgg1507.js";
+  assistantStatus,
+  ProviderJournalMessageSchema,
+  ProviderJournalRequestSchema,
+  ProviderJournalResponseSchema
+} from "./index-jna0ejsa.js";
 import {
   StepEventPayloadSchema,
   ParkEventPayloadSchema,
@@ -170,7 +173,7 @@ function emptyHead(conversationId) {
 }
 
 // src/agent-runtime/store-create.ts
-import { z as z16 } from "zod";
+import { z as z15 } from "zod";
 
 // src/agent-runtime/store-archive.ts
 import { z as z5 } from "zod";
@@ -992,10 +995,10 @@ async function exportConversationIn(driver, transaction, conversationId) {
 
 // src/agent-runtime/store-branch.ts
 import { createHash as createHash7 } from "node:crypto";
-import { z as z14 } from "zod";
+import { z as z13 } from "zod";
 
 // src/agent-runtime/branch-events.ts
-import { z as z10 } from "zod";
+import { z as z9 } from "zod";
 
 // src/agent-runtime/branch-messages.ts
 import { z as z6 } from "zod";
@@ -1068,7 +1071,7 @@ function branchPart(ids, part) {
       return { ...part, reference: ids.reference("spill", part.reference) };
     case "tool-call": {
       if (part.provider)
-        throw new TypeError("Branch cannot rekey opaque tool provider metadata");
+        branchOpaqueJson(part.provider.data);
       return {
         ...part,
         callId: ids.reference("call", part.callId),
@@ -1095,7 +1098,7 @@ function branchPart(ids, part) {
       throw new TypeError("Branch cannot rekey an opaque provider part");
     case "reasoning":
       if (part.provider)
-        throw new TypeError("Branch cannot rekey opaque reasoning provider metadata");
+        branchOpaqueJson(part.provider.data);
       return part;
     default:
       return part;
@@ -1261,92 +1264,17 @@ var BranchObservationSchema = z7.object({ sourceKind: Id, payload: z7.json() }).
 
 // src/agent-runtime/branch-provider.ts
 import { createHash as createHash3 } from "node:crypto";
-import { z as z8 } from "zod";
-var Hash3 = z8.string().regex(/^[a-f0-9]{64}$/);
-var Text = z8.object({ type: z8.enum(["text", "reasoning"]), text: z8.string() }).strict();
-var Call = z8.object({
-  type: z8.literal("tool-call"),
-  toolCallId: z8.string(),
-  toolName: z8.string(),
-  input: z8.json()
-}).strict();
-var Result = z8.object({
-  type: z8.literal("tool-result"),
-  toolCallId: z8.string(),
-  toolName: z8.string(),
-  output: z8.discriminatedUnion("type", [
-    z8.object({ type: z8.enum(["text", "error-text"]), value: z8.string() }).strict(),
-    z8.object({ type: z8.enum(["json", "error-json"]), value: z8.json() }).strict()
-  ])
-}).strict();
-var Message = z8.object({
-  role: z8.enum(["user", "assistant", "tool"]),
-  content: z8.union([
-    z8.string(),
-    z8.array(z8.union([
-      Text,
-      Call,
-      Result,
-      z8.object({
-        type: z8.literal("tool-approval-request"),
-        approvalId: z8.string(),
-        toolCallId: z8.string(),
-        signature: z8.string().optional(),
-        isAutomatic: z8.boolean().optional()
-      }).strict(),
-      z8.object({
-        type: z8.literal("tool-approval-response"),
-        approvalId: z8.string(),
-        approved: z8.boolean(),
-        reason: z8.string().optional()
-      }).strict(),
-      z8.object({
-        type: z8.literal("file"),
-        data: z8.union([
-          z8.string(),
-          z8.object({
-            binary: z8.literal(true),
-            sha256: Hash3,
-            bytes: z8.int().nonnegative()
-          }).strict()
-        ]),
-        mediaType: z8.string(),
-        filename: z8.string().optional()
-      }).strict(),
-      z8.object({
-        type: z8.literal("image"),
-        image: z8.union([
-          z8.string(),
-          z8.object({
-            binary: z8.literal(true),
-            sha256: Hash3,
-            bytes: z8.int().nonnegative()
-          }).strict()
-        ]),
-        mediaType: z8.string().optional()
-      }).strict()
-    ]))
-  ])
-}).strict();
-var ProviderMessage = z8.object({ sha256: Hash3, message: Message }).strict();
-var ProviderRequest = z8.object({
-  runId: z8.string(),
-  attempt: z8.int().nonnegative(),
-  stepNumber: z8.int().nonnegative(),
-  modelId: z8.string(),
-  instructionsSha256: Hash3,
-  messageShas: z8.array(Hash3),
-  bodySha256: Hash3
-}).strict();
-var ProviderResponse = z8.object({
-  runId: z8.string(),
-  attempt: z8.int().nonnegative(),
-  stepNumber: z8.int().nonnegative(),
-  response: z8.object({ id: z8.string(), provider: z8.string().optional() }).strict()
-}).strict();
 function hash(value) {
   return createHash3("sha256").update(canonicalAgentJson2(value)).digest("hex");
 }
+function checkFileData(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return;
+  if (value.type === "reference" && "reference" in value)
+    branchOpaqueJson(value.reference);
+  else if (!("type" in value) && value.binary !== true)
+    branchOpaqueJson(value);
+}
 
 class BranchProvider {
   ids;
@@ -1356,12 +1284,20 @@ class BranchProvider {
   }
   rekey(kind, raw) {
     if (kind === "provider/message") {
-      const value = ProviderMessage.parse(raw);
+      const value = ProviderJournalMessageSchema.parse(raw);
       if (hash(value.message) !== value.sha256)
         throw new TypeError("Branch provider message digest is inconsistent");
+      if (value.message.providerOptions)
+        branchOpaqueJson(value.message.providerOptions);
       const message = {
         ...value.message,
         content: typeof value.message.content === "string" ? value.message.content : value.message.content.map((part) => {
+          if ("providerOptions" in part && part.providerOptions)
+            branchOpaqueJson(part.providerOptions);
+          if (part.type === "file" || part.type === "reasoning-file")
+            checkFileData(part.data);
+          if (part.type === "image")
+            checkFileData(part.image);
           if (part.type === "tool-call")
             return {
               ...part,
@@ -1369,8 +1305,21 @@ class BranchProvider {
               input: branchToolJson(this.ids, part.toolName, part.input, false)
             };
           if (part.type === "tool-result") {
+            if ("providerOptions" in part.output && part.output.providerOptions)
+              branchOpaqueJson(part.output.providerOptions);
             if (part.output.type === "error-json")
               branchOpaqueJson(part.output.value);
+            if (part.output.type === "content")
+              for (const item of part.output.value) {
+                if (item.providerOptions)
+                  branchOpaqueJson(item.providerOptions);
+                if (item.type === "file")
+                  checkFileData(item.data);
+                if ("providerReference" in item)
+                  branchOpaqueJson(item.providerReference);
+                if ("fileId" in item && typeof item.fileId !== "string")
+                  branchOpaqueJson(item.fileId);
+              }
             return {
               ...part,
               toolCallId: this.ids.reference("call", part.toolCallId),
@@ -1384,7 +1333,8 @@ class BranchProvider {
             return {
               type: part.type,
               approvalId: this.ids.reference("approval", part.approvalId),
-              toolCallId: this.ids.reference("call", part.toolCallId)
+              toolCallId: this.ids.reference("call", part.toolCallId),
+              ...part.reason !== undefined && { reason: part.reason }
             };
           if (part.type === "tool-approval-response")
             return {
@@ -1399,7 +1349,7 @@ class BranchProvider {
       return { sha256, message };
     }
     if (kind === "provider/request") {
-      const value = ProviderRequest.parse(raw);
+      const value = ProviderJournalRequestSchema.parse(raw);
       const sourceHash = createHash3("sha256").update(value.instructionsSha256).update(value.messageShas.join(",")).digest("hex");
       if (sourceHash !== value.bodySha256)
         throw new TypeError("Branch provider request digest is inconsistent");
@@ -1416,13 +1366,13 @@ class BranchProvider {
         bodySha256: createHash3("sha256").update(value.instructionsSha256).update(messageShas.join(",")).digest("hex")
       };
     }
-    const value = ProviderResponse.parse(raw);
+    const value = ProviderJournalResponseSchema.parse(raw);
     return { ...value, runId: this.ids.reference("run", value.runId) };
   }
 }
 
 // src/agent-runtime/branch-transitions.ts
-import { z as z9 } from "zod";
+import { z as z8 } from "zod";
 function rekeyBranchTransition(ids, source, operation) {
   const message = (value) => branchMessage(ids, source, value);
   const input = operation.input;
@@ -1493,11 +1443,11 @@ function rekeyBranchTransition(ids, source, operation) {
   }
 }
 function branchJson(value) {
-  return z9.json().parse(value);
+  return z8.json().parse(value);
 }
 
 // src/agent-runtime/branch-events.ts
-var Hash4 = z10.string().regex(/^[a-f0-9]{64}$/);
+var Hash3 = z9.string().regex(/^[a-f0-9]{64}$/);
 function rekeyBranchEvents(ids, source, events, retainedMessages = new Map) {
   const hydrated = events.map((event) => {
     const assistant = retainedMessages.get(event.eventId);
@@ -1544,14 +1494,14 @@ function rekeyBranchEvent(ids, source, event, provider) {
   if (event.kind === "runtime/transition") {
     const operation = branchTransition(event);
     const rekeyed = rekeyBranchTransition(ids, source, operation);
-    const raw = z10.object({
-      type: z10.string(),
-      input: z10.object({
-        assistant: z10.object({
-          sha256: Hash4.optional(),
-          sourceSha256: Hash4.optional(),
-          bytes: z10.int(),
-          parts: z10.int()
+    const raw = z9.object({
+      type: z9.string(),
+      input: z9.object({
+        assistant: z9.object({
+          sha256: Hash3.optional(),
+          sourceSha256: Hash3.optional(),
+          bytes: z9.int(),
+          parts: z9.int()
         }).passthrough()
       }).passthrough()
     }).passthrough().safeParse(event.payload);
@@ -1709,32 +1659,32 @@ class BranchIdentities {
 
 // src/agent-runtime/branch-source.ts
 import { createHash as createHash6 } from "node:crypto";
-import { z as z13 } from "zod";
+import { z as z12 } from "zod";
 
 // src/agent-runtime/archive-projection.ts
-import { z as z11 } from "zod";
-var ArchiveProjectionSchema = z11.object({
-  name: z11.string(),
-  version: z11.int().positive(),
-  uptoSeq: z11.int().nonnegative(),
-  value: z11.json(),
-  updatedAt: z11.string()
+import { z as z10 } from "zod";
+var ArchiveProjectionSchema = z10.object({
+  name: z10.string(),
+  version: z10.int().positive(),
+  uptoSeq: z10.int().nonnegative(),
+  value: z10.json(),
+  updatedAt: z10.string()
 }).strict();
 
 // src/agent-runtime/archive-spill.ts
 import { createHash as createHash5 } from "node:crypto";
-import { z as z12 } from "zod";
-var ArchiveSpillSchema = z12.object({
-  reference: z12.string().min(1),
-  runId: z12.string().min(1).optional(),
-  toolCallId: z12.string().min(1).optional(),
-  mediaType: z12.string().min(1),
-  bytes: z12.int().nonnegative(),
-  sha256: z12.string().regex(/^[a-f0-9]{64}$/),
-  createdAt: z12.iso.datetime({ offset: true }),
-  expiresAt: z12.iso.datetime({ offset: true }).optional(),
+import { z as z11 } from "zod";
+var ArchiveSpillSchema = z11.object({
+  reference: z11.string().min(1),
+  runId: z11.string().min(1).optional(),
+  toolCallId: z11.string().min(1).optional(),
+  mediaType: z11.string().min(1),
+  bytes: z11.int().nonnegative(),
+  sha256: z11.string().regex(/^[a-f0-9]{64}$/),
+  createdAt: z11.iso.datetime({ offset: true }),
+  expiresAt: z11.iso.datetime({ offset: true }).optional(),
   authorization: AgentCodingToolAuthorizationSchema2.optional(),
-  base64: z12.string()
+  base64: z11.string()
 }).strict().superRefine((spill, ctx) => {
   const bytes = Buffer.from(spill.base64, "base64");
   if (bytes.toString("base64") !== spill.base64 || bytes.byteLength !== spill.bytes || createHash5("sha256").update(bytes).digest("hex") !== spill.sha256) {
@@ -1746,7 +1696,7 @@ var ArchiveSpillSchema = z12.object({
 });
 
 // src/agent-runtime/branch-source.ts
-var SnapshotProjection = z13.object({ archiveType: z13.literal("runtime-snapshot"), snapshot: AgentSnapshotSchema2 }).strict();
+var SnapshotProjection = z12.object({ archiveType: z12.literal("runtime-snapshot"), snapshot: AgentSnapshotSchema2 }).strict();
 function branchHash(value) {
   return createHash6("sha256").update(canonicalAgentJson2(value)).digest("hex");
 }
@@ -1763,13 +1713,13 @@ function boundary(events, throughRunId) {
   for (const event of events) {
     if (event.kind !== "runtime/transition")
       continue;
-    const candidate = z13.object({
-      type: z13.string(),
-      input: z13.object({
-        runId: z13.string().optional(),
-        reason: z13.string().optional(),
-        action: z13.string().optional(),
-        absorb: z13.array(z13.object({ runId: z13.string() })).optional()
+    const candidate = z12.object({
+      type: z12.string(),
+      input: z12.object({
+        runId: z12.string().optional(),
+        reason: z12.string().optional(),
+        action: z12.string().optional(),
+        absorb: z12.array(z12.object({ runId: z12.string() })).optional()
       })
     }).safeParse(event.payload);
     if (!candidate.success)
@@ -1788,7 +1738,7 @@ function prepareBranchSource(bytes, source) {
     if (event.seq !== index + 1)
       throw new TypeError("Branch source event sequence is incomplete");
   }
-  const projections = archive.projections.map((value) => z13.union([SnapshotProjection, ArchiveProjectionSchema]).parse(value));
+  const projections = archive.projections.map((value) => z12.union([SnapshotProjection, ArchiveProjectionSchema]).parse(value));
   if (projections.some((value, index) => canonicalAgentJson2(value) !== canonicalAgentJson2(archive.projections[index])))
     throw new TypeError("Branch archive snapshot contains an unknown opaque field");
   const snapshots = projections.filter((value) => ("archiveType" in value));
@@ -1958,12 +1908,12 @@ async function branchConversation(driver, raw) {
       conversationId: input.destinationConversationId,
       events: [],
       projections: [],
-      spills: z14.array(z14.json()).parse(spills)
+      spills: z13.array(z13.json()).parse(spills)
     });
     await driver.events.append(tx, agentStoreEventDraft({
       conversationId: input.destinationConversationId,
       kind: "runtime/branched",
-      payload: z14.json().parse(receipt)
+      payload: z13.json().parse(receipt)
     }));
     return { outcome: "created", receipt };
   });
@@ -2016,7 +1966,7 @@ function findEventOnce(driver, input) {
 }
 
 // src/agent-runtime/store-mutate.ts
-import { z as z15 } from "zod";
+import { z as z14 } from "zod";
 function validateAdmissionReceipt(receipt, record, conversationId) {
   const input = receipt.input;
   const run = record.run;
@@ -2163,7 +2113,7 @@ async function persistApplied(driver, transaction, read, operation, reduced) {
   await driver.events.append(transaction, agentStoreEventDraft({
     conversationId,
     kind: "runtime/transition",
-    payload: z15.json().parse(transitionRecord(operation, reduced))
+    payload: z14.json().parse(transitionRecord(operation, reduced))
   }));
   return { outcome: "applied", snapshot: reduced.snapshot };
 }
@@ -2212,9 +2162,9 @@ function createStoreConversationPurge(driver, conversations) {
 }
 
 // src/agent-runtime/store-create.ts
-var AgentRecoverableScanInputSchema = z16.object({
-  cursor: z16.string().min(1).optional(),
-  limit: z16.number().int().min(1).max(1000)
+var AgentRecoverableScanInputSchema = z15.object({
+  cursor: z15.string().min(1).optional(),
+  limit: z15.number().int().min(1).max(1000)
 });
 function createAgentRuntimeStore2(driver) {
   const mutate = (operation) => mutateStore(driver, operation);

package/llms/agent-runtime.txt

@@ -612,6 +612,12 @@ spill. Compacted content stays in the event history and SQLite inactive rows; th
 same active summaries. A hash-only checkpoint is historical digest evidence, marked
 `sourceSha256`; a later full terminal record must settle its content.
 
+Recorded provider options and canonical reasoning/tool-call provider metadata are retained.
+Provider message hashes and request references remain consistent after rekey. Metadata is
+data, subject to the opaque JSON reference guard: an undocumented runtime reference key
+refuses instead of carrying a source identity into the destination. Unknown message fields
+and malformed request/message digests also refuse before any destination writes.
+
 A branch grants no source authority. Terminal run owners/fences and approval signatures are
 removed. State, schedules, children, retries, sandbox, approval rejection and durability facts are
 retained as inert `runtime/branch-observation` records; they cannot repopulate operational state

package/llms-full.txt

@@ -5810,6 +5810,12 @@ spill. Compacted content stays in the event history and SQLite inactive rows; th
 same active summaries. A hash-only checkpoint is historical digest evidence, marked
 `sourceSha256`; a later full terminal record must settle its content.
 
+Recorded provider options and canonical reasoning/tool-call provider metadata are retained.
+Provider message hashes and request references remain consistent after rekey. Metadata is
+data, subject to the opaque JSON reference guard: an undocumented runtime reference key
+refuses instead of carrying a source identity into the destination. Unknown message fields
+and malformed request/message digests also refuse before any destination writes.
+
 A branch grants no source authority. Terminal run owners/fences and approval signatures are
 removed. State, schedules, children, retries, sandbox, approval rejection and durability facts are
 retained as inert `runtime/branch-observation` records; they cannot repopulate operational state

package/llms.txt

@@ -25,7 +25,7 @@ Load the slice for each entrypoint your code imports — `import … from 'stitc
 - **stitchkit/primitives**: [llms/primitives.txt](llms/primitives.txt) 11.7 KB
 - **stitchkit/server**: [llms/server.txt](llms/server.txt) 45.3 KB → [llms/server.2.txt](llms/server.2.txt) 14.6 KB → [llms/server.3.txt](llms/server.3.txt) 45.6 KB → [llms/server.4.txt](llms/server.4.txt) 38.3 KB → [llms/server.5.txt](llms/server.5.txt) 22.1 KB
 - **stitchkit/observability**: [llms/observability.txt](llms/observability.txt) 45.9 KB
-- **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 42.2 KB → [llms/agent-runtime.2.txt](llms/agent-runtime.2.txt) 46.7 KB → [llms/agent-runtime.3.txt](llms/agent-runtime.3.txt) 35.6 KB
+- **stitchkit/agent-runtime**: [llms/agent-runtime.txt](llms/agent-runtime.txt) 42.7 KB → [llms/agent-runtime.2.txt](llms/agent-runtime.2.txt) 46.7 KB → [llms/agent-runtime.3.txt](llms/agent-runtime.3.txt) 35.6 KB
 - **stitchkit/agent-runtime/testing**: [llms/agent-runtime-testing.txt](llms/agent-runtime-testing.txt) 2.6 KB
 - **stitchkit/agent-runtime/harness**: [llms/agent-runtime-harness.txt](llms/agent-runtime-harness.txt) 11.0 KB
 - **stitchkit/agent-runtime/coding-tools**: [llms/agent-runtime-coding-tools.txt](llms/agent-runtime-coding-tools.txt) 5.0 KB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stitchkit",
-  "version": "0.110.3",
+  "version": "0.110.4",
   "description": "Contract-first backend framework — one defineContract() into an HTTP API, MCP tools, AI-agent tools and a typed client. Bun and Node.",
   "keywords": [
     "bun",