stitchkit 0.68.10 → 0.69.0

package/dist/agent-runtime-browser.js

@@ -1,3 +1,6 @@
+// src/agent-runtime/control-schema.ts
+import { z as z3 } from "zod";
+
 // src/agent-runtime/event-schema.ts
 import { z as z2 } from "zod";
 
@@ -47,6 +50,19 @@ var AgentToolResultPartSchema = z.object({
   outcome: z.enum(["success", "error", "interrupted"]),
   output: z.json().optional()
 });
+var AgentToolApprovalRequestPartSchema = z.object({
+  type: z.literal("tool-approval-request"),
+  approvalId: z.string().min(1),
+  callId: z.string().min(1),
+  isAutomatic: z.boolean().optional(),
+  signature: z.string().min(1).optional()
+});
+var AgentToolApprovalResponsePartSchema = z.object({
+  type: z.literal("tool-approval-response"),
+  approvalId: z.string().min(1),
+  approved: z.boolean(),
+  reason: z.string().min(1).optional()
+});
 var AgentOpaquePartSchema = z.object({
   type: z.literal("provider"),
   envelope: AgentProviderEnvelopeSchema
@@ -62,10 +78,18 @@ var AgentMessagePartSchema = z.discriminatedUnion("type", [
   AgentSourcePartSchema,
   AgentToolCallPartSchema,
   AgentToolResultPartSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
   AgentOpaquePartSchema,
   AgentControlPartSchema
 ]);
-var AgentMessageRoleSchema = z.enum(["user", "assistant", "system", "summary"]);
+var AgentMessageRoleSchema = z.enum([
+  "user",
+  "assistant",
+  "tool",
+  "system",
+  "summary"
+]);
 var AgentMessageStatusSchema = z.enum([
   "committed",
   "streaming",
@@ -378,11 +402,196 @@ function advanceAgentRuntimeEventCursor(rawCursor, event) {
 function agentDurableEventId(type, runId, snapshotVersion) {
   return `${runId}:${type}:${snapshotVersion}`;
 }
+
+// src/agent-runtime/control-schema.ts
+var AgentControlIdentitySchema = z3.object({ schemaVersion: z3.literal(1), requestId: z3.string().min(1) }).strict();
+var AgentControlRequestSchema = z3.discriminatedUnion("operation", [
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("attach"),
+    conversationId: z3.string().min(1),
+    access: z3.enum(["observe", "control"])
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("detach"),
+    conversationId: z3.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("snapshot"),
+    conversationId: z3.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("submit"),
+    conversationId: z3.string().min(1),
+    idempotencyKey: z3.string().min(1),
+    context: z3.unknown(),
+    parts: z3.array(AgentMessagePartSchema).min(1),
+    metadata: z3.unknown().optional()
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("interrupt"),
+    conversationId: z3.string().min(1),
+    runId: z3.string().min(1)
+  }),
+  AgentControlIdentitySchema.extend({
+    operation: z3.literal("respond-approval"),
+    conversationId: z3.string().min(1),
+    approvalId: z3.string().min(1),
+    approved: z3.boolean(),
+    reason: z3.string().min(1).optional(),
+    context: z3.unknown(),
+    metadata: z3.unknown().optional()
+  })
+]);
+var AgentControlResponseIdentitySchema = z3.object({
+  schemaVersion: z3.literal(1),
+  requestId: z3.string().min(1)
+});
+var AgentControlResponseSchema = z3.discriminatedUnion("outcome", [
+  AgentControlResponseIdentitySchema.extend({
+    outcome: z3.literal("ok"),
+    snapshot: AgentSnapshotSchema.optional(),
+    runId: z3.string().min(1).optional()
+  }).strict(),
+  AgentControlResponseIdentitySchema.extend({
+    outcome: z3.literal("error"),
+    error: z3.object({ code: z3.string().min(1), message: z3.string().min(1) }).strict()
+  }).strict()
+]);
+var AgentControlDeliverySchema = z3.discriminatedUnion("type", [
+  z3.object({
+    schemaVersion: z3.literal(1),
+    type: z3.literal("event"),
+    event: AgentRuntimeEventSchema
+  }).strict(),
+  z3.object({
+    schemaVersion: z3.literal(1),
+    type: z3.literal("resync-required"),
+    conversationId: z3.string().min(1),
+    reason: z3.literal("overflow")
+  }).strict()
+]);
+var AgentMultiSessionCursorSchema = z3.object({
+  conversations: z3.record(z3.string(), z3.object({
+    snapshotVersion: z3.int().nonnegative().optional(),
+    durableEventIds: z3.array(z3.string().min(1)).optional(),
+    runs: z3.record(z3.string(), z3.object({ runtimeEpoch: z3.string().min(1), sequence: z3.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 {
   AgentAdmissionEventSchema,
   AgentAssistantPlaceholderSchema,
   AgentCheckpointEventSchema,
+  AgentControlDeliverySchema,
   AgentControlPartSchema,
+  AgentControlRequestSchema,
+  AgentControlResponseSchema,
   AgentCostValueSchema,
   AgentFilePartSchema,
   AgentJsonObjectSchema,
@@ -390,6 +599,7 @@ export {
   AgentMessageRoleSchema,
   AgentMessageSchema,
   AgentMessageStatusSchema,
+  AgentMultiSessionCursorSchema,
   AgentOpaquePartSchema,
   AgentProvenanceSchema,
   AgentProviderEnvelopeSchema,
@@ -412,13 +622,19 @@ export {
   AgentTerminalReasonSchema,
   AgentTextPartSchema,
   AgentTimestampSchema,
+  AgentToolApprovalRequestPartSchema,
+  AgentToolApprovalResponsePartSchema,
   AgentToolCallPartSchema,
   AgentToolResultPartSchema,
   AgentToolStatusEventSchema,
   AgentTransientDeltaEventSchema,
   AgentUsageSchema,
   AgentUsageValueSchema,
+  advanceAgentMultiSessionCursor,
   advanceAgentRuntimeEventCursor,
   agentDurableEventId,
+  createAgentControlView,
+  reduceAgentControlEvent,
+  reduceAgentControlSnapshot,
   runStateForTerminalReason
 };

package/dist/agent-runtime-coding-tools.d.ts

@@ -0,0 +1,2 @@
+export { type AgentCodingArtifactStore, type AgentCodingToolAuthorization, AgentCodingToolAuthorizationSchema, type AgentCodingToolConfig, type AgentCodingToolDefinition, type AgentCodingToolLimits, AgentCodingToolLimitsSchema, createAgentCodingTools, } from './agent-runtime/coding-tools.js';
+//# sourceMappingURL=agent-runtime-coding-tools.d.ts.map

package/dist/agent-runtime-coding-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runtime-coding-tools.d.ts","sourceRoot":"","sources":["../src/agent-runtime-coding-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,4BAA4B,EACjC,kCAAkC,EAClC,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,qBAAqB,EAC1B,2BAA2B,EAC3B,sBAAsB,GACvB,MAAM,8BAA8B,CAAC"}