stitchkit 0.103.0 → 0.103.2

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-kmpzj1cq.js

@@ -0,0 +1,48 @@
+import {
+  collectToolSurface
+} from "./index-dnn9z96q.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-dvwj1f43.js → index-m2xqkv55.js}

@@ -15,11 +15,11 @@ import {
   applyToolViewDefaults,
   projectToolView,
   objectShapeKeys
-} from "./index-7z9ym7t8.js";
+} from "./index-x87j7csh.js";
 import {
   runWithRequestContext2,
   getRequestContext2
-} from "./index-r1z0rd9c.js";
+} from "./index-7n68nmc6.js";
 import {
   formatZodError2
 } from "./index-1eeqpadm.js";

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

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

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

package/dist/index-r34mvse1.js

@@ -0,0 +1,225 @@
+import {
+  parseRealtimeRequestArguments,
+  parseRealtimeRequestAcknowledgement,
+  createValidatedRealtimeSocket
+} from "./index-pw99k9h5.js";
+import {
+  randomHex
+} from "./index-c9d05kvt.js";
+
+// src/browser/socket-io-trace.ts
+var realtimeRequestTraces = new WeakMap;
+function observeRealtimeRequestPhase(trace, phase) {
+  const observation = {
+    requestId: trace.requestId,
+    event: trace.event,
+    phase,
+    elapsedMs: performance.now() - trace.startedAt
+  };
+  const observers = trace.observeRequest && trace.observeRequest !== trace.observeClient ? [trace.observeClient, trace.observeRequest] : [trace.observeClient ?? trace.observeRequest];
+  for (const observer of observers) {
+    if (!observer)
+      continue;
+    try {
+      const result = observer(observation);
+      if (result)
+        Promise.resolve(result).catch(() => {
+          return;
+        });
+    } catch {}
+  }
+}
+function socketIoPacketIdentity(data, expected) {
+  if (typeof data !== "string")
+    return null;
+  const type = data.charAt(0);
+  const binary = type === (expected === "event" ? "5" : "6");
+  if (type !== (expected === "event" ? "2" : "3") && !binary)
+    return null;
+  let offset = 1;
+  if (binary) {
+    const separator = data.indexOf("-", offset);
+    if (separator < 0)
+      return null;
+    for (let index = offset;index < separator; index += 1) {
+      const code = data.charCodeAt(index);
+      if (code < 48 || code > 57)
+        return null;
+    }
+    offset = separator + 1;
+  }
+  let namespace = "/";
+  if (data.charAt(offset) === "/") {
+    const separator = data.indexOf(",", offset);
+    if (separator < 0)
+      return null;
+    namespace = data.slice(offset, separator);
+    offset = separator + 1;
+  }
+  const start = offset;
+  while (offset < data.length) {
+    const code = data.charCodeAt(offset);
+    if (code < 48 || code > 57)
+      break;
+    offset += 1;
+  }
+  if (offset === start)
+    return null;
+  return { namespace, id: data.slice(start, offset) };
+}
+function packetIdentityKey(identity) {
+  return `${identity.namespace}:${identity.id}`;
+}
+function createRequestTracer(onRequestPhase) {
+  const requestTracesByNativeKey = new Map;
+  const observedRequestEngines = new WeakSet;
+  let startingRequestTrace = null;
+  return {
+    start(event, onPhase) {
+      if (!onRequestPhase && !onPhase)
+        return;
+      const trace = {
+        requestId: randomHex(16),
+        event,
+        startedAt: performance.now(),
+        observeClient: onRequestPhase,
+        observeRequest: onPhase,
+        closed: false
+      };
+      return trace;
+    },
+    close(trace, phase) {
+      if (!trace || trace.closed)
+        return;
+      trace.closed = true;
+      if (trace.nativeKey)
+        requestTracesByNativeKey.delete(trace.nativeKey);
+      observeRealtimeRequestPhase(trace, phase);
+    },
+    starting(trace, emit) {
+      startingRequestTrace = trace ?? null;
+      try {
+        return emit();
+      } finally {
+        startingRequestTrace = null;
+      }
+    },
+    observeEachOpen(target, current) {
+      if (!onRequestPhase)
+        return;
+      target.io.on("open", () => {
+        const socket = current();
+        if (socket)
+          this.observe(socket);
+      });
+    },
+    observe(target) {
+      const engine = target.io.engine;
+      if (!engine || observedRequestEngines.has(engine))
+        return;
+      observedRequestEngines.add(engine);
+      engine.on("packetCreate", (packet) => {
+        if (!startingRequestTrace || packet.type !== "message")
+          return;
+        const identity = socketIoPacketIdentity(packet.data, "event");
+        if (!identity)
+          return;
+        const key = packetIdentityKey(identity);
+        startingRequestTrace.nativeKey = key;
+        requestTracesByNativeKey.set(key, startingRequestTrace);
+        observeRealtimeRequestPhase(startingRequestTrace, "engine-handoff");
+      });
+      engine.on("packet", (packet) => {
+        if (packet.type !== "message")
+          return;
+        const identity = socketIoPacketIdentity(packet.data, "ack");
+        if (!identity)
+          return;
+        const key = packetIdentityKey(identity);
+        const trace = requestTracesByNativeKey.get(key);
+        if (!trace || trace.closed)
+          return;
+        observeRealtimeRequestPhase(trace, "engine-ack-received");
+        requestTracesByNativeKey.delete(key);
+      });
+    }
+  };
+}
+
+// src/browser/realtime-client.ts
+function assertRealtimeClientTransport(transport) {
+  for (const capability of ["on", "emit", "emitWithAck", "onConnectionChange"]) {
+    if (typeof Reflect.get(transport, capability) !== "function") {
+      throw new TypeError(`Realtime client transport does not implement ${capability}()`);
+    }
+  }
+  if (typeof transport.connected !== "boolean") {
+    throw new TypeError("Realtime client transport does not expose boolean connected");
+  }
+}
+function bindRealtimeClient2(contract, transport, { onRejected, logger } = {}) {
+  assertRealtimeClientTransport(transport);
+  const events = createValidatedRealtimeSocket({
+    target: transport,
+    inbound: contract.serverToClient,
+    outbound: contract.clientToServer,
+    inboundDirection: "client-inbound",
+    outboundDirection: "client-outbound",
+    onRejected,
+    logger,
+    subscribe: (event, handler) => {
+      const subscribe = Reflect.get(transport, "on");
+      if (typeof subscribe !== "function") {
+        throw new Error("Socket.IO client does not implement on()");
+      }
+      const unsubscribe = Reflect.apply(subscribe, transport, [event, handler]);
+      if (typeof unsubscribe !== "function") {
+        throw new Error("Socket.IO client on() did not return an unsubscribe function");
+      }
+      return () => {
+        Reflect.apply(unsubscribe, undefined, []);
+      };
+    }
+  });
+  async function request(event, ...args) {
+    const options = args.at(-1);
+    if (!options || typeof options !== "object" || !("timeoutMs" in options)) {
+      throw new TypeError(`Realtime request "${event}" requires { timeoutMs }`);
+    }
+    const timeoutMs = options.timeoutMs;
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new RangeError(`Realtime request "${event}" timeoutMs must be finite and > 0`);
+    }
+    const values = args.slice(0, -1);
+    const parsedArgs = parseRealtimeRequestArguments(contract.clientToServer, event, "client-outbound", values);
+    const definition = contract.clientToServer[event];
+    if (!definition?.ack) {
+      throw new Error(`Realtime request "${event}" has no acknowledgement schema`);
+    }
+    const pending = transport.emitWithAck(event, parsedArgs, options);
+    const trace = realtimeRequestTraces.get(pending);
+    if (trace)
+      realtimeRequestTraces.delete(pending);
+    const value = await pending;
+    let acknowledgement;
+    try {
+      acknowledgement = parseRealtimeRequestAcknowledgement(definition.ack, event, "client-inbound", value, onRejected, logger);
+    } finally {
+      if (trace && !trace.closed) {
+        trace.closed = true;
+        observeRealtimeRequestPhase(trace, "settled");
+      }
+    }
+    return acknowledgement;
+  }
+  return {
+    ...events,
+    get connected() {
+      return transport.connected;
+    },
+    request,
+    onConnectionChange: (listener) => transport.onConnectionChange(listener)
+  };
+}
+
+export { realtimeRequestTraces, createRequestTracer, bindRealtimeClient2 };

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

@@ -6,11 +6,11 @@ import {
   mergeSchemas,
   assertToolExtensionCompatible,
   projectToolSurface
-} from "./index-7z9ym7t8.js";
+} from "./index-x87j7csh.js";
 import {
   toolErrorFromResult,
   executeToolMethod
-} from "./index-dvwj1f43.js";
+} from "./index-m2xqkv55.js";
 
 // src/tools/mount.ts
 import { z } from "zod";

package/dist/index-srs8hj9c.js

@@ -0,0 +1,10 @@
+// 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 { isModuleNotFound };

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

@@ -1,6 +1,6 @@
 import {
   projectRuntimeTool
-} from "./index-7z9ym7t8.js";
+} from "./index-x87j7csh.js";
 
 // src/tools/runtime-tool.ts
 function defineRuntimeTool2(definition) {