stitchkit 0.102.0 → 0.103.1

package/dist/entrypoints/agent-runtime/browser.js

@@ -1,3 +1,4 @@
+import"../../index-814xpr6d.js";
 import {
   AgentRecordIdSchema2,
   AgentRecordVersionSchema2,
@@ -62,10 +63,242 @@ import {
   reduceAgentControlSnapshot2,
   reduceAgentControlEvent2
 } from "../../index-n5yqxd3d.js";
+import {
+  AgentBrowserRequestSchema2,
+  agentControlRealtimeContract2
+} from "../../index-20yvtn9a.js";
+import"../../index-n53mswt3.js";
+import"../../index-pw99k9h5.js";
+import"../../index-4s0fep5q.js";
+import {
+  bindRealtimeClient2
+} from "../../index-r34mvse1.js";
+// src/agent-runtime/browser-controller.ts
+function refreshed(view, snapshot) {
+  const current = view.conversations[snapshot.conversationId];
+  if (Math.max(current?.snapshot?.version ?? 0, view.cursor.conversations[snapshot.conversationId]?.snapshotVersion ?? 0) > snapshot.version)
+    return view;
+  const next = reduceAgentControlSnapshot2(view, snapshot);
+  const transientByRun = Object.fromEntries(Object.entries(current?.transientByRun ?? {}).filter(([id]) => snapshot.runs.some((run) => run.id === id && ["running", "interrupt_requested"].includes(run.state))));
+  return {
+    ...next,
+    conversations: {
+      ...next.conversations,
+      [snapshot.conversationId]: { snapshot, resyncRequired: false, transientByRun }
+    }
+  };
+}
+function createAgentController(config) {
+  return new ConversationController(config);
+}
+
+class ConversationController {
+  config;
+  client;
+  timeoutMs;
+  maxEvents;
+  maxBytes;
+  maxPending;
+  state = {
+    status: "connecting",
+    view: createAgentControlView2()
+  };
+  listeners = new Set;
+  generation = 0;
+  closed = false;
+  busy = false;
+  buffered = [];
+  bufferedBytes = 0;
+  overflowed = false;
+  refreshScheduled = false;
+  refreshAttempts = 0;
+  tail = Promise.resolve();
+  pending = new Set;
+  offDelivery;
+  offConnection;
+  constructor(config) {
+    this.config = config;
+    this.client = bindRealtimeClient2(agentControlRealtimeContract2, config.transport);
+    this.timeoutMs = config.timeoutMs ?? 1e4;
+    this.maxEvents = config.maxBufferedEvents ?? 256;
+    this.maxBytes = config.maxBufferedBytes ?? 1048576;
+    this.maxPending = config.maxPendingRequests ?? 32;
+    for (const [name, value] of Object.entries({
+      timeoutMs: this.timeoutMs,
+      maxEvents: this.maxEvents,
+      maxBytes: this.maxBytes,
+      maxPending: this.maxPending
+    })) {
+      if (!Number.isSafeInteger(value) || value < 1)
+        throw new TypeError(`${name} must be a positive safe integer`);
+    }
+    if (!config.conversationId)
+      throw new TypeError("conversationId must not be empty");
+    this.offDelivery = this.client.on("agent:delivery", (delivery) => this.receive(delivery));
+    this.offConnection = this.client.onConnectionChange((connected) => this.changed(connected));
+    this.changed(this.client.connected);
+  }
+  getSnapshot = () => this.state;
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  update(next) {
+    this.state = next;
+    for (const listener of this.listeners)
+      listener();
+  }
+  failure(code, message) {
+    this.update({ ...this.state, status: "error", error: { code, message } });
+  }
+  apply(delivery) {
+    if (delivery.type === "event") {
+      this.update({
+        ...this.state,
+        view: reduceAgentControlEvent2(this.state.view, delivery.event)
+      });
+    } else {
+      this.failure("EVENT_OVERFLOW", "Reconnect the transport to restore agent state");
+    }
+  }
+  scheduleRefresh() {
+    if (this.refreshScheduled || this.busy || this.pending.size >= this.maxPending || this.state.status !== "ready" || !this.state.view.conversations[this.config.conversationId]?.resyncRequired)
+      return;
+    this.refreshScheduled = true;
+    queueMicrotask(() => {
+      this.refreshScheduled = false;
+      if (!this.closed && this.state.status === "ready") {
+        if (++this.refreshAttempts > 3) {
+          this.failure("RESYNC_EXHAUSTED", "Snapshot did not catch up; refresh explicitly to retry");
+          return;
+        }
+        this.request({ operation: "snapshot" }).catch(() => {});
+      }
+    });
+  }
+  async execute(command, epoch) {
+    if (this.closed || epoch !== this.generation || !this.client.connected)
+      throw new Error("Agent controller is disconnected");
+    this.busy = true;
+    const requestId = crypto.randomUUID();
+    try {
+      const response = await this.client.request("agent:control", {
+        ...command,
+        schemaVersion: 1,
+        requestId,
+        conversationId: this.config.conversationId
+      }, { timeoutMs: this.timeoutMs });
+      if (this.closed || epoch !== this.generation)
+        throw new Error("Agent controller connection changed");
+      if (response.requestId !== requestId)
+        throw new Error("Agent control acknowledgement identity mismatch");
+      if (response.outcome === "error") {
+        this.failure(response.error.code, response.error.message);
+        return response;
+      }
+      if (response.snapshot) {
+        if (response.snapshot.conversationId !== this.config.conversationId)
+          throw new Error("Agent snapshot conversation mismatch");
+        this.update({ status: "ready", view: refreshed(this.state.view, response.snapshot) });
+        if (!this.state.view.conversations[this.config.conversationId]?.resyncRequired)
+          this.refreshAttempts = 0;
+      }
+      if (command.operation === "detach")
+        this.update({ ...this.state, status: "disconnected" });
+      return response;
+    } catch (error) {
+      if (!this.closed && epoch === this.generation)
+        this.failure("CONTROL_REQUEST_FAILED", error instanceof Error ? error.message : "Agent request failed");
+      throw error;
+    } finally {
+      if (epoch === this.generation) {
+        this.busy = false;
+        const deliveries = this.buffered;
+        this.buffered = [];
+        this.bufferedBytes = 0;
+        for (const delivery of deliveries)
+          this.apply(delivery);
+        if (this.overflowed) {
+          this.overflowed = false;
+          this.failure("EVENT_OVERFLOW", "Refresh agent state before continuing");
+        }
+      }
+    }
+  }
+  request(command) {
+    if (this.closed || this.pending.size >= this.maxPending)
+      return Promise.reject(new Error(this.closed ? "Agent controller is closed" : "Agent request capacity exceeded"));
+    const entry = {};
+    this.pending.add(entry);
+    const epoch = this.generation;
+    const result = this.tail.then(() => this.execute(command, epoch)).finally(() => {
+      this.pending.delete(entry);
+      this.scheduleRefresh();
+    });
+    this.tail = result.catch(() => {});
+    return result;
+  }
+  receive(delivery) {
+    const conversationId = delivery.type === "event" ? delivery.event.conversationId : delivery.conversationId;
+    if (this.closed || conversationId !== this.config.conversationId)
+      return;
+    if (this.busy) {
+      const bytes = new TextEncoder().encode(JSON.stringify(delivery)).byteLength;
+      if (this.overflowed || this.buffered.length >= this.maxEvents || this.bufferedBytes + bytes > this.maxBytes) {
+        this.overflowed = true;
+        this.buffered = [];
+        this.bufferedBytes = 0;
+      } else {
+        this.buffered.push(delivery);
+        this.bufferedBytes += bytes;
+      }
+    } else {
+      this.apply(delivery);
+      this.scheduleRefresh();
+    }
+  }
+  changed(connected) {
+    this.generation += 1;
+    this.busy = false;
+    this.buffered = [];
+    this.bufferedBytes = 0;
+    this.overflowed = false;
+    this.refreshAttempts = 0;
+    this.tail = Promise.resolve();
+    this.update({
+      status: connected ? "connecting" : "disconnected",
+      view: createAgentControlView2()
+    });
+    if (connected)
+      this.request({ operation: "attach", access: this.config.access }).catch(() => {});
+  }
+  async close() {
+    if (this.closed)
+      return;
+    this.closed = true;
+    this.generation += 1;
+    this.offDelivery();
+    this.offConnection();
+    this.update({ ...this.state, status: "closed" });
+    if (this.client.connected) {
+      const response = await this.client.request("agent:control", {
+        schemaVersion: 1,
+        requestId: crypto.randomUUID(),
+        operation: "detach",
+        conversationId: this.config.conversationId
+      }, { timeoutMs: this.timeoutMs });
+      if (response.outcome === "error" && !["CONNECTION_CLOSED", "ACCESS_DENIED"].includes(response.error.code))
+        throw new Error(`Agent detach failed: ${response.error.code}`);
+    }
+  }
+}
 export {
   AgentAdmissionEventSchema2 as AgentAdmissionEventSchema,
   AgentAssistantPlaceholderSchema2 as AgentAssistantPlaceholderSchema,
   AgentAttemptResetEventSchema2 as AgentAttemptResetEventSchema,
+  AgentBrowserRequestSchema2 as AgentBrowserRequestSchema,
   AgentCheckpointEventSchema2 as AgentCheckpointEventSchema,
   AgentControlDeliverySchema2 as AgentControlDeliverySchema,
   AgentControlPartSchema2 as AgentControlPartSchema,
@@ -116,8 +349,10 @@ export {
   AgentUsageValueSchema2 as AgentUsageValueSchema,
   advanceAgentMultiSessionCursor2 as advanceAgentMultiSessionCursor,
   advanceAgentRuntimeEventCursor2 as advanceAgentRuntimeEventCursor,
+  agentControlRealtimeContract2 as agentControlRealtimeContract,
   agentDurableEventId2 as agentDurableEventId,
   createAgentControlView2 as createAgentControlView,
+  createAgentController,
   reduceAgentControlEvent2 as reduceAgentControlEvent,
   reduceAgentControlSnapshot2 as reduceAgentControlSnapshot,
   runStateForTerminalReason2 as runStateForTerminalReason

package/dist/entrypoints/agent-runtime/harness-tools.d.ts

@@ -0,0 +1,2 @@
+export { type AgentHarnessToolsConfig, createAgentHarnessTools, } from '../../agent-runtime/harness-tools.js';
+//# sourceMappingURL=harness-tools.d.ts.map

package/dist/entrypoints/agent-runtime/harness-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness-tools.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/agent-runtime/harness-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,uBAAuB,EAC5B,uBAAuB,GACxB,MAAM,mCAAmC,CAAC"}

package/dist/entrypoints/agent-runtime/harness-tools.js

@@ -0,0 +1,32 @@
+import"../../index-nggfa2yn.js";
+import"../../index-n53mswt3.js";
+import"../../index-b2bz0kdm.js";
+import"../../index-yex7eg1v.js";
+import"../../index-9pw0a51a.js";
+import"../../index-ct75c3at.js";
+import"../../index-7z9ym7t8.js";
+import"../../index-0efgsyav.js";
+import"../../index-kgmh97hf.js";
+import {
+  mountAgent2
+} from "../../index-xgc94hy6.js";
+import {
+  composeToolLifecycle2
+} from "../../index-ze1eph1k.js";
+import"../../index-x1dkwx5x.js";
+import"../../index-7n68nmc6.js";
+import"../../index-jzczzcsb.js";
+
+// src/agent-runtime/harness-tools.ts
+function createAgentHarnessTools(resolve) {
+  return async (run) => {
+    const { services, lifecycle, ...config } = await resolve(run);
+    return mountAgent2(services, {
+      ...config,
+      lifecycle: composeToolLifecycle2(lifecycle, run.toolFenceLifecycle)
+    });
+  };
+}
+export {
+  createAgentHarnessTools
+};

package/dist/entrypoints/agent-runtime/harness.js

@@ -3,29 +3,30 @@ import {
 } from "../../index-nx6eazt0.js";
 import"../../index-8kzct1d6.js";
 import {
-  createAgentRuntimeEventSink2,
   composeAgentPrompt2,
   createAgentRuntime2
-} from "../../index-zs4ms3th.js";
+} from "../../index-z3pqcy7r.js";
 import"../../index-h97tqqp1.js";
 import"../../index-mnkk1ffz.js";
 import"../../index-n53mswt3.js";
 import"../../index-b2bz0kdm.js";
-import"../../index-hby4qhax.js";
+import"../../index-yex7eg1v.js";
 import"../../index-9pw0a51a.js";
 import"../../index-ct75c3at.js";
 import"../../index-7z9ym7t8.js";
-import"../../index-dvwj1f43.js";
-import"../../index-a9pd417t.js";
+import"../../index-0efgsyav.js";
+import"../../index-5vyd0fkb.js";
+import"../../index-nggfa2yn.js";
 import"../../index-r5hsgkz5.js";
+import"../../index-n5yqxd3d.js";
 import {
-  AgentControlRequestSchema2,
-  AgentControlResponseSchema2
-} from "../../index-n5yqxd3d.js";
+  createAgentHarnessControlServer2
+} from "../../index-jn9g8xdt.js";
+import"../../index-vgkbcnkc.js";
 import {
   walkContainedFiles
 } from "../../index-ej331hah.js";
-import"../../index-r1z0rd9c.js";
+import"../../index-7n68nmc6.js";
 import {
   defineRuntimeTool2
 } from "../../index-jzczzcsb.js";
@@ -264,222 +265,6 @@ function createAgentHarnessFileResources(config) {
   });
   return { load, runtimeTools: [readResource] };
 }
-// 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 createAgentHarnessControlServer(harness, config = {}) {
-  const maxPendingAttachments = config.maxPendingAttachments ?? 32;
-  if (!Number.isSafeInteger(maxPendingAttachments) || maxPendingAttachments <= 0) {
-    throw new TypeError("maxPendingAttachments must be a positive safe integer");
-  }
-  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 = {
-        attached: new Map,
-        pendingAttachments: 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"
-            });
-            detach(id);
-          }
-        })
-      };
-      connections.set(id, state);
-      return {
-        async request(raw) {
-          const request = AgentControlRequestSchema2.parse(raw);
-          const fail = (code, message) => AgentControlResponseSchema2.parse({
-            schemaVersion: 1,
-            requestId: request.requestId,
-            outcome: "error",
-            error: { 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) {
-                  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");
-              }
-              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 (state.pendingAttachments.has(request.conversationId)) {
-              return fail("ATTACH_IN_PROGRESS", "Wait for the current attachment request to settle");
-            }
-            if (request.operation === "detach") {
-              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.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);
-    }
-  };
-}
 
 // src/agent-runtime/harness.ts
 class AgentHarnessApprovalRejectedError extends Error {
@@ -727,7 +512,7 @@ export {
   AgentHarnessResourceDiagnosticSchema,
   AgentHarnessResourceKindSchema,
   AgentHarnessResourceSchema,
-  createAgentHarnessControlServer,
+  createAgentHarnessControlServer2 as createAgentHarnessControlServer,
   createAgentHarnessFileResources,
   createHeadlessAgentHarness
 };

package/dist/entrypoints/agent-runtime/react.d.ts

@@ -0,0 +1,2 @@
+export { useAgent } from '../../agent-runtime/react.js';
+//# sourceMappingURL=react.d.ts.map

package/dist/entrypoints/agent-runtime/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/agent-runtime/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC"}

package/dist/entrypoints/agent-runtime/react.js

@@ -0,0 +1,8 @@
+// src/agent-runtime/react.ts
+import { useSyncExternalStore } from "react";
+function useAgent(controller) {
+  return useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
+}
+export {
+  useAgent
+};

package/dist/entrypoints/agent-runtime/realtime.d.ts

@@ -0,0 +1,2 @@
+export { type AgentHarnessRealtimeConfig, bindAgentHarnessRealtime, } from '../../agent-runtime/harness-realtime.js';
+//# sourceMappingURL=realtime.d.ts.map

package/dist/entrypoints/agent-runtime/realtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtime.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/agent-runtime/realtime.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,0BAA0B,EAC/B,wBAAwB,GACzB,MAAM,sCAAsC,CAAC"}