stitchkit 0.78.0 → 0.80.0

package/dist/{index-4ntp63ps.js → index-9s6z8vgf.js}

@@ -7,36 +7,33 @@ import {
   isCompleteAgentHistoryTurn
 } from "./index-y2s6h5bf.js";
 import {
-  isAgentToolError
-} from "./index-3xnq72rz.js";
+  createBoundedSinkManager
+} from "./index-a59da114.js";
 import {
-  ToolExecutionControlError,
-  isToolExecutionControlError
-} from "./index-qaajjfp6.js";
+  AgentRuntimeEventSchema,
+  agentDurableEventId
+} from "./index-85vfqd7m.js";
 import {
   AgentAssistantPlaceholderSchema,
   AgentJsonObjectSchema,
   AgentMessagePartSchema,
   AgentMessageSchema,
   AgentProvenanceSchema,
-  AgentProviderEnvelopeSchema,
-  AgentRecordIdSchema,
-  AgentRecordVersionSchema,
-  AgentRunMetricsSchema,
   AgentRunSchema,
-  AgentRunStateSchema,
   AgentSnapshotSchema,
-  AgentTerminalReasonSchema,
-  AgentTimestampSchema,
   runStateForTerminalReason
 } from "./index-x1th9s8c.js";
 import {
-  createBoundedSinkManager
-} from "./index-a59da114.js";
+  isAgentToolError
+} from "./index-3xnq72rz.js";
+import {
+  ToolExecutionControlError,
+  isToolExecutionControlError
+} from "./index-758zx2ha.js";
 import {
   isRecord,
   transportResult
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/agent-runtime/context-refusal.ts
 class AgentContextOverflowError extends Error {
@@ -189,127 +186,6 @@ function createAgentSessionCoordinator() {
   };
 }
 
-// src/agent-runtime/event-schema.ts
-import { z } from "zod";
-var AgentAdmissionEventSchema = z.object({
-  type: z.literal("admission"),
-  eventId: AgentRecordIdSchema,
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  input: AgentMessageSchema,
-  run: AgentRunSchema,
-  assistant: z.union([AgentAssistantPlaceholderSchema, AgentMessageSchema]),
-  emittedAt: AgentTimestampSchema
-});
-var EventIdentitySchema = z.object({
-  conversationId: AgentRecordIdSchema,
-  runId: AgentRecordIdSchema,
-  emittedAt: AgentTimestampSchema
-});
-var AgentTransientDeltaEventSchema = EventIdentitySchema.extend({
-  type: z.literal("assistant-delta"),
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  textDelta: z.string()
-});
-var AgentTransientReasoningIdentitySchema = EventIdentitySchema.extend({
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  provider: AgentProviderEnvelopeSchema.optional()
-});
-var AgentReasoningStartEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-start")
-});
-var AgentReasoningDeltaEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-delta"),
-  textDelta: z.string()
-});
-var AgentReasoningEndEventSchema = AgentTransientReasoningIdentitySchema.extend({
-  type: z.literal("reasoning-end")
-});
-var AgentCheckpointEventSchema = EventIdentitySchema.extend({
-  type: z.literal("assistant-checkpoint"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRunStateEventSchema = EventIdentitySchema.extend({
-  type: z.literal("run-state"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  state: AgentRunStateSchema
-});
-var AgentToolStatusEventSchema = EventIdentitySchema.extend({
-  type: z.literal("tool-status"),
-  runtimeEpoch: z.string().min(1),
-  sequence: z.int().nonnegative(),
-  callId: AgentRecordIdSchema,
-  toolName: z.string().min(1),
-  status: z.enum(["started", "completed", "failed", "interrupted"]),
-  input: z.json().optional(),
-  output: z.json().optional()
-});
-var AgentTerminalEventSchema = EventIdentitySchema.extend({
-  type: z.literal("terminal"),
-  eventId: AgentRecordIdSchema,
-  snapshotVersion: AgentRecordVersionSchema,
-  reason: AgentTerminalReasonSchema,
-  policyName: z.string().min(1).optional(),
-  message: AgentMessageSchema,
-  metrics: AgentRunMetricsSchema.optional()
-});
-var AgentRuntimeEventSchema = z.discriminatedUnion("type", [
-  AgentAdmissionEventSchema,
-  AgentTransientDeltaEventSchema,
-  AgentReasoningStartEventSchema,
-  AgentReasoningDeltaEventSchema,
-  AgentReasoningEndEventSchema,
-  AgentCheckpointEventSchema,
-  AgentRunStateEventSchema,
-  AgentToolStatusEventSchema,
-  AgentTerminalEventSchema
-]);
-var AgentRuntimeEventCursorSchema = z.object({
-  snapshotVersion: AgentRecordVersionSchema.optional(),
-  durableEventIds: z.array(AgentRecordIdSchema).optional(),
-  runtimeEpoch: z.string().min(1).optional(),
-  sequence: z.int().nonnegative().optional()
-});
-function isDurableEvent(event) {
-  return event.type === "admission" || event.type === "assistant-checkpoint" || event.type === "run-state" || event.type === "terminal";
-}
-function advanceAgentRuntimeEventCursor(rawCursor, event) {
-  const cursor = AgentRuntimeEventCursorSchema.parse(rawCursor);
-  if (isDurableEvent(event)) {
-    const previous = cursor.snapshotVersion;
-    const durableEventIds = previous === event.snapshotVersion ? cursor.durableEventIds ?? [] : [];
-    if (previous !== undefined && event.snapshotVersion < previous || durableEventIds.includes(event.eventId)) {
-      return { status: "duplicate", cursor };
-    }
-    return {
-      status: "accepted",
-      cursor: {
-        ...cursor,
-        snapshotVersion: event.snapshotVersion,
-        durableEventIds: [...durableEventIds, event.eventId]
-      }
-    };
-  }
-  const previousSequence = cursor.runtimeEpoch === event.runtimeEpoch ? cursor.sequence : undefined;
-  if (previousSequence !== undefined && event.sequence <= previousSequence) {
-    return { status: "duplicate", cursor };
-  }
-  return {
-    status: previousSequence !== undefined && event.sequence > previousSequence + 1 ? "gap" : "accepted",
-    cursor: { ...cursor, runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
-  };
-}
-function agentDurableEventId(type, runId, snapshotVersion) {
-  return `${runId}:${type}:${snapshotVersion}`;
-}
-
 // src/agent-runtime/events.ts
 function createAgentRuntimeEventSink(config) {
   const manager = createBoundedSinkManager({
@@ -625,9 +501,9 @@ function createAgentToolFenceLifecycle(config) {
 }
 
 // src/agent-runtime/prompt.ts
-import { z as z2 } from "zod";
-var AgentTokenCountSchema = z2.object({
-  value: z2.int().nonnegative().optional(),
+import { z } from "zod";
+var AgentTokenCountSchema = z.object({
+  value: z.int().nonnegative().optional(),
   provenance: AgentProvenanceSchema.extract([
     "measured",
     "computed",
@@ -1058,7 +934,7 @@ function repairedSearchCall(toolCall, searchName) {
 }
 
 // src/agent-runtime/runtime-internals.ts
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 function findRun(runs, runId) {
   const run = runs.find((candidate) => candidate.id === runId);
   if (!run)
@@ -1066,7 +942,7 @@ function findRun(runs, runId) {
   return run;
 }
 function jsonValue(value) {
-  const parsed = z3.json().safeParse(value);
+  const parsed = z2.json().safeParse(value);
   return parsed.success ? parsed.data : { message: "Non-JSON tool output omitted" };
 }
 function providerEnvelope(value) {
@@ -2567,4 +2443,4 @@ function createAgentRuntime(config) {
   };
 }
 
-export { AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, AgentAdmissionEventSchema, AgentTransientDeltaEventSchema, AgentReasoningStartEventSchema, AgentReasoningDeltaEventSchema, AgentReasoningEndEventSchema, AgentCheckpointEventSchema, AgentRunStateEventSchema, AgentToolStatusEventSchema, AgentTerminalEventSchema, AgentRuntimeEventSchema, AgentRuntimeEventCursorSchema, advanceAgentRuntimeEventCursor, agentDurableEventId, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentRuntimeConflictError, createAgentRuntime };
+export { AgentContextOverflowError, createAgentSessionCoordinator, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink, projectAgentHistoryDetailed, projectAgentHistory, createAgentToolFenceLifecycle, AgentTokenCountSchema, selectAgentHistory, composeAgentPrompt, AgentRuntimeConflictError, createAgentRuntime };

package/dist/index-a916km3r.js

@@ -0,0 +1,45 @@
+// src/internal/stable-digest.ts
+function stableValue(value) {
+  if (Array.isArray(value))
+    return value.map(stableValue);
+  if (value === null || typeof value !== "object")
+    return value;
+  const result = {};
+  for (const key of Object.keys(value).sort()) {
+    result[key] = stableValue(Reflect.get(value, key));
+  }
+  return result;
+}
+function mix128(input) {
+  let a = 2654435769;
+  let b = 2246822507;
+  let c = 3266489909;
+  let d = 668265263;
+  for (let index = 0;index < input.length; index += 1) {
+    const code = input.charCodeAt(index);
+    a = Math.imul(a ^ code, 2246822519);
+    b = Math.imul(b ^ code, 3266489917);
+    c = Math.imul(c ^ code, 668265263);
+    d = Math.imul(d ^ code, 374761393);
+    a = a << 13 | a >>> 19;
+    b = b << 17 | b >>> 15;
+    c = c << 7 | c >>> 25;
+    d = d << 11 | d >>> 21;
+  }
+  a ^= b >>> 15;
+  b ^= c >>> 13;
+  c ^= d >>> 11;
+  d ^= a >>> 9;
+  return [
+    Math.imul(a ^ a >>> 16, 575075507) >>> 0,
+    Math.imul(b ^ b >>> 13, 2654435761) >>> 0,
+    Math.imul(c ^ c >>> 16, 2246822507) >>> 0,
+    Math.imul(d ^ d >>> 15, 3266489909) >>> 0
+  ];
+}
+function argumentsDigest(args) {
+  const lanes = mix128(JSON.stringify(stableValue(args)) ?? "undefined");
+  return lanes.map((lane) => lane.toString(16).padStart(8, "0")).join("");
+}
+
+export { stableValue, argumentsDigest };

package/dist/index-b9aefrqd.js

@@ -0,0 +1,20 @@
+// src/internal/deadline.ts
+async function withDeadline(value, timeoutMs) {
+  if (!(value instanceof Promise))
+    return { settled: true, value };
+  let timer;
+  const expiry = new Promise((resolve) => {
+    timer = setTimeout(() => resolve({ settled: false }), timeoutMs);
+  });
+  try {
+    return await Promise.race([
+      value.then((settledValue) => ({ settled: true, value: settledValue })),
+      expiry
+    ]);
+  } finally {
+    if (timer !== undefined)
+      clearTimeout(timer);
+  }
+}
+
+export { withDeadline };

package/dist/index-dre2ywck.js

@@ -0,0 +1,48 @@
+import {
+  LiveStatePhaseSchema,
+  LiveStateStopReasonSchema
+} from "./index-ywd0y6m1.js";
+
+// src/live/watch-contract.ts
+import { z } from "zod";
+var WatchKeySchema = z.object({
+  service: z.string().min(1),
+  action: z.string().min(1),
+  digest: z.string().min(1)
+}).strict().readonly();
+var WatchOpenSchema = z.object({ key: WatchKeySchema, args: z.unknown() }).readonly();
+var WatchAcceptedSchema = z.object({
+  accepted: z.boolean(),
+  reason: z.string().optional()
+}).strict().readonly();
+var WatchValueSchema = z.object({
+  key: WatchKeySchema,
+  revision: z.number().int().nonnegative(),
+  value: z.unknown()
+}).readonly();
+var WatchStateSchema = z.object({
+  key: WatchKeySchema,
+  phase: LiveStatePhaseSchema,
+  reason: LiveStateStopReasonSchema.optional(),
+  code: z.string().optional(),
+  message: z.string().optional()
+}).readonly();
+var WATCH_OPEN = "stitchkit.watch.open";
+var WATCH_CLOSE = "stitchkit.watch.close";
+var WATCH_VALUE = "stitchkit.watch.value";
+var WATCH_STATE = "stitchkit.watch.state";
+var watchContract = {
+  serverToClient: {
+    [WATCH_VALUE]: { args: z.tuple([WatchValueSchema]) },
+    [WATCH_STATE]: { args: z.tuple([WatchStateSchema]) }
+  },
+  clientToServer: {
+    [WATCH_OPEN]: { args: z.tuple([WatchOpenSchema]), ack: WatchAcceptedSchema },
+    [WATCH_CLOSE]: { args: z.tuple([z.object({ key: WatchKeySchema }).readonly()]) }
+  }
+};
+function watchKeyString(key) {
+  return `${key.service}/${key.action}/${key.digest}`;
+}
+
+export { WatchKeySchema, WatchValueSchema, WatchStateSchema, WATCH_OPEN, WATCH_CLOSE, WATCH_VALUE, WATCH_STATE, watchContract, watchKeyString };

package/dist/{index-s5tn4kdv.js → index-dwf1f2ap.js}

@@ -1,12 +1,12 @@
 import {
   resolveTraceContext
-} from "./index-efm026pw.js";
+} from "./index-fxz0v7vg.js";
 import {
   isUnsafeKey
-} from "./index-vj3vvpaa.js";
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/server/request.ts
 function generateTraceId() {

package/dist/{index-wwst0td5.js → index-dx9xehwt.js}

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool(definition) {

package/dist/{index-5r0ak8fr.js → index-dxesg10d.js}

@@ -3,18 +3,18 @@ import {
 } from "./index-3xnq72rz.js";
 import {
   collectToolSurface
-} from "./index-93xp5tgg.js";
+} from "./index-2rwwmr7v.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-cwp38wxn.js";
+} from "./index-5mtc969c.js";
 import {
   isToolExecutionControlError,
   toolResultFromError
-} from "./index-qaajjfp6.js";
+} from "./index-758zx2ha.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/tools/agent.ts
 import { jsonSchema, tool } from "ai";

package/dist/{index-aczggrty.js → index-dxjjv399.js}

@@ -1,9 +1,9 @@
 import {
   isUnsafeKey
-} from "./index-vj3vvpaa.js";
+} from "./index-kzfs85xp.js";
 import {
   isRecord
-} from "./index-qyrqwr4c.js";
+} from "./index-77fekveh.js";
 
 // src/observability/sanitize.ts
 var SENSITIVE_WORDS = new Set([

package/dist/{index-j6mfaw26.js → index-egaabxkz.js}

@@ -1,13 +1,13 @@
 import {
   collectTools,
   createToolRunner
-} from "./index-cwp38wxn.js";
+} from "./index-5mtc969c.js";
 import {
   toolErrorFromResult
-} from "./index-qaajjfp6.js";
+} from "./index-758zx2ha.js";
 import {
   assertUniqueToolName
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 import {
   AppError
 } from "./index-0w9abg87.js";