stitchkit 0.103.0 → 0.103.2

package/dist/agent-runtime/browser-control-contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-control-contract.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/browser-control-contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AASxB,wFAAwF;AACxF,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAWpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,4BAA4B;;QAEjB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAItB,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACJ,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGP,CAAC"}

package/dist/agent-runtime/browser-controller.d.ts

@@ -0,0 +1,31 @@
+import { type RealtimeClientTransport } from '../browser/realtime-client.js';
+import { type AgentBrowserRequest } from './browser-control-contract.js';
+import { type AgentControlResponse, type AgentControlView } from './control-schema.js';
+export interface AgentControllerConfig {
+    transport: RealtimeClientTransport;
+    conversationId: string;
+    access: 'observe' | 'control';
+    timeoutMs?: number;
+    maxBufferedEvents?: number;
+    maxBufferedBytes?: number;
+    maxPendingRequests?: number;
+}
+export interface AgentControllerState {
+    status: 'connecting' | 'ready' | 'disconnected' | 'error' | 'closed';
+    view: AgentControlView;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export type AgentBrowserCommand<T extends AgentBrowserRequest = AgentBrowserRequest> = T extends unknown ? Omit<T, 'schemaVersion' | 'requestId' | 'conversationId'> : never;
+export interface AgentController {
+    getSnapshot(): AgentControllerState;
+    subscribe(listener: () => void): () => void;
+    request(command: AgentBrowserCommand): Promise<AgentControlResponse>;
+    /** Release this attachment; the supplied transport and remote runtime remain application-owned. */
+    close(): Promise<void>;
+}
+/** One conversation over the existing realtime client; no transport or agent-loop ownership. */
+export declare function createAgentController(config: AgentControllerConfig): AgentController;
+//# sourceMappingURL=browser-controller.d.ts.map

package/dist/agent-runtime/browser-controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-controller.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/browser-controller.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAC9F,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAEL,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAC;AAG1B,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,uBAAuB,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,YAAY,GAAG,OAAO,GAAG,cAAc,GAAG,OAAO,GAAG,QAAQ,CAAC;IACrE,IAAI,EAAE,gBAAgB,CAAC;IACvB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CAC3C;AAED,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,mBAAmB,GAAG,mBAAmB,IACjF,CAAC,SAAS,OAAO,GAAG,IAAI,CAAC,CAAC,EAAE,eAAe,GAAG,WAAW,GAAG,gBAAgB,CAAC,GAAG,KAAK,CAAC;AAExF,MAAM,WAAW,eAAe;IAC9B,WAAW,IAAI,oBAAoB,CAAC;IACpC,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;IAC5C,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACrE,mGAAmG;IACnG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AA6BD,gGAAgG;AAChG,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,eAAe,CAEpF"}

package/dist/agent-runtime/harness-control.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"harness-control.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/harness-control.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EAExB,KAAK,oBAAoB,EAE1B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAG/D,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnE,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,KAAK,EAAE;QACb,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,oBAAoB,EAAE;YAAE,IAAI,EAAE,OAAO,CAAA;SAAE,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1F,qFAAqF;QACrF,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,oBAAoB,EAAE;YAAE,IAAI,EAAE,iBAAiB,CAAA;SAAE,CAAC,GAAG,IAAI,CAAC;KACxF,GAAG,6BAA6B,CAAC;IAClC,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,+BAA+B;IAC9C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AA8DD,wBAAgB,+BAA+B,CAAC,OAAO,EACrD,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,MAAM,GAAE,+BAAoC,GAC3C,yBAAyB,CAoM3B"}
+{"version":3,"file":"harness-control.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/harness-control.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EAExB,KAAK,oBAAoB,EAE1B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAG/D,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,KAAK,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnE,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,yBAAyB;IACxC,OAAO,CAAC,KAAK,EAAE;QACb,EAAE,EAAE,MAAM,CAAC;QACX,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,oBAAoB,EAAE;YAAE,IAAI,EAAE,OAAO,CAAA;SAAE,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1F,qFAAqF;QACrF,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,oBAAoB,EAAE;YAAE,IAAI,EAAE,iBAAiB,CAAA;SAAE,CAAC,GAAG,IAAI,CAAC;KACxF,GAAG,6BAA6B,CAAC;IAClC,KAAK,IAAI,IAAI,CAAC;CACf;AAED,MAAM,WAAW,+BAA+B;IAC9C,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,iFAAiF;IACjF,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAkHD,wBAAgB,+BAA+B,CAAC,OAAO,EACrD,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,MAAM,GAAE,+BAAoC,GAC3C,yBAAyB,CAsL3B"}

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

@@ -0,0 +1,25 @@
+import { type RealtimeServerHandle } from '../server/realtime.js';
+import { type AgentBrowserRequest } from './browser-control-contract.js';
+import type { HeadlessAgentHarness } from './harness-contract.js';
+import { type AgentHarnessControlServerConfig } from './harness-control.js';
+export interface AgentHarnessRealtimeConfig<IDENTITY, CONTEXT> extends AgentHarnessControlServerConfig {
+    /** Verify identity, conversation access and user-supplied file/metadata policy on EVERY call. */
+    authorize(input: {
+        identity: IDENTITY;
+        request: AgentBrowserRequest;
+        signal: AbortSignal;
+    }): {
+        context: CONTEXT;
+    } | null | Promise<{
+        context: CONTEXT;
+    } | null>;
+    /** Server-only diagnostic; raw authorization errors are never sent to a browser. */
+    onError?(error: unknown): void;
+    maxPendingRequests?: number;
+    authorizationTimeoutMs?: number;
+}
+/** Bind the canonical control server to an existing, application-owned Socket.IO server. */
+export declare function bindAgentHarnessRealtime<CONTEXT, IDENTITY>(harness: HeadlessAgentHarness<CONTEXT>, handle: RealtimeServerHandle<IDENTITY>, config: AgentHarnessRealtimeConfig<IDENTITY, CONTEXT>): {
+    close(): void;
+};
+//# sourceMappingURL=harness-realtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"harness-realtime.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/harness-realtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AACnF,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EACL,KAAK,+BAA+B,EAErC,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,0BAA0B,CAAC,QAAQ,EAAE,OAAO,CAC3D,SAAQ,+BAA+B;IACvC,iGAAiG;IACjG,SAAS,CAAC,KAAK,EAAE;QACf,QAAQ,EAAE,QAAQ,CAAC;QACnB,OAAO,EAAE,mBAAmB,CAAC;QAC7B,MAAM,EAAE,WAAW,CAAC;KACrB,GAAG;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC,CAAC;IACvE,oFAAoF;IACpF,OAAO,CAAC,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,sBAAsB,CAAC,EAAE,MAAM,CAAC;CACjC;AAED,4FAA4F;AAC5F,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,QAAQ,EACxD,OAAO,EAAE,oBAAoB,CAAC,OAAO,CAAC,EACtC,MAAM,EAAE,oBAAoB,CAAC,QAAQ,CAAC,EACtC,MAAM,EAAE,0BAA0B,CAAC,QAAQ,EAAE,OAAO,CAAC,GACpD;IAAE,KAAK,IAAI,IAAI,CAAA;CAAE,CA6InB"}

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

@@ -0,0 +1,11 @@
+import type { ToolSet } from 'ai';
+import type { ServiceDef } from '../server/types.js';
+import { type AgentMountConfig } from '../tools/agent.js';
+import type { AgentRuntimeRunContext } from './runtime.js';
+/** Full mount configuration, resolved from the validated context of each run. */
+export interface AgentHarnessToolsConfig extends AgentMountConfig {
+    services: ServiceDef | ServiceDef[];
+}
+/** Mount through the existing tool runner, always retaining the run's execution fence. */
+export declare function createAgentHarnessTools<CONTEXT>(resolve: (run: AgentRuntimeRunContext<CONTEXT>) => AgentHarnessToolsConfig | Promise<AgentHarnessToolsConfig>): (run: AgentRuntimeRunContext<CONTEXT>) => Promise<ToolSet>;
+//# sourceMappingURL=harness-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"harness-tools.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/harness-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,KAAK,gBAAgB,EAAc,MAAM,gBAAgB,CAAC;AAEnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,WAAW,CAAC;AAExD,iFAAiF;AACjF,MAAM,WAAW,uBAAwB,SAAQ,gBAAgB;IAC/D,QAAQ,EAAE,UAAU,GAAG,UAAU,EAAE,CAAC;CACrC;AAED,0FAA0F;AAC1F,wBAAgB,uBAAuB,CAAC,OAAO,EAC7C,OAAO,EAAE,CACP,GAAG,EAAE,sBAAsB,CAAC,OAAO,CAAC,KACjC,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,GAC9D,CAAC,GAAG,EAAE,sBAAsB,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAQ5D"}

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

@@ -0,0 +1,4 @@
+import type { AgentController, AgentControllerState } from './browser-controller.js';
+/** Observe an application-owned controller; unmount never closes a shared connection or agent. */
+export declare function useAgent(controller: AgentController): AgentControllerState;
+//# sourceMappingURL=react.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/react.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAElF,kGAAkG;AAClG,wBAAgB,QAAQ,CAAC,UAAU,EAAE,eAAe,GAAG,oBAAoB,CAM1E"}

package/dist/agent-runtime/run-assertions.d.ts

@@ -0,0 +1,63 @@
+import { type AgentSnapshot } from './schemas.js';
+/** Assertions inspect durable evidence for exactly one run, independent of a test framework. */
+export declare function inspectAgentRun(rawSnapshot: AgentSnapshot, runId: string): {
+    run: {
+        schemaVersion: 1;
+        id: string;
+        conversationId: string;
+        inputMessageIds: string[];
+        assistantMessageId: string;
+        state: "abandoned" | "cancelled" | "completed" | "failed" | "interrupt_requested" | "interrupted" | "queued" | "running" | "superseded";
+        revision: number;
+        queuePriority?: "interrupt-next" | undefined;
+        executionSequence?: number | undefined;
+        ownerId?: string | undefined;
+        fencingToken?: number | undefined;
+        terminalReason?: "abandoned" | "absorbed" | "cancelled" | "context_overflow" | "interrupted" | "output_rejected" | "policy_stop" | "provider_failure" | "provider_stop" | "runtime_failure" | "shutdown" | "storage_conflict" | "success" | "superseded" | "timeout" | undefined;
+        terminalPolicyName?: string | undefined;
+        absorbedIntoRunId?: string | undefined;
+        usage?: {
+            inputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            outputTokens: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            };
+            reasoningTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheReadTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cacheWriteTokens?: {
+                value?: number | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+            cost?: {
+                value?: number | undefined;
+                currency?: string | undefined;
+                provenance: "computed" | "estimated" | "provider-reported" | "unavailable";
+            } | undefined;
+        } | undefined;
+        lastOperation?: {
+            operationId: string;
+            kind: "compaction" | "model-request";
+            phase: "cancelled" | "completed" | "failed" | "first-output" | "started";
+            step?: number | undefined;
+            startedAt: string;
+            firstOutputAt?: string | undefined;
+            finishedAt?: string | undefined;
+        } | undefined;
+        createdAt: string;
+        updatedAt: string;
+    };
+    completed(): void;
+    calledTool(name: string): void;
+    notCalledTool(name: string): void;
+    toolSucceeded(name: string): void;
+};
+//# sourceMappingURL=run-assertions.d.ts.map

package/dist/agent-runtime/run-assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-assertions.d.ts","sourceRoot":"","sources":["../../src/agent-runtime/run-assertions.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,aAAa,EAAuB,MAAM,WAAW,CAAC;AA8BnF,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,WAAW,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAsCpD,MAAM;wBAGH,MAAM;wBAGN,MAAM;EAgB7B"}

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

@@ -1,4 +1,6 @@
 /** Browser-safe canonical records and delivery cursor — no runtime execution or sinks. */
+export { type AgentBrowserRequest, AgentBrowserRequestSchema, agentControlRealtimeContract, } from '../../agent-runtime/browser-control-contract.js';
+export { type AgentBrowserCommand, type AgentController, type AgentControllerConfig, type AgentControllerState, createAgentController, } from '../../agent-runtime/browser-controller.js';
 export * from '../../agent-runtime/control-schema.js';
 export * from '../../agent-runtime/event-schema.js';
 export * from '../../agent-runtime/schemas.js';

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

@@ -1 +1 @@
-{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/agent-runtime/browser.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAE1F,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../../src/entrypoints/agent-runtime/browser.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAE1F,OAAO,EACL,KAAK,mBAAmB,EACxB,yBAAyB,EACzB,4BAA4B,GAC7B,MAAM,8CAA8C,CAAC;AACtD,OAAO,EACL,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,qBAAqB,GACtB,MAAM,wCAAwC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC"}

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/coding-tools.js

@@ -1,5 +1,5 @@
 import"../../index-ct75c3at.js";
-import"../../index-7z9ym7t8.js";
+import"../../index-x87j7csh.js";
 import"../../index-n53mswt3.js";
 import"../../index-b2bz0kdm.js";
 import {
@@ -7,9 +7,9 @@ import {
   AgentCodingToolAuthorizationSchema2,
   AgentCodingToolPathAuthorizationSchema2,
   createAgentCodingTools2
-} from "../../index-djjhhgjk.js";
+} from "../../index-a4ajxwmb.js";
 import"../../index-ahvsksw5.js";
-import"../../index-jzczzcsb.js";
+import"../../index-tgzhq07n.js";
 export {
   AgentCodingToolAuthorizationSchema2 as AgentCodingToolAuthorizationSchema,
   AgentCodingToolLimitsSchema2 as AgentCodingToolLimitsSchema,

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-x87j7csh.js";
+import"../../index-m2xqkv55.js";
+import"../../index-r956rndn.js";
+import {
+  mountAgent2
+} from "../../index-1khy8y7n.js";
+import {
+  composeToolLifecycle2
+} from "../../index-ze1eph1k.js";
+import"../../index-dnn9z96q.js";
+import"../../index-7n68nmc6.js";
+import"../../index-tgzhq07n.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
+};