stitchkit 0.100.1 → 0.100.3

package/dist/index-mnkk1ffz.js

@@ -0,0 +1,150 @@
+import {
+  AgentRecordIdSchema2,
+  AgentRecordVersionSchema2,
+  AgentTimestampSchema2,
+  AgentProviderEnvelopeSchema2,
+  AgentMessageSchema2,
+  AgentAssistantPlaceholderSchema2,
+  AgentRunStateSchema2,
+  AgentRunOperationSchema2,
+  AgentTerminalReasonSchema2,
+  AgentRunSchema2,
+  AgentRunMetricsSchema2
+} from "./index-8kzct1d6.js";
+
+// src/agent-runtime/event-schema.ts
+import { z } from "zod";
+var AgentAdmissionEventSchema2 = z.object({
+  type: z.literal("admission"),
+  eventId: AgentRecordIdSchema2,
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  snapshotVersion: AgentRecordVersionSchema2,
+  input: AgentMessageSchema2,
+  run: AgentRunSchema2,
+  assistant: z.union([AgentAssistantPlaceholderSchema2, AgentMessageSchema2]),
+  emittedAt: AgentTimestampSchema2
+});
+var EventIdentitySchema = z.object({
+  conversationId: AgentRecordIdSchema2,
+  runId: AgentRecordIdSchema2,
+  emittedAt: AgentTimestampSchema2
+});
+var AgentTransientDeltaEventSchema2 = 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: AgentProviderEnvelopeSchema2.optional()
+});
+var AgentReasoningStartEventSchema2 = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-start")
+});
+var AgentReasoningDeltaEventSchema2 = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-delta"),
+  textDelta: z.string()
+});
+var AgentReasoningEndEventSchema2 = AgentTransientReasoningIdentitySchema.extend({
+  type: z.literal("reasoning-end")
+});
+var AgentAttemptResetEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("attempt-reset"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  attempt: z.int().positive()
+});
+var AgentCheckpointEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("assistant-checkpoint"),
+  eventId: AgentRecordIdSchema2,
+  snapshotVersion: AgentRecordVersionSchema2,
+  message: AgentMessageSchema2,
+  metrics: AgentRunMetricsSchema2.optional()
+});
+var AgentRunStateEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("run-state"),
+  eventId: AgentRecordIdSchema2,
+  snapshotVersion: AgentRecordVersionSchema2,
+  state: AgentRunStateSchema2
+});
+var AgentRunOperationEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("run-operation"),
+  eventId: AgentRecordIdSchema2,
+  snapshotVersion: AgentRecordVersionSchema2,
+  operation: AgentRunOperationSchema2
+});
+var AgentToolStatusEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("tool-status"),
+  runtimeEpoch: z.string().min(1),
+  sequence: z.int().nonnegative(),
+  callId: AgentRecordIdSchema2,
+  toolName: z.string().min(1),
+  status: z.enum(["started", "completed", "failed", "interrupted"]),
+  input: z.json().optional(),
+  output: z.json().optional()
+});
+var AgentTerminalEventSchema2 = EventIdentitySchema.extend({
+  type: z.literal("terminal"),
+  eventId: AgentRecordIdSchema2,
+  snapshotVersion: AgentRecordVersionSchema2,
+  reason: AgentTerminalReasonSchema2,
+  policyName: z.string().min(1).optional(),
+  message: AgentMessageSchema2,
+  metrics: AgentRunMetricsSchema2.optional()
+});
+var AgentRuntimeEventSchema2 = z.discriminatedUnion("type", [
+  AgentAdmissionEventSchema2,
+  AgentTransientDeltaEventSchema2,
+  AgentReasoningStartEventSchema2,
+  AgentReasoningDeltaEventSchema2,
+  AgentReasoningEndEventSchema2,
+  AgentAttemptResetEventSchema2,
+  AgentCheckpointEventSchema2,
+  AgentRunStateEventSchema2,
+  AgentRunOperationEventSchema2,
+  AgentToolStatusEventSchema2,
+  AgentTerminalEventSchema2
+]);
+var AgentRuntimeEventCursorSchema2 = z.object({
+  snapshotVersion: AgentRecordVersionSchema2.optional(),
+  durableEventIds: z.array(AgentRecordIdSchema2).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 === "run-operation" || event.type === "terminal";
+}
+function advanceAgentRuntimeEventCursor2(rawCursor, event) {
+  const cursor = AgentRuntimeEventCursorSchema2.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 agentDurableEventId2(type, runId, snapshotVersion) {
+  return `${runId}:${type}:${snapshotVersion}`;
+}
+
+export { AgentAdmissionEventSchema2, AgentTransientDeltaEventSchema2, AgentReasoningStartEventSchema2, AgentReasoningDeltaEventSchema2, AgentReasoningEndEventSchema2, AgentAttemptResetEventSchema2, AgentCheckpointEventSchema2, AgentRunStateEventSchema2, AgentRunOperationEventSchema2, AgentToolStatusEventSchema2, AgentTerminalEventSchema2, AgentRuntimeEventSchema2, AgentRuntimeEventCursorSchema2, advanceAgentRuntimeEventCursor2, agentDurableEventId2 };

package/dist/index-n15jny5b.js

@@ -0,0 +1,4 @@
+// src/release/header.ts
+var RELEASE_HEADER2 = "X-Build-Id";
+
+export { RELEASE_HEADER2 };

package/dist/{index-2vtcmrj9.js → index-n53mswt3.js}

@@ -1,7 +1,7 @@
 // src/contract/errors.ts
 var APP_ERROR_BRAND = Symbol.for("stitchkit.AppError");
 
-class AppError extends Error {
+class AppError2 extends Error {
   code;
   status;
   details;
@@ -33,25 +33,25 @@ class AppError extends Error {
     };
   }
 }
-function notFound(message = "Not found") {
-  throw new AppError("NOT_FOUND", message, 404);
+function notFound2(message = "Not found") {
+  throw new AppError2("NOT_FOUND", message, 404);
 }
-function badRequest(message, details) {
-  throw new AppError("BAD_REQUEST", message, 400, details);
+function badRequest2(message, details) {
+  throw new AppError2("BAD_REQUEST", message, 400, details);
 }
-function unauthorized(message = "Unauthorized") {
-  throw new AppError("UNAUTHORIZED", message, 401);
+function unauthorized2(message = "Unauthorized") {
+  throw new AppError2("UNAUTHORIZED", message, 401);
 }
-function forbidden(message = "Forbidden") {
-  throw new AppError("FORBIDDEN", message, 403);
+function forbidden2(message = "Forbidden") {
+  throw new AppError2("FORBIDDEN", message, 403);
 }
-function conflict(message = "Conflict", details) {
-  throw new AppError("CONFLICT", message, 409, details);
+function conflict2(message = "Conflict", details) {
+  throw new AppError2("CONFLICT", message, 409, details);
 }
-function rateLimited(message = "Too many requests") {
-  throw new AppError("RATE_LIMITED", message, 429);
+function rateLimited2(message = "Too many requests") {
+  throw new AppError2("RATE_LIMITED", message, 429);
 }
-var STITCH_ERROR_STATUS = {
+var STITCH_ERROR_STATUS2 = {
   BAD_REQUEST: 400,
   UNAUTHORIZED: 401,
   FORBIDDEN: 403,
@@ -85,14 +85,14 @@ var STITCH_ERROR_STATUS = {
   SPILL_REFERENCE_UNKNOWN: 404,
   INTERNAL_SERVER_ERROR: 500
 };
-function isRetryableStatus(status) {
+function isRetryableStatus2(status) {
   return status === 408 || status === 429 || status === 502 || status === 503 || status === 504;
 }
-function isStitchErrorCode(code) {
-  return Object.hasOwn(STITCH_ERROR_STATUS, code);
+function isStitchErrorCode2(code) {
+  return Object.hasOwn(STITCH_ERROR_STATUS2, code);
 }
-function appError(code, message, details) {
-  throw new AppError(code, message, isStitchErrorCode(code) ? STITCH_ERROR_STATUS[code] : 500, details);
+function appError2(code, message, details) {
+  throw new AppError2(code, message, isStitchErrorCode2(code) ? STITCH_ERROR_STATUS2[code] : 500, details);
 }
 
-export { AppError, notFound, badRequest, unauthorized, forbidden, conflict, rateLimited, STITCH_ERROR_STATUS, isRetryableStatus, isStitchErrorCode, appError };
+export { AppError2, notFound2, badRequest2, unauthorized2, forbidden2, conflict2, rateLimited2, STITCH_ERROR_STATUS2, isRetryableStatus2, isStitchErrorCode2, appError2 };

package/dist/{index-bt14acb5.js → index-n5yqxd3d.js}

@@ -1,15 +1,15 @@
 import {
-  AgentRuntimeEventSchema
-} from "./index-y64k3s0h.js";
+  AgentMessagePartSchema2,
+  AgentSnapshotSchema2
+} from "./index-8kzct1d6.js";
 import {
-  AgentMessagePartSchema,
-  AgentSnapshotSchema
-} from "./index-gtj3zc53.js";
+  AgentRuntimeEventSchema2
+} from "./index-mnkk1ffz.js";
 
 // src/agent-runtime/control-schema.ts
 import { z } from "zod";
 var AgentControlIdentitySchema = z.object({ schemaVersion: z.literal(1), requestId: z.string().min(1) }).strict();
-var AgentControlRequestSchema = z.discriminatedUnion("operation", [
+var AgentControlRequestSchema2 = z.discriminatedUnion("operation", [
   AgentControlIdentitySchema.extend({
     operation: z.literal("attach"),
     conversationId: z.string().min(1),
@@ -28,7 +28,7 @@ var AgentControlRequestSchema = z.discriminatedUnion("operation", [
     conversationId: z.string().min(1),
     idempotencyKey: z.string().min(1),
     context: z.unknown(),
-    parts: z.array(AgentMessagePartSchema).min(1),
+    parts: z.array(AgentMessagePartSchema2).min(1),
     metadata: z.unknown().optional()
   }),
   AgentControlIdentitySchema.extend({
@@ -50,10 +50,10 @@ var AgentControlResponseIdentitySchema = z.object({
   schemaVersion: z.literal(1),
   requestId: z.string().min(1)
 });
-var AgentControlResponseSchema = z.discriminatedUnion("outcome", [
+var AgentControlResponseSchema2 = z.discriminatedUnion("outcome", [
   AgentControlResponseIdentitySchema.extend({
     outcome: z.literal("ok"),
-    snapshot: AgentSnapshotSchema.optional(),
+    snapshot: AgentSnapshotSchema2.optional(),
     runId: z.string().min(1).optional()
   }).strict(),
   AgentControlResponseIdentitySchema.extend({
@@ -61,11 +61,11 @@ var AgentControlResponseSchema = z.discriminatedUnion("outcome", [
     error: z.object({ code: z.string().min(1), message: z.string().min(1) }).strict()
   }).strict()
 ]);
-var AgentControlDeliverySchema = z.discriminatedUnion("type", [
+var AgentControlDeliverySchema2 = z.discriminatedUnion("type", [
   z.object({
     schemaVersion: z.literal(1),
     type: z.literal("event"),
-    event: AgentRuntimeEventSchema
+    event: AgentRuntimeEventSchema2
   }).strict(),
   z.object({
     schemaVersion: z.literal(1),
@@ -74,7 +74,7 @@ var AgentControlDeliverySchema = z.discriminatedUnion("type", [
     reason: z.literal("overflow")
   }).strict()
 ]);
-var AgentMultiSessionCursorSchema = z.object({
+var AgentMultiSessionCursorSchema2 = z.object({
   conversations: z.record(z.string(), z.object({
     snapshotVersion: z.int().nonnegative().optional(),
     durableEventIds: z.array(z.string().min(1)).optional(),
@@ -90,8 +90,8 @@ function durable(event) {
     "terminal"
   ].includes(event.type);
 }
-function advanceAgentMultiSessionCursor(raw, event) {
-  const cursor = AgentMultiSessionCursorSchema.parse(raw);
+function advanceAgentMultiSessionCursor2(raw, event) {
+  const cursor = AgentMultiSessionCursorSchema2.parse(raw);
   const previous = cursor.conversations[event.conversationId] ?? { runs: {} };
   if (durable(event)) {
     const ids = previous.snapshotVersion === event.snapshotVersion ? previous.durableEventIds ?? [] : [];
@@ -133,11 +133,11 @@ function advanceAgentMultiSessionCursor(raw, event) {
     }
   };
 }
-function createAgentControlView() {
+function createAgentControlView2() {
   return { cursor: { conversations: {} }, conversations: {} };
 }
-function reduceAgentControlSnapshot(view, rawSnapshot) {
-  const snapshot = AgentSnapshotSchema.parse(rawSnapshot);
+function reduceAgentControlSnapshot2(view, rawSnapshot) {
+  const snapshot = AgentSnapshotSchema2.parse(rawSnapshot);
   const previous = view.cursor.conversations[snapshot.conversationId] ?? { runs: {} };
   return {
     cursor: {
@@ -160,9 +160,9 @@ function reduceAgentControlSnapshot(view, rawSnapshot) {
     }
   };
 }
-function reduceAgentControlEvent(view, rawEvent) {
-  const event = AgentRuntimeEventSchema.parse(rawEvent);
-  const advanced = advanceAgentMultiSessionCursor(view.cursor, event);
+function reduceAgentControlEvent2(view, rawEvent) {
+  const event = AgentRuntimeEventSchema2.parse(rawEvent);
+  const advanced = advanceAgentMultiSessionCursor2(view.cursor, event);
   if (advanced.status === "duplicate")
     return view;
   const current = view.conversations[event.conversationId] ?? {
@@ -195,4 +195,4 @@ function reduceAgentControlEvent(view, rawEvent) {
   };
 }
 
-export { AgentControlRequestSchema, AgentControlResponseSchema, AgentControlDeliverySchema, AgentMultiSessionCursorSchema, advanceAgentMultiSessionCursor, createAgentControlView, reduceAgentControlSnapshot, reduceAgentControlEvent };
+export { AgentControlRequestSchema2, AgentControlResponseSchema2, AgentControlDeliverySchema2, AgentMultiSessionCursorSchema2, advanceAgentMultiSessionCursor2, createAgentControlView2, reduceAgentControlSnapshot2, reduceAgentControlEvent2 };

package/dist/{index-bm5rx7n6.js → index-n9tyz8z3.js}

@@ -1,16 +1,16 @@
 import {
-  executeToolMethod,
-  toolErrorFromResult
-} from "./index-8qt2m66q.js";
+  isRetryableStatus2
+} from "./index-n53mswt3.js";
 import {
-  assertToolExtensionCompatible,
+  rebuildObject,
   mergeSchemas,
-  projectToolSurface,
-  rebuildObject
-} from "./index-0r0fbk7z.js";
+  assertToolExtensionCompatible,
+  projectToolSurface
+} from "./index-7z9ym7t8.js";
 import {
-  isRetryableStatus
-} from "./index-2vtcmrj9.js";
+  toolErrorFromResult,
+  executeToolMethod
+} from "./index-dvwj1f43.js";
 
 // src/tools/mount.ts
 import { z } from "zod";
@@ -33,7 +33,7 @@ function contractToolMountable(projected, extend) {
     shouldExtend: projected.shouldExtend
   };
 }
-function collectTools(service, transport, config = {}) {
+function collectTools2(service, transport, config = {}) {
   const { extend, flattenUnionInput = false, assertNames = true } = config;
   const tools = [];
   for (const projected of projectToolSurface({ services: [service] }, transport === "HTTP" ? "AGENT" : transport, {
@@ -72,7 +72,7 @@ function createToolRunner(config) {
 function formatToolError(result, toolName, errorHint) {
   const err = {
     error: result.code,
-    retryable: result.retryable ?? isRetryableStatus(toolErrorFromResult(result).status)
+    retryable: result.retryable ?? isRetryableStatus2(toolErrorFromResult(result).status)
   };
   if (result.details)
     err.details = result.details;
@@ -89,4 +89,4 @@ function formatToolError(result, toolName, errorHint) {
   return err;
 }
 
-export { contractToolMountable, collectTools, createToolRunner, formatToolError };
+export { contractToolMountable, collectTools2, createToolRunner, formatToolError };