stitchkit 0.103.0 → 0.103.1

package/dist/index-20yvtn9a.js

@@ -0,0 +1,38 @@
+import {
+  defineRealtimeContract2
+} from "./index-814xpr6d.js";
+import {
+  AgentTextPartSchema2,
+  AgentFilePartSchema2
+} from "./index-8kzct1d6.js";
+import {
+  AgentControlRequestSchema2,
+  AgentControlResponseSchema2,
+  AgentControlDeliverySchema2
+} from "./index-n5yqxd3d.js";
+
+// src/agent-runtime/browser-control-contract.ts
+import { z } from "zod";
+var AgentBrowserRequestSchema2 = z.discriminatedUnion("operation", [
+  AgentControlRequestSchema2.options[0],
+  AgentControlRequestSchema2.options[1],
+  AgentControlRequestSchema2.options[2],
+  AgentControlRequestSchema2.options[3].omit({ context: true }).extend({
+    parts: z.array(z.union([AgentTextPartSchema2.strict(), AgentFilePartSchema2.strict()])).min(1)
+  }),
+  AgentControlRequestSchema2.options[4],
+  AgentControlRequestSchema2.options[5].omit({ context: true })
+]);
+var agentControlRealtimeContract2 = defineRealtimeContract2({
+  serverToClient: {
+    "agent:delivery": { args: z.tuple([AgentControlDeliverySchema2]) }
+  },
+  clientToServer: {
+    "agent:control": {
+      args: z.tuple([AgentBrowserRequestSchema2]),
+      ack: AgentControlResponseSchema2
+    }
+  }
+});
+
+export { AgentBrowserRequestSchema2, agentControlRealtimeContract2 };

package/dist/{index-a9pd417t.js → index-5vyd0fkb.js}

@@ -639,37 +639,4 @@ function createLocalStepDurability2(options) {
   };
 }
 
-// src/tools/agent-tool-error.ts
-var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
-
-class AgentToolError2 extends Error {
-  output;
-  constructor(output, cause) {
-    let message = "Tool execution failed";
-    try {
-      message = JSON.stringify(output);
-    } catch {}
-    super(message, cause === undefined ? undefined : { cause });
-    this.name = "AgentToolError";
-    this.output = output;
-    Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
-  }
-}
-function isAgentToolError2(value) {
-  return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
-}
-
-// src/tools/durability-context.ts
-var contexts = new WeakMap;
-function createToolDurabilityContext(factory) {
-  const context = {};
-  contexts.set(context, factory);
-  return context;
-}
-function resolveToolDurability(context, callId, signal) {
-  if (typeof context !== "object" || context === null)
-    return;
-  return contexts.get(context)?.(callId, signal);
-}
-
-export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2, AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };
+export { DURABILITY_STEP_EVENT_KIND2, StepResultDecodeError2, StepResultNotSerializableError2, StepAbortedError2, EffectUnresolvedError2, ParkRecordDecodeError2, ParkAbortedError2, createLocalStepDurability2 };

package/dist/{index-r1z0rd9c.js → index-7n68nmc6.js}

@@ -1,6 +1,6 @@
 import {
   resolveTraceContext2
-} from "./index-hby4qhax.js";
+} from "./index-yex7eg1v.js";
 import {
   resolveSocketIp2,
   getClientInfo2

package/dist/index-860vjkgm.js

@@ -0,0 +1,48 @@
+import {
+  collectToolSurface
+} from "./index-x1dkwx5x.js";
+
+// src/tools/manifest.ts
+function utf8Length(value) {
+  return new TextEncoder().encode(JSON.stringify(value)).byteLength;
+}
+function describeToolCatalog2(config) {
+  const deferred = new Set(config.deferredNames ?? []);
+  const entries = collectToolSurface({
+    surface: config,
+    transport: config.transport,
+    extend: config.extend,
+    flattenUnionInput: config.flattenUnionInput
+  }).map(({ kind, service, action, mountable }) => {
+    const schemaBytes = utf8Length(mountable.presentationSchema);
+    return {
+      name: mountable.name,
+      description: mountable.method.desc,
+      inputSchema: mountable.presentationSchema,
+      source: { kind, service, action },
+      schemaBytes,
+      deferred: deferred.has(mountable.name)
+    };
+  });
+  if (config.maxSchemaBytes !== undefined) {
+    const total = entries.reduce((sum, entry) => sum + entry.schemaBytes, 0);
+    if (total > config.maxSchemaBytes) {
+      throw new TypeError(`Tool catalog schemas use ${total} bytes, exceeding maxSchemaBytes ${config.maxSchemaBytes}`);
+    }
+  }
+  return entries;
+}
+function buildToolManifest2(config) {
+  return collectToolSurface({
+    surface: config,
+    transport: config.transport,
+    extend: config.extend,
+    flattenUnionInput: config.flattenUnionInput
+  }).map(({ mountable }) => ({
+    name: mountable.name,
+    description: mountable.method.desc,
+    inputSchema: mountable.presentationSchema
+  }));
+}
+
+export { describeToolCatalog2, buildToolManifest2 };

package/dist/index-c9d05kvt.js

@@ -0,0 +1,11 @@
+// src/internal/random-hex.ts
+function randomHex(bytes) {
+  const arr = new Uint8Array(bytes);
+  crypto.getRandomValues(arr);
+  let hex = "";
+  for (const byte of arr)
+    hex += byte.toString(16).padStart(2, "0");
+  return hex;
+}
+
+export { randomHex };

package/dist/{index-m9fndta6.js → index-ds7jdhep.js}

@@ -3,14 +3,14 @@ import {
 } from "./index-n53mswt3.js";
 import {
   toolErrorFromResult
-} from "./index-dvwj1f43.js";
+} from "./index-0efgsyav.js";
 import {
   assertUniqueToolName
 } from "./index-7z9ym7t8.js";
 import {
   collectTools2,
   createToolRunner
-} from "./index-n9tyz8z3.js";
+} from "./index-kgmh97hf.js";
 
 // src/tools/invoker.ts
 function createToolInvoker2(services, config) {

package/dist/index-jn9g8xdt.js

@@ -0,0 +1,246 @@
+import {
+  AgentControlRequestSchema2,
+  AgentControlResponseSchema2
+} from "./index-n5yqxd3d.js";
+import {
+  createAgentRuntimeEventSink2
+} from "./index-vgkbcnkc.js";
+
+// src/agent-runtime/harness-control.ts
+async function runControlledOperation(harness, request) {
+  if (request.operation === "interrupt") {
+    await harness.interrupt({
+      conversationId: request.conversationId,
+      runId: request.runId
+    });
+    return AgentControlResponseSchema2.parse({
+      schemaVersion: 1,
+      requestId: request.requestId,
+      outcome: "ok",
+      snapshot: await harness.snapshot(request.conversationId)
+    });
+  }
+  if (request.operation === "respond-approval") {
+    const ticket = await harness.respondToApproval({
+      conversationId: request.conversationId,
+      approvalId: request.approvalId,
+      approved: request.approved,
+      ...request.reason && { reason: request.reason },
+      context: request.context,
+      ...request.metadata !== undefined && { metadata: request.metadata }
+    });
+    const admission = await ticket.admission;
+    return AgentControlResponseSchema2.parse({
+      schemaVersion: 1,
+      requestId: request.requestId,
+      outcome: "ok",
+      runId: admission.runId,
+      snapshot: await harness.snapshot(request.conversationId)
+    });
+  }
+  const ticket = harness.submit({
+    conversationId: request.conversationId,
+    idempotencyKey: request.idempotencyKey,
+    context: request.context,
+    parts: request.parts,
+    ...request.metadata !== undefined && { metadata: request.metadata }
+  });
+  const admission = await ticket.admission;
+  return AgentControlResponseSchema2.parse({
+    schemaVersion: 1,
+    requestId: request.requestId,
+    outcome: "ok",
+    runId: admission.runId,
+    snapshot: await harness.snapshot(request.conversationId)
+  });
+}
+function controlFailure(requestId, code, message) {
+  return AgentControlResponseSchema2.parse({
+    schemaVersion: 1,
+    requestId,
+    outcome: "error",
+    error: { code, message }
+  });
+}
+function attachmentLimit(config) {
+  const limit = config.maxPendingAttachments ?? 32;
+  if (!Number.isSafeInteger(limit) || limit <= 0)
+    throw new TypeError("maxPendingAttachments must be a positive safe integer");
+  return limit;
+}
+function connectionState(config, {
+  deliver,
+  onOverflow
+}, disconnect) {
+  const state = {
+    attached: new Map,
+    pendingAttachments: new Set,
+    cancelledAttachments: new Set,
+    overflowed: false,
+    sink: createAgentRuntimeEventSink2({
+      write: (event) => deliver({ schemaVersion: 1, type: "event", event }),
+      maxPending: config.maxPendingEvents ?? 128,
+      onDrop: ({ event }) => {
+        if (state.overflowed)
+          return;
+        state.overflowed = true;
+        onOverflow({
+          schemaVersion: 1,
+          type: "resync-required",
+          conversationId: event.conversationId,
+          reason: "overflow"
+        });
+        disconnect();
+      }
+    })
+  };
+  return state;
+}
+function createAgentHarnessControlServer2(harness, config = {}) {
+  const maxPendingAttachments = attachmentLimit(config);
+  const connections = new Map;
+  const controllers = new Map;
+  let pendingAttachments = 0;
+  let closed = false;
+  const unsubscribe = harness.subscribe((event) => {
+    for (const connection of connections.values()) {
+      if (connection.attached.has(event.conversationId) && !connection.overflowed) {
+        connection.sink.publish(event);
+      }
+    }
+  });
+  const detach = (connectionId) => {
+    const connection = connections.get(connectionId);
+    if (!connection)
+      return;
+    for (const conversationId of connection.attached.keys()) {
+      if (controllers.get(conversationId) === connectionId) {
+        controllers.delete(conversationId);
+      }
+    }
+    connection.sink.close();
+    connections.delete(connectionId);
+  };
+  return {
+    connect({ id, deliver, onOverflow }) {
+      if (closed)
+        throw new Error("Agent harness control server is closed");
+      if (connections.has(id))
+        throw new Error("Agent harness control connection id is duplicate");
+      const state = connectionState(config, { deliver, onOverflow }, () => detach(id));
+      connections.set(id, state);
+      return {
+        async request(raw) {
+          const request = AgentControlRequestSchema2.parse(raw);
+          const fail = (code, message) => controlFailure(request.requestId, code, message);
+          if (closed || connections.get(id) !== state)
+            return fail("CONNECTION_CLOSED", "Connection is closed");
+          try {
+            if (request.operation === "attach") {
+              if (state.pendingAttachments.has(request.conversationId)) {
+                return fail("ATTACH_IN_PROGRESS", "Wait for the current attachment request to settle");
+              }
+              if (pendingAttachments >= maxPendingAttachments) {
+                return fail("ATTACHMENT_CAPACITY", "Too many attachment snapshots are pending on this control server");
+              }
+              const owner = controllers.get(request.conversationId);
+              if (request.access === "control" && owner && owner !== id) {
+                return fail("LEASE_CONFLICT", "Conversation already has a controller");
+              }
+              const previousAccess = state.attached.get(request.conversationId);
+              const previousController = controllers.get(request.conversationId);
+              pendingAttachments += 1;
+              state.pendingAttachments.add(request.conversationId);
+              if (!previousAccess)
+                state.attached.set(request.conversationId, request.access);
+              if (request.access === "control")
+                controllers.set(request.conversationId, id);
+              let snapshot;
+              try {
+                snapshot = await harness.snapshot(request.conversationId);
+              } catch (error) {
+                if (connections.get(id) === state && !state.cancelledAttachments.delete(request.conversationId)) {
+                  if (previousAccess)
+                    state.attached.set(request.conversationId, previousAccess);
+                  else
+                    state.attached.delete(request.conversationId);
+                  if (request.access === "control" && controllers.get(request.conversationId) === id && previousController) {
+                    controllers.set(request.conversationId, previousController);
+                  } else if (request.access === "control" && controllers.get(request.conversationId) === id) {
+                    controllers.delete(request.conversationId);
+                  }
+                }
+                throw error;
+              } finally {
+                pendingAttachments -= 1;
+                state.pendingAttachments.delete(request.conversationId);
+              }
+              if (closed || connections.get(id) !== state) {
+                return fail("CONNECTION_CLOSED", "Connection is closed");
+              }
+              if (state.cancelledAttachments.delete(request.conversationId)) {
+                return fail("ATTACH_CANCELLED", "Attachment was detached while its snapshot was pending");
+              }
+              state.attached.set(request.conversationId, request.access);
+              if (request.access === "observe" && controllers.get(request.conversationId) === id) {
+                controllers.delete(request.conversationId);
+              }
+              return AgentControlResponseSchema2.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok",
+                snapshot
+              });
+            }
+            if (request.operation === "detach") {
+              if (state.pendingAttachments.has(request.conversationId)) {
+                state.cancelledAttachments.add(request.conversationId);
+              }
+              if (controllers.get(request.conversationId) === id)
+                controllers.delete(request.conversationId);
+              state.attached.delete(request.conversationId);
+              return AgentControlResponseSchema2.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok"
+              });
+            }
+            if (state.pendingAttachments.has(request.conversationId)) {
+              return fail("ATTACH_IN_PROGRESS", "Wait for the current attachment request to settle");
+            }
+            if (!state.attached.has(request.conversationId))
+              return fail("NOT_ATTACHED", "Attach before requesting conversation state");
+            if (request.operation === "snapshot") {
+              const snapshot = await harness.snapshot(request.conversationId);
+              return AgentControlResponseSchema2.parse({
+                schemaVersion: 1,
+                requestId: request.requestId,
+                outcome: "ok",
+                snapshot
+              });
+            }
+            if (state.attached.get(request.conversationId) !== "control" || controllers.get(request.conversationId) !== id) {
+              return fail("LEASE_REQUIRED", "An active controller lease is required");
+            }
+            return await runControlledOperation(harness, request);
+          } catch {
+            return fail("REQUEST_REJECTED", "Control request was rejected");
+          }
+        },
+        close() {
+          detach(id);
+        }
+      };
+    },
+    close() {
+      if (closed)
+        return;
+      closed = true;
+      unsubscribe();
+      for (const id of [...connections.keys()])
+        detach(id);
+    }
+  };
+}
+
+export { createAgentHarnessControlServer2 };

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

@@ -10,7 +10,7 @@ import {
 import {
   toolErrorFromResult,
   executeToolMethod
-} from "./index-dvwj1f43.js";
+} from "./index-0efgsyav.js";
 
 // src/tools/mount.ts
 import { z } from "zod";

package/dist/{index-c6aagrbd.js → index-kkk1wzsq.js}

@@ -4,7 +4,7 @@ import {
 import {
   toolResultFromError,
   toolErrorFromResult
-} from "./index-dvwj1f43.js";
+} from "./index-0efgsyav.js";
 import {
   coerceJsonArgs2
 } from "./index-9pw0a51a.js";
@@ -19,13 +19,13 @@ import {
 import {
   createToolRunner,
   formatToolError
-} from "./index-n9tyz8z3.js";
+} from "./index-kgmh97hf.js";
 import {
   isWithinDir2
 } from "./index-5cc6r990.js";
 import {
   collectToolSurface
-} from "./index-ewbaywk5.js";
+} from "./index-x1dkwx5x.js";
 import {
   formatZodError2
 } from "./index-1eeqpadm.js";

package/dist/index-nggfa2yn.js

@@ -0,0 +1,34 @@
+// src/tools/agent-tool-error.ts
+var AGENT_TOOL_ERROR_BRAND = Symbol.for("stitchkit.AgentToolError");
+
+class AgentToolError2 extends Error {
+  output;
+  constructor(output, cause) {
+    let message = "Tool execution failed";
+    try {
+      message = JSON.stringify(output);
+    } catch {}
+    super(message, cause === undefined ? undefined : { cause });
+    this.name = "AgentToolError";
+    this.output = output;
+    Object.defineProperty(this, AGENT_TOOL_ERROR_BRAND, { value: true });
+  }
+}
+function isAgentToolError2(value) {
+  return typeof value === "object" && value !== null && AGENT_TOOL_ERROR_BRAND in value;
+}
+
+// src/tools/durability-context.ts
+var contexts = new WeakMap;
+function createToolDurabilityContext(factory) {
+  const context = {};
+  contexts.set(context, factory);
+  return context;
+}
+function resolveToolDurability(context, callId, signal) {
+  if (typeof context !== "object" || context === null)
+    return;
+  return contexts.get(context)?.(callId, signal);
+}
+
+export { AgentToolError2, isAgentToolError2, createToolDurabilityContext, resolveToolDurability };

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

@@ -312,13 +312,4 @@ function createValidatedRealtimeSocket({
   };
 }
 
-// src/internal/optional-peer.ts
-function isModuleNotFound(error) {
-  if (typeof error !== "object" || error === null)
-    return false;
-  const code = "code" in error ? error.code : undefined;
-  const message = "message" in error && typeof error.message === "string" ? error.message : "";
-  return code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND" || message.includes("Cannot find module") || message.includes("Cannot find package");
-}
-
-export { REALTIME_REJECTION_KEY2, asRealtimeRejection2, parseRealtimeRequestArguments, parseRealtimeRequestAcknowledgement, createValidatedRealtimeSocket, isModuleNotFound };
+export { REALTIME_REJECTION_KEY2, asRealtimeRejection2, parseRealtimeRequestArguments, parseRealtimeRequestAcknowledgement, createValidatedRealtimeSocket };

package/dist/index-qapzv4p5.js

@@ -0,0 +1,54 @@
+import {
+  createValidatedRealtimeSocket
+} from "./index-pw99k9h5.js";
+
+// src/server/realtime.ts
+function bindRealtimeServer2(contract, handle, options = {}) {
+  const outbound = (target) => createValidatedRealtimeSocket({
+    target,
+    inbound: {},
+    outbound: contract.serverToClient,
+    inboundDirection: "server-inbound",
+    outboundDirection: "server-outbound",
+    onRejected: options.onRejected,
+    logger: options.logger
+  });
+  const broadcast = outbound(handle.io);
+  return {
+    onConnection: (handler) => {
+      const listener = (raw) => {
+        const events = createValidatedRealtimeSocket({
+          target: raw,
+          inbound: contract.clientToServer,
+          outbound: contract.serverToClient,
+          inboundDirection: "server-inbound",
+          outboundDirection: "server-outbound",
+          onRejected: options.onRejected,
+          logger: options.logger
+        });
+        const failed = (error) => {
+          try {
+            raw.disconnect(true);
+          } catch {}
+          if (options.logger)
+            options.logger.error("Realtime connection handler failed", { error });
+          else
+            console.error("[stitchkit] realtime connection handler failed", error);
+        };
+        try {
+          Promise.resolve(handler({ raw, events, to: (room) => outbound(raw.to(room)) })).catch(failed);
+        } catch (error) {
+          failed(error);
+        }
+      };
+      handle.io.on("connection", listener);
+      return () => {
+        handle.io.off("connection", listener);
+      };
+    },
+    emit: broadcast.emit,
+    to: (room) => outbound(handle.io.to(room))
+  };
+}
+
+export { bindRealtimeServer2 };