stitchkit 0.100.2 → 0.101.0

package/dist/{index-d8m8zpd8.js → index-jzczzcsb.js}

@@ -1,15 +1,15 @@
 import {
   projectRuntimeTool
-} from "./index-0r0fbk7z.js";
+} from "./index-7z9ym7t8.js";
 
 // src/tools/runtime-tool.ts
-function defineRuntimeTool(definition) {
+function defineRuntimeTool2(definition) {
   if (definition.transports?.length === 0) {
     throw new Error(`Runtime tool "${definition.name}" must expose at least one transport`);
   }
   return definition;
 }
-function createRuntimeToolFactory(config) {
+function createRuntimeToolFactory2(config) {
   function parseContext(context) {
     const parsed = config.context.parse(context);
     return {
@@ -22,18 +22,18 @@ function createRuntimeToolFactory(config) {
   }
   function define(definition) {
     if (definition.output !== undefined) {
-      const { action: action2, method: method2, meta: meta2, handler: handler2, ...tool2 } = definition;
-      const identity2 = {
+      const { action, method, meta, handler, ...tool } = definition;
+      const identity = {
         serviceName: config.serviceName,
-        action: action2,
-        method: method2,
+        action,
+        method,
         ...config.scope !== undefined && { scope: config.scope },
-        ...(meta2 ?? config.meta) !== undefined && { meta: meta2 ?? config.meta }
+        ...(meta ?? config.meta) !== undefined && { meta: meta ?? config.meta }
       };
-      return defineRuntimeTool({
-        ...tool2,
-        identity: identity2,
-        handler: (context) => handler2(parseContext(context))
+      return defineRuntimeTool2({
+        ...tool,
+        identity,
+        handler: (context) => handler(parseContext(context))
       });
     }
     const { action, method, meta, handler, ...tool } = definition;
@@ -44,7 +44,7 @@ function createRuntimeToolFactory(config) {
       ...config.scope !== undefined && { scope: config.scope },
       ...(meta ?? config.meta) !== undefined && { meta: meta ?? config.meta }
     };
-    return defineRuntimeTool({
+    return defineRuntimeTool2({
       ...tool,
       identity,
       handler: (context) => handler(parseContext(context))
@@ -97,4 +97,4 @@ function executableAgentRuntimeTools(tools) {
   return tools;
 }
 
-export { defineRuntimeTool, createRuntimeToolFactory, runtimeToolMountable, executableAgentRuntimeTools };
+export { defineRuntimeTool2, createRuntimeToolFactory2, runtimeToolMountable, executableAgentRuntimeTools };

package/dist/index-kqnd6a85.js

@@ -0,0 +1,26 @@
+import {
+  AgentRecordIdSchema2,
+  AgentRecordVersionSchema2,
+  AgentMessageSchema2
+} from "./index-8kzct1d6.js";
+
+// src/agent-runtime/conversations.ts
+import { z } from "zod";
+var AgentConversationSummarySchema2 = z.object({
+  conversationId: AgentRecordIdSchema2,
+  version: AgentRecordVersionSchema2,
+  updatedAt: z.iso.datetime({ offset: true }),
+  preview: z.string(),
+  activeRuns: z.int().nonnegative()
+}).strict();
+var AgentConversationPageSchema2 = z.object({
+  items: z.array(AgentConversationSummarySchema2),
+  nextCursor: z.string().min(1).optional()
+}).strict();
+var AgentConversationMessagePageSchema2 = z.object({
+  items: z.array(AgentMessageSchema2),
+  compacted: z.array(z.string().min(1)),
+  nextCursor: z.string().min(1).optional()
+}).strict();
+
+export { AgentConversationSummarySchema2, AgentConversationPageSchema2, AgentConversationMessagePageSchema2 };

package/dist/{index-35mh5bhj.js → index-kw1ws0cs.js}

@@ -1,23 +1,23 @@
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 import {
   isRecord
-} from "./index-hffjpmq9.js";
+} from "./index-9jfdm5tg.js";
 
 // src/internal/request.ts
-function generateTraceId() {
+function generateTraceId2() {
   return `${Date.now().toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
 }
-function resolveTraceId(req) {
+function resolveTraceId2(req) {
   const header = req.headers.get("x-request-id") ?? req.headers.get("x-trace-id");
   const trimmed = header?.trim();
   if (trimmed && trimmed.length <= 128 && /^[\w.-]+$/.test(trimmed)) {
     return trimmed;
   }
-  return generateTraceId();
+  return generateTraceId2();
 }
-function resolveSocketIp(req, server) {
+function resolveSocketIp2(req, server) {
   if (typeof server === "object" && server !== null && "requestIP" in server && typeof server.requestIP === "function") {
     const addr = server.requestIP(req);
     if (isRecord(addr) && typeof addr.address === "string" && addr.address) {
@@ -28,7 +28,7 @@ function resolveSocketIp(req, server) {
     return req.ip;
   return;
 }
-function extractIp(req, options = {}) {
+function extractIp2(req, options = {}) {
   if (options.trustProxy) {
     const forwarded = req.headers.get("x-forwarded-for");
     if (forwarded)
@@ -39,9 +39,9 @@ function extractIp(req, options = {}) {
   }
   return (options.socketIp ?? "").replace(/^::ffff:/, "");
 }
-function getClientInfo(req, options = {}) {
+function getClientInfo2(req, options = {}) {
   return {
-    ipAddress: extractIp(req, options) || undefined,
+    ipAddress: extractIp2(req, options) || undefined,
     userAgent: req.headers.get("user-agent") ?? undefined
   };
 }
@@ -145,7 +145,7 @@ function hasPrefix(bytes, prefix, bits) {
   }
   return true;
 }
-function isPublicIp(value) {
+function isPublicIp2(value) {
   const address = value.trim();
   if (!address)
     return false;
@@ -163,7 +163,7 @@ function isPublicIp(value) {
   if (!bytes)
     return false;
   if (hasPrefix(bytes, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255], 96)) {
-    return isPublicIp(Array.from(bytes.slice(12)).join("."));
+    return isPublicIp2(Array.from(bytes.slice(12)).join("."));
   }
   if (!hasPrefix(bytes, [32], 3))
     return false;
@@ -174,4 +174,4 @@ function isPublicIp(value) {
   return true;
 }
 
-export { generateTraceId, resolveTraceId, resolveSocketIp, extractIp, getClientInfo, parseQueryParams, isPublicIp };
+export { generateTraceId2, resolveTraceId2, resolveSocketIp2, extractIp2, getClientInfo2, parseQueryParams, isPublicIp2 };

package/dist/{index-4gcnakhx.js → index-m38ej7e5.js}

@@ -1,6 +1,6 @@
 import {
   isUnsafeKey
-} from "./index-kzfs85xp.js";
+} from "./index-zsarb5xp.js";
 
 // src/internal/route-pattern.ts
 import { z } from "zod";
@@ -79,4 +79,4 @@ function parseTrailingWildcard(path) {
   return wildcard ? { name: wildcard.name, segmentIndex: wildcard.segmentIndex } : null;
 }
 
-export { joinRoutePath, resolveRouteParamsSchema, parseTrailingWildcard };
+export { joinRoutePath, parseRoutePattern, resolveRouteParamsSchema, parseTrailingWildcard };

package/dist/{index-ndddxtyx.js → index-m79yr938.js}

@@ -1,24 +1,24 @@
 import {
-  RealtimeRequestInvalidAcknowledgementError,
-  RealtimeRequestRejectedError
-} from "./index-dce5wxcq.js";
+  AppError2
+} from "./index-n53mswt3.js";
 import {
-  zodIssues
-} from "./index-p5r7qpdd.js";
+  RealtimeRequestInvalidAcknowledgementError2,
+  RealtimeRequestRejectedError2
+} from "./index-4s0fep5q.js";
 import {
-  AppError
-} from "./index-2vtcmrj9.js";
+  zodIssues2
+} from "./index-1eeqpadm.js";
 
 // src/realtime/rejected-frame.ts
-var REALTIME_REJECTION_KEY = "@stitchkit/realtime-rejected";
+var REALTIME_REJECTION_KEY2 = "@stitchkit/realtime-rejected";
 var MAX_REJECTION_ISSUES = 20;
 function realtimeRejectionEnvelope(report) {
-  return { [REALTIME_REJECTION_KEY]: report };
+  return { [REALTIME_REJECTION_KEY2]: report };
 }
-function asRealtimeRejection(value) {
+function asRealtimeRejection2(value) {
   if (typeof value !== "object" || value === null)
     return null;
-  const report = Reflect.get(value, REALTIME_REJECTION_KEY);
+  const report = Reflect.get(value, REALTIME_REJECTION_KEY2);
   if (typeof report !== "object" || report === null)
     return null;
   const event = Reflect.get(report, "event");
@@ -58,9 +58,9 @@ function parseIssues(value) {
 // src/realtime/rejection.ts
 import { z } from "zod";
 function realtimeContractViolation(options) {
-  const issues = options.cause instanceof z.ZodError ? zodIssues(options.cause) : undefined;
+  const issues = options.cause instanceof z.ZodError ? zodIssues2(options.cause) : undefined;
   const reason = options.reason.replaceAll("-", " ");
-  const error = new AppError("REALTIME_CONTRACT_VIOLATION", `Realtime event "${options.event}" (${options.direction}, ${options.phase}): ${reason}`, 500, {
+  const error = new AppError2("REALTIME_CONTRACT_VIOLATION", `Realtime event "${options.event}" (${options.direction}, ${options.phase}): ${reason}`, 500, {
     event: options.event,
     direction: options.direction,
     phase: options.phase,
@@ -152,7 +152,7 @@ function parseRealtimeRequestArguments(registry, event, direction, args) {
   return parsed.data;
 }
 function parseRealtimeRequestAcknowledgement(schema, event, direction, value, hook, logger) {
-  const refusal = asRealtimeRejection(value);
+  const refusal = asRealtimeRejection2(value);
   if (refusal) {
     reportRejected(realtimeContractViolation({
       event,
@@ -161,7 +161,7 @@ function parseRealtimeRequestAcknowledgement(schema, event, direction, value, ho
       reason: "rejected-by-peer",
       fault: "local"
     }), hook, logger);
-    throw new RealtimeRequestRejectedError(event, refusal.reason, refusal.message, refusal.issues);
+    throw new RealtimeRequestRejectedError2(event, refusal.reason, refusal.message, refusal.issues);
   }
   const parsed = schema.safeParse(value);
   if (parsed.success)
@@ -175,7 +175,7 @@ function parseRealtimeRequestAcknowledgement(schema, event, direction, value, ho
     cause: parsed.error
   });
   reportRejected(rejected, hook, logger);
-  throw new RealtimeRequestInvalidAcknowledgementError(event, rejected.error);
+  throw new RealtimeRequestInvalidAcknowledgementError2(event, rejected.error);
 }
 function createValidatedRealtimeSocket({
   target,
@@ -208,7 +208,7 @@ function createValidatedRealtimeSocket({
             event,
             reason: "invalid-arguments",
             message: rejected.error.message,
-            issues: zodIssues(parsed.error).slice(0, MAX_REJECTION_ISSUES)
+            issues: zodIssues2(parsed.error).slice(0, MAX_REJECTION_ISSUES)
           }, logger);
           return;
         }
@@ -279,7 +279,7 @@ function createValidatedRealtimeSocket({
       const wireArgs = [...parsed.data];
       if (definition.ack && acknowledgement) {
         wireArgs.push((value) => {
-          const refusal = asRealtimeRejection(value);
+          const refusal = asRealtimeRejection2(value);
           if (refusal) {
             reportRejected(realtimeContractViolation({
               event,
@@ -321,4 +321,4 @@ function isModuleNotFound(error) {
   return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || message.includes("Cannot find module") || message.includes("Cannot find package");
 }
 
-export { REALTIME_REJECTION_KEY, asRealtimeRejection, parseRealtimeRequestArguments, parseRealtimeRequestAcknowledgement, createValidatedRealtimeSocket, isModuleNotFound };
+export { REALTIME_REJECTION_KEY2, asRealtimeRejection2, parseRealtimeRequestArguments, parseRealtimeRequestAcknowledgement, createValidatedRealtimeSocket, isModuleNotFound };

package/dist/{index-5p2m7we1.js → index-m9fndta6.js}

@@ -1,23 +1,23 @@
 import {
-  collectTools,
-  createToolRunner
-} from "./index-bm5rx7n6.js";
+  AppError2
+} from "./index-n53mswt3.js";
 import {
   toolErrorFromResult
-} from "./index-8qt2m66q.js";
+} from "./index-dvwj1f43.js";
 import {
   assertUniqueToolName
-} from "./index-0r0fbk7z.js";
+} from "./index-7z9ym7t8.js";
 import {
-  AppError
-} from "./index-2vtcmrj9.js";
+  collectTools2,
+  createToolRunner
+} from "./index-n9tyz8z3.js";
 
 // src/tools/invoker.ts
-function createToolInvoker(services, config) {
+function createToolInvoker2(services, config) {
   const serviceList = Array.isArray(services) ? services : [services];
   const tools = new Map;
   for (const service of serviceList) {
-    for (const tool of collectTools(service, config.transport, {
+    for (const tool of collectTools2(service, config.transport, {
       extend: config.extend,
       flattenUnionInput: config.flattenUnionInput
     })) {
@@ -30,7 +30,7 @@ function createToolInvoker(services, config) {
     const tool = tools.get(name);
     if (tool)
       return tool;
-    throw new AppError("NOT_FOUND", `Unknown tool: ${name}`, 404, {
+    throw new AppError2("NOT_FOUND", `Unknown tool: ${name}`, 404, {
       available: names
     });
   };
@@ -61,4 +61,4 @@ function createToolInvoker(services, config) {
   });
 }
 
-export { createToolInvoker };
+export { createToolInvoker2 };

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 };