stitchkit 0.78.0 → 0.80.0

package/dist/cli.js

@@ -5,20 +5,22 @@ import {
   emitResult,
   parseCliArgs,
   pollUntilDone
-} from "./index-31k1ns1s.js";
-import"./index-93xp5tgg.js";
-import"./index-wwst0td5.js";
-import"./index-cwp38wxn.js";
-import"./index-qaajjfp6.js";
+} from "./index-vwp69871.js";
 import"./index-sbdmyz75.js";
-import"./index-22by16v6.js";
+import"./index-2rwwmr7v.js";
+import"./index-dx9xehwt.js";
+import"./index-5mtc969c.js";
+import"./index-758zx2ha.js";
+import"./index-dwf1f2ap.js";
+import"./index-mgtxfe6b.js";
 import"./index-cby4ar3v.js";
-import"./index-s5tn4kdv.js";
-import"./index-efm026pw.js";
-import"./index-vj3vvpaa.js";
-import"./index-qyrqwr4c.js";
-import"./index-0w9abg87.js";
+import"./index-7zbps32p.js";
+import"./index-fxz0v7vg.js";
+import"./index-y01f4223.js";
 import"./index-6k1937bx.js";
+import"./index-0w9abg87.js";
+import"./index-kzfs85xp.js";
+import"./index-77fekveh.js";
 export {
   pollUntilDone,
   parseCliArgs,

package/dist/contract/index.js

@@ -2,15 +2,17 @@ import {
   ALL_TRANSPORTS,
   ContractStreamFrameSchema,
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES,
-  ManagedFilePathSchema,
-  ManagedFileRefSchema,
   createContractFactory,
   decodeCursor,
   defineContract,
   defineErrors,
   encodeCursor,
   paginatedSchema
-} from "../index-7z69kyrh.js";
+} from "../index-y01f4223.js";
+import {
+  ManagedFilePathSchema,
+  ManagedFileRefSchema
+} from "../index-6k1937bx.js";
 import {
   AppError,
   STITCH_ERROR_STATUS,
@@ -23,7 +25,8 @@ import {
   rateLimited,
   unauthorized
 } from "../index-0w9abg87.js";
-import"../index-ksp6e2ye.js";
+import"../index-kzfs85xp.js";
+import"../index-77fekveh.js";
 export {
   unauthorized,
   rateLimited,

package/dist/index-2qzskm8h.js

@@ -0,0 +1,63 @@
+// src/realtime/request.ts
+import { z } from "zod";
+var RealtimeRequestPhaseSchema = z.enum([
+  "engine-handoff",
+  "engine-ack-received",
+  "settled",
+  "timeout",
+  "disconnected"
+]);
+var RealtimeRequestPhaseEventSchema = z.object({
+  requestId: z.string().min(1),
+  event: z.string().min(1),
+  phase: RealtimeRequestPhaseSchema,
+  elapsedMs: z.number().finite().nonnegative()
+}).strict();
+
+class RealtimeRequestTimeoutError extends Error {
+  code = "REALTIME_REQUEST_TIMEOUT";
+  event;
+  timeoutMs;
+  constructor(event, timeoutMs) {
+    super(`Realtime request "${event}" timed out after ${timeoutMs}ms`);
+    this.name = "RealtimeRequestTimeoutError";
+    this.event = event;
+    this.timeoutMs = timeoutMs;
+  }
+}
+
+class RealtimeRequestDisconnectedError extends Error {
+  code = "REALTIME_REQUEST_DISCONNECTED";
+  event;
+  constructor(event) {
+    super(`Realtime request "${event}" was interrupted by disconnect`);
+    this.name = "RealtimeRequestDisconnectedError";
+    this.event = event;
+  }
+}
+
+class RealtimeRequestInvalidAcknowledgementError extends Error {
+  code = "REALTIME_REQUEST_INVALID_ACKNOWLEDGEMENT";
+  event;
+  constructor(event, cause) {
+    super(`Realtime request "${event}" received an invalid acknowledgement`, { cause });
+    this.name = "RealtimeRequestInvalidAcknowledgementError";
+    this.event = event;
+  }
+}
+
+class RealtimeRequestRejectedError extends Error {
+  code = "REALTIME_REQUEST_REJECTED";
+  event;
+  reason;
+  issues;
+  constructor(event, reason, detail, issues) {
+    super(`Realtime request "${event}" was rejected by the peer (${reason}): ${detail}`);
+    this.name = "RealtimeRequestRejectedError";
+    this.event = event;
+    this.reason = reason;
+    this.issues = issues;
+  }
+}
+
+export { RealtimeRequestPhaseSchema, RealtimeRequestPhaseEventSchema, RealtimeRequestTimeoutError, RealtimeRequestDisconnectedError, RealtimeRequestInvalidAcknowledgementError, RealtimeRequestRejectedError };

package/dist/{index-93xp5tgg.js → index-2rwwmr7v.js}

@@ -1,12 +1,12 @@
 import {
   runtimeToolMountable
-} from "./index-wwst0td5.js";
+} from "./index-dx9xehwt.js";
 import {
   contractToolMountable
-} from "./index-cwp38wxn.js";
+} from "./index-5mtc969c.js";
 import {
   projectToolSurface
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 
 // src/tools/surface.ts
 function collectToolSurface({

package/dist/{index-kw12fsbc.js → index-3gye9wzb.js}

@@ -44,7 +44,8 @@ var ApplicationSnapshotSchema = z.object({
   capturedAt: z.string().datetime({ offset: true }),
   changedAt: z.string().datetime({ offset: true }),
   admission: ApplicationAdmissionSnapshotSchema,
-  resources: z.array(ManagedResourceSnapshotSchema).readonly()
+  resources: z.array(ManagedResourceSnapshotSchema).readonly(),
+  restarting: z.array(z.string()).readonly()
 }).readonly();
 var ApplicationStatusProjectionSchema = z.object({
   id: ApplicationIdSchema,
@@ -57,7 +58,8 @@ var ApplicationStatusProjectionSchema = z.object({
     ready: NonNegativeIntegerSchema,
     degraded: NonNegativeIntegerSchema,
     failed: NonNegativeIntegerSchema
-  }).readonly()
+  }).readonly(),
+  restarting: NonNegativeIntegerSchema
 }).readonly();
 function projectApplicationStatus(snapshot) {
   let ready = 0;
@@ -77,7 +79,8 @@ function projectApplicationStatus(snapshot) {
     health: snapshot.health,
     ready: snapshot.ready,
     capturedAt: snapshot.capturedAt,
-    resources: { total: snapshot.resources.length, ready, degraded, failed }
+    resources: { total: snapshot.resources.length, ready, degraded, failed },
+    restarting: snapshot.restarting.length
   };
 }
 var ApplicationResourceShutdownSchema = z.object({
@@ -96,4 +99,5 @@ var ApplicationShutdownResultSchema = z.object({
   resources: z.array(ApplicationResourceShutdownSchema).readonly(),
   durationMs: z.number().nonnegative()
 }).readonly();
+
 export { ApplicationIdSchema, ApplicationLifecycleSchema, ApplicationHealthSchema, ManagedResourceStateSchema, ApplicationAdmissionSnapshotSchema, ManagedResourceSnapshotSchema, ApplicationSnapshotSchema, ApplicationStatusProjectionSchema, projectApplicationStatus, ApplicationResourceShutdownSchema, ApplicationShutdownResultSchema };

package/dist/{index-1ckavx4h.js → index-3z73fh2c.js}

@@ -329,52 +329,4 @@ function createServerLifecycle(getAdapter) {
   };
 }
 
-// src/realtime/request.ts
-import { z as z2 } from "zod";
-var RealtimeRequestPhaseSchema = z2.enum([
-  "engine-handoff",
-  "engine-ack-received",
-  "settled",
-  "timeout",
-  "disconnected"
-]);
-var RealtimeRequestPhaseEventSchema = z2.object({
-  requestId: z2.string().min(1),
-  event: z2.string().min(1),
-  phase: RealtimeRequestPhaseSchema,
-  elapsedMs: z2.number().finite().nonnegative()
-}).strict();
-
-class RealtimeRequestTimeoutError extends Error {
-  code = "REALTIME_REQUEST_TIMEOUT";
-  event;
-  timeoutMs;
-  constructor(event, timeoutMs) {
-    super(`Realtime request "${event}" timed out after ${timeoutMs}ms`);
-    this.name = "RealtimeRequestTimeoutError";
-    this.event = event;
-    this.timeoutMs = timeoutMs;
-  }
-}
-
-class RealtimeRequestDisconnectedError extends Error {
-  code = "REALTIME_REQUEST_DISCONNECTED";
-  event;
-  constructor(event) {
-    super(`Realtime request "${event}" was interrupted by disconnect`);
-    this.name = "RealtimeRequestDisconnectedError";
-    this.event = event;
-  }
-}
-
-class RealtimeRequestInvalidAcknowledgementError extends Error {
-  code = "REALTIME_REQUEST_INVALID_ACKNOWLEDGEMENT";
-  event;
-  constructor(event, cause) {
-    super(`Realtime request "${event}" received an invalid acknowledgement`, { cause });
-    this.name = "RealtimeRequestInvalidAcknowledgementError";
-    this.event = event;
-  }
-}
-
-export { isStreamCancellation, ownHttpStream, settleStreamCleanup, ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle, RealtimeRequestTimeoutError, RealtimeRequestDisconnectedError, RealtimeRequestInvalidAcknowledgementError };
+export { isStreamCancellation, ownHttpStream, settleStreamCleanup, ShutdownStateSchema, ShutdownOptionsSchema, ShutdownStatusSchema, ShutdownResultSchema, createServerLifecycle };

package/dist/index-4fpa9dy2.js

@@ -0,0 +1,51 @@
+// src/tools/async-operation-contract.ts
+import { z } from "zod";
+var AsyncOperationCancelResultSchema = z.discriminatedUnion("outcome", [
+  z.object({ outcome: z.literal("accepted") }),
+  z.object({ outcome: z.literal("already_terminal") }),
+  z.object({ outcome: z.literal("rejected"), reason: z.string().min(1) })
+]);
+function createAsyncOperationSnapshotSchema(config) {
+  const progress = config.progress ? { progress: config.progress.optional() } : {};
+  return z.discriminatedUnion("phase", [
+    z.object({ phase: z.literal("pending"), ...progress }),
+    z.object({ phase: z.literal("running"), ...progress }),
+    z.object({ phase: z.literal("succeeded"), ...progress }),
+    z.object({ phase: z.literal("failed"), failure: config.failure, ...progress }),
+    z.object({ phase: z.literal("cancelled"), ...progress })
+  ]);
+}
+// src/tools/view-file-contract.ts
+import { z as z2 } from "zod";
+var MAX_VIEW_FILES = 20;
+var McpAnnotationsSchema = z2.object({
+  audience: z2.array(z2.enum(["user", "assistant"])).optional(),
+  priority: z2.number().optional()
+});
+var McpMediaContentSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("text"), text: z2.string() }),
+  z2.object({
+    type: z2.literal("image"),
+    data: z2.string(),
+    mimeType: z2.string(),
+    annotations: McpAnnotationsSchema.optional()
+  }),
+  z2.object({
+    type: z2.literal("audio"),
+    data: z2.string(),
+    mimeType: z2.string(),
+    annotations: McpAnnotationsSchema.optional()
+  })
+]);
+var ViewFileErrorSchema = z2.object({
+  path: z2.string(),
+  message: z2.string()
+});
+var ViewFileOutputSchema = z2.object({
+  content: z2.array(McpMediaContentSchema),
+  errors: z2.array(ViewFileErrorSchema)
+});
+var ViewFileInputSchema = z2.object({
+  paths: z2.union([z2.string(), z2.array(z2.string()).max(MAX_VIEW_FILES)]).describe("Media URL(s) or file path(s) to view")
+});
+export { AsyncOperationCancelResultSchema, createAsyncOperationSnapshotSchema, McpAnnotationsSchema, McpMediaContentSchema, ViewFileErrorSchema, ViewFileOutputSchema, ViewFileInputSchema };

package/dist/{index-cwp38wxn.js → index-5mtc969c.js}

@@ -1,12 +1,12 @@
 import {
   executeToolMethod
-} from "./index-qaajjfp6.js";
+} from "./index-758zx2ha.js";
 import {
   assertToolExtensionCompatible,
   mergeSchemas,
   projectToolSurface,
   rebuildObject
-} from "./index-22by16v6.js";
+} from "./index-mgtxfe6b.js";
 
 // src/tools/mount.ts
 import { z } from "zod";

package/dist/index-5s3zajp8.js

@@ -0,0 +1,192 @@
+import {
+  AgentRuntimeEventSchema
+} from "./index-85vfqd7m.js";
+import {
+  AgentMessagePartSchema,
+  AgentSnapshotSchema
+} from "./index-x1th9s8c.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", [
+  AgentControlIdentitySchema.extend({
+    operation: z.literal("attach"),
+    conversationId: z.string().min(1),
+    access: z.enum(["observe", "control"])
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z.literal("detach"),
+    conversationId: z.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z.literal("snapshot"),
+    conversationId: z.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z.literal("submit"),
+    conversationId: z.string().min(1),
+    idempotencyKey: z.string().min(1),
+    context: z.unknown(),
+    parts: z.array(AgentMessagePartSchema).min(1),
+    metadata: z.unknown().optional()
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z.literal("interrupt"),
+    conversationId: z.string().min(1),
+    runId: z.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z.literal("respond-approval"),
+    conversationId: z.string().min(1),
+    approvalId: z.string().min(1),
+    approved: z.boolean(),
+    reason: z.string().min(1).optional(),
+    context: z.unknown(),
+    metadata: z.unknown().optional()
+  })
+]);
+var AgentControlResponseIdentitySchema = z.object({
+  schemaVersion: z.literal(1),
+  requestId: z.string().min(1)
+});
+var AgentControlResponseSchema = z.discriminatedUnion("outcome", [
+  AgentControlResponseIdentitySchema.extend({
+    outcome: z.literal("ok"),
+    snapshot: AgentSnapshotSchema.optional(),
+    runId: z.string().min(1).optional()
+  }).strict(),
+  AgentControlResponseIdentitySchema.extend({
+    outcome: z.literal("error"),
+    error: z.object({ code: z.string().min(1), message: z.string().min(1) }).strict()
+  }).strict()
+]);
+var AgentControlDeliverySchema = z.discriminatedUnion("type", [
+  z.object({
+    schemaVersion: z.literal(1),
+    type: z.literal("event"),
+    event: AgentRuntimeEventSchema
+  }).strict(),
+  z.object({
+    schemaVersion: z.literal(1),
+    type: z.literal("resync-required"),
+    conversationId: z.string().min(1),
+    reason: z.literal("overflow")
+  }).strict()
+]);
+var AgentMultiSessionCursorSchema = z.object({
+  conversations: z.record(z.string(), z.object({
+    snapshotVersion: z.int().nonnegative().optional(),
+    durableEventIds: z.array(z.string().min(1)).optional(),
+    runs: z.record(z.string(), z.object({ runtimeEpoch: z.string().min(1), sequence: z.int().nonnegative() }).strict())
+  }).strict())
+}).strict();
+function durable(event) {
+  return ["admission", "assistant-checkpoint", "run-state", "terminal"].includes(event.type);
+}
+function advanceAgentMultiSessionCursor(raw, event) {
+  const cursor = AgentMultiSessionCursorSchema.parse(raw);
+  const previous = cursor.conversations[event.conversationId] ?? { runs: {} };
+  if (durable(event)) {
+    const ids = previous.snapshotVersion === event.snapshotVersion ? previous.durableEventIds ?? [] : [];
+    if (previous.snapshotVersion !== undefined && event.snapshotVersion < previous.snapshotVersion || ids.includes(event.eventId)) {
+      return { status: "duplicate", cursor };
+    }
+    return {
+      status: "accepted",
+      cursor: {
+        conversations: {
+          ...cursor.conversations,
+          [event.conversationId]: {
+            ...previous,
+            snapshotVersion: event.snapshotVersion,
+            durableEventIds: [...ids, event.eventId]
+          }
+        }
+      }
+    };
+  }
+  const run = previous.runs[event.runId];
+  const sequence = run?.runtimeEpoch === event.runtimeEpoch ? run.sequence : undefined;
+  if (sequence !== undefined && event.sequence <= sequence)
+    return { status: "duplicate", cursor };
+  const expected = sequence === undefined ? 1 : sequence + 1;
+  return {
+    status: event.sequence === expected ? "accepted" : "gap",
+    cursor: {
+      conversations: {
+        ...cursor.conversations,
+        [event.conversationId]: {
+          ...previous,
+          runs: {
+            ...previous.runs,
+            [event.runId]: { runtimeEpoch: event.runtimeEpoch, sequence: event.sequence }
+          }
+        }
+      }
+    }
+  };
+}
+function createAgentControlView() {
+  return { cursor: { conversations: {} }, conversations: {} };
+}
+function reduceAgentControlSnapshot(view, rawSnapshot) {
+  const snapshot = AgentSnapshotSchema.parse(rawSnapshot);
+  const previous = view.cursor.conversations[snapshot.conversationId] ?? { runs: {} };
+  return {
+    cursor: {
+      conversations: {
+        ...view.cursor.conversations,
+        [snapshot.conversationId]: {
+          ...previous,
+          snapshotVersion: snapshot.version,
+          durableEventIds: []
+        }
+      }
+    },
+    conversations: {
+      ...view.conversations,
+      [snapshot.conversationId]: {
+        snapshot,
+        resyncRequired: false,
+        transientByRun: {}
+      }
+    }
+  };
+}
+function reduceAgentControlEvent(view, rawEvent) {
+  const event = AgentRuntimeEventSchema.parse(rawEvent);
+  const advanced = advanceAgentMultiSessionCursor(view.cursor, event);
+  if (advanced.status === "duplicate")
+    return view;
+  const current = view.conversations[event.conversationId] ?? {
+    resyncRequired: false,
+    transientByRun: {}
+  };
+  if (advanced.status === "gap") {
+    return {
+      cursor: advanced.cursor,
+      conversations: {
+        ...view.conversations,
+        [event.conversationId]: { ...current, resyncRequired: true }
+      }
+    };
+  }
+  const transient = current.transientByRun[event.runId] ?? { text: "", reasoning: "" };
+  const nextTransient = event.type === "assistant-delta" ? { ...transient, text: transient.text + event.textDelta } : event.type === "reasoning-delta" ? { ...transient, reasoning: transient.reasoning + event.textDelta } : transient;
+  const snapshotStale = durable(event) && current.snapshot?.version !== event.snapshotVersion;
+  const transientByRun = event.type === "terminal" ? Object.fromEntries(Object.entries(current.transientByRun).filter(([runId]) => runId !== event.runId)) : { ...current.transientByRun, [event.runId]: nextTransient };
+  return {
+    cursor: advanced.cursor,
+    conversations: {
+      ...view.conversations,
+      [event.conversationId]: {
+        ...current,
+        resyncRequired: current.resyncRequired || snapshotStale,
+        transientByRun
+      }
+    }
+  };
+}
+
+export { AgentControlRequestSchema, AgentControlResponseSchema, AgentControlDeliverySchema, AgentMultiSessionCursorSchema, advanceAgentMultiSessionCursor, createAgentControlView, reduceAgentControlSnapshot, reduceAgentControlEvent };