stitchkit 0.103.0 → 0.103.1

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

@@ -0,0 +1,29 @@
+import {
+  createBoundedSinkManager
+} from "./index-h97tqqp1.js";
+import {
+  AgentRuntimeEventSchema2
+} from "./index-mnkk1ffz.js";
+
+// src/agent-runtime/events.ts
+function createAgentRuntimeEventSink2(config) {
+  const manager = createBoundedSinkManager({
+    write: config.write,
+    ...config.maxPending !== undefined && { maxPending: config.maxPending },
+    ...config.onSinkError && { onSinkError: config.onSinkError },
+    ...config.onDrop && { onDrop: config.onDrop }
+  });
+  return {
+    publish(rawEvent) {
+      const event = AgentRuntimeEventSchema2.parse(rawEvent);
+      const projected = config.project?.(event) ?? (config.project ? undefined : event);
+      if (projected)
+        manager.submit(() => AgentRuntimeEventSchema2.parse(projected));
+    },
+    flush: (bound) => manager.flush(bound),
+    getStatus: () => manager.getStatus(),
+    close: (bound) => manager.close(bound)
+  };
+}
+
+export { createAgentRuntimeEventSink2 };

package/dist/{index-ewbaywk5.js → index-x1dkwx5x.js}

@@ -3,7 +3,7 @@ import {
 } from "./index-7z9ym7t8.js";
 import {
   contractToolMountable
-} from "./index-n9tyz8z3.js";
+} from "./index-kgmh97hf.js";
 import {
   runtimeToolMountable
 } from "./index-jzczzcsb.js";

package/dist/{index-xkhk5d6g.js → index-xgc94hy6.js}

@@ -1,19 +1,19 @@
 import {
   AgentToolError2,
   resolveToolDurability
-} from "./index-a9pd417t.js";
+} from "./index-nggfa2yn.js";
 import {
   toolResultFromError,
   toolCauseFromResult,
   isToolExecutionControlError2
-} from "./index-dvwj1f43.js";
+} from "./index-0efgsyav.js";
 import {
   createToolRunner,
   formatToolError
-} from "./index-n9tyz8z3.js";
+} from "./index-kgmh97hf.js";
 import {
   collectToolSurface
-} from "./index-ewbaywk5.js";
+} from "./index-x1dkwx5x.js";
 import {
   isRecord
 } from "./index-9jfdm5tg.js";
@@ -108,47 +108,4 @@ function mountAgent2(services, config = {}) {
   return tools;
 }
 
-// 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 { mountAgent2, describeToolCatalog2, buildToolManifest2 };
+export { mountAgent2 };

package/dist/{index-3ct7hhq6.js → index-xwq9j1sf.js}

@@ -17,7 +17,7 @@ import {
 } from "./index-b2bz0kdm.js";
 import {
   resolveTraceContext2
-} from "./index-hby4qhax.js";
+} from "./index-yex7eg1v.js";
 import {
   DEFAULT_CONTRACT_STREAM_FRAME_BYTES2
 } from "./index-r5c4fedv.js";
@@ -25,13 +25,12 @@ import {
   joinRoutePath,
   parseTrailingWildcard
 } from "./index-m38ej7e5.js";
-import {
-  createValidatedRealtimeSocket,
-  isModuleNotFound
-} from "./index-m79yr938.js";
 import {
   RELEASE_HEADER2
 } from "./index-n15jny5b.js";
+import {
+  isModuleNotFound
+} from "./index-srs8hj9c.js";
 import {
   assertCorsConfig,
   isOriginAllowed,
@@ -50,7 +49,7 @@ import {
   getRequestContext2,
   setRequestEndpoint2,
   setRequestError2
-} from "./index-r1z0rd9c.js";
+} from "./index-7n68nmc6.js";
 import {
   resolveTraceId2,
   resolveSocketIp2,
@@ -2341,55 +2340,6 @@ function bindProcessSignals2(handle, options = {}) {
   return { promise, close };
 }
 
-// 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))
-  };
-}
-
 // src/server/websocket.ts
 function webSocketLane2(lane) {
   const { match, handlers } = lane;
@@ -3499,4 +3449,4 @@ function createUnixClientTransport2(config) {
   };
 }
 
-export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart2, DEFAULT_STREAM_HEARTBEAT_MS2, streamingRoute2, ndjsonRoute2, sseRoute2, createHandler2, createScopedImplementRegistry2, implementRegistry2, createImplementRegistry2, bindProcessSignals2, bindRealtimeServer2, webSocketLane2, composeWebSocketHandlers2, createSocketIOServer2, socketIoLane2, UnixClientTransportError2, createUnixClientTransport2 };
+export { contextContributionDelta, prepareContextContribution, mergeContextContribution, parseMultipart2, DEFAULT_STREAM_HEARTBEAT_MS2, streamingRoute2, ndjsonRoute2, sseRoute2, createHandler2, createScopedImplementRegistry2, implementRegistry2, createImplementRegistry2, bindProcessSignals2, webSocketLane2, composeWebSocketHandlers2, createSocketIOServer2, socketIoLane2, UnixClientTransportError2, createUnixClientTransport2 };

package/dist/{index-hby4qhax.js → index-yex7eg1v.js}

@@ -1,12 +1,6 @@
-// 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;
-}
+import {
+  randomHex
+} from "./index-c9d05kvt.js";
 
 // src/observability/trace.ts
 var TRACEPARENT_RE = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})(.*)$/i;
@@ -80,4 +74,4 @@ function resolvePropagationContext2(metadata, fallback) {
   };
 }
 
-export { randomHex, createTraceContext2, parseTraceparent2, formatTraceparent2, resolveTraceContext2, childSpan2, resolvePropagationContext2 };
+export { createTraceContext2, parseTraceparent2, formatTraceparent2, resolveTraceContext2, childSpan2, resolvePropagationContext2 };

package/dist/{index-1h6gtdrj.js → index-ygkka6zn.js}

@@ -1,7 +1,7 @@
 import {
   createTraceContext2,
   formatTraceparent2
-} from "./index-hby4qhax.js";
+} from "./index-yex7eg1v.js";
 import {
   isRecord,
   transportResult

package/dist/{index-zs4ms3th.js → index-z3pqcy7r.js}

@@ -12,21 +12,19 @@ import {
   AgentSnapshotSchema2
 } from "./index-8kzct1d6.js";
 import {
-  createBoundedSinkManager
-} from "./index-h97tqqp1.js";
+  ToolExecutionControlError2,
+  isToolExecutionControlError2
+} from "./index-0efgsyav.js";
 import {
-  AgentRuntimeEventSchema2,
   agentDurableEventId2
 } from "./index-mnkk1ffz.js";
 import {
-  ToolExecutionControlError2,
-  isToolExecutionControlError2
-} from "./index-dvwj1f43.js";
+  createLocalStepDurability2
+} from "./index-5vyd0fkb.js";
 import {
-  createLocalStepDurability2,
   isAgentToolError2,
   createToolDurabilityContext
-} from "./index-a9pd417t.js";
+} from "./index-nggfa2yn.js";
 import {
   canonicalAgentJson2,
   createToolChronology,
@@ -324,27 +322,6 @@ function createAgentSessionCoordinator2() {
   };
 }
 
-// src/agent-runtime/events.ts
-function createAgentRuntimeEventSink2(config) {
-  const manager = createBoundedSinkManager({
-    write: config.write,
-    ...config.maxPending !== undefined && { maxPending: config.maxPending },
-    ...config.onSinkError && { onSinkError: config.onSinkError },
-    ...config.onDrop && { onDrop: config.onDrop }
-  });
-  return {
-    publish(rawEvent) {
-      const event = AgentRuntimeEventSchema2.parse(rawEvent);
-      const projected = config.project?.(event) ?? (config.project ? undefined : event);
-      if (projected)
-        manager.submit(() => AgentRuntimeEventSchema2.parse(projected));
-    },
-    flush: (bound) => manager.flush(bound),
-    getStatus: () => manager.getStatus(),
-    close: (bound) => manager.close(bound)
-  };
-}
-
 // src/agent-runtime/history.ts
 import { modelMessageSchema as modelMessageSchema2 } from "ai";
 
@@ -4310,4 +4287,4 @@ function createAgentRuntime2(config) {
   };
 }
 
-export { AgentRuntimeConflictError2, normalizeSdkUsage, AgentContextOverflowError2, createAgentSessionCoordinator2, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, createAgentRuntimeEventSink2, projectAgentHistoryDetailed2, projectAgentHistory2, ModelInvocationTraceSchema2, CompletionInvocationInputSchema2, ModelInvocationRecordSchema2, currentModelInvocationAttempt2, createModelInvocationLedger2, createAgentToolFenceLifecycle2, AgentTokenCountSchema2, selectAgentHistory2, composeAgentPrompt2, AgentProviderStreamCutError2, classifyProviderFailure2, isToolResultFailure2, recordAgentRetryDecision2, defineStateSlot2, createAgentStateSlotStore2, renderAgentStateSlots2, agentGoalStateSlot2, agentTodoStateSlot2, createAgentRuntime2 };
+export { AgentRuntimeConflictError2, normalizeSdkUsage, AgentContextOverflowError2, createAgentSessionCoordinator2, registerDeferredToolRepair, registerDeferredToolCatalog, deferredToolCatalog, repairedSearchCall, projectAgentHistoryDetailed2, projectAgentHistory2, ModelInvocationTraceSchema2, CompletionInvocationInputSchema2, ModelInvocationRecordSchema2, currentModelInvocationAttempt2, createModelInvocationLedger2, createAgentToolFenceLifecycle2, AgentTokenCountSchema2, selectAgentHistory2, composeAgentPrompt2, AgentProviderStreamCutError2, classifyProviderFailure2, isToolResultFailure2, recordAgentRetryDecision2, defineStateSlot2, createAgentStateSlotStore2, renderAgentStateSlots2, agentGoalStateSlot2, agentTodoStateSlot2, createAgentRuntime2 };

package/dist/index-ze1eph1k.js

@@ -0,0 +1,20 @@
+// src/tools/lifecycle.ts
+function composeToolLifecycle2(...hooks) {
+  return {
+    beforeHandle: async (ctx, endpoint) => {
+      for (const hook of hooks)
+        await hook?.beforeHandle?.(ctx, endpoint);
+    },
+    afterHandle: async (ctx, result, endpoint) => {
+      let current = result;
+      for (const hook of hooks) {
+        const transformed = await hook?.afterHandle?.(ctx, current, endpoint);
+        if (transformed !== undefined)
+          current = transformed;
+      }
+      return current;
+    }
+  };
+}
+
+export { composeToolLifecycle2 };

package/llms/agent-runtime-browser.txt

@@ -7,6 +7,7 @@ Contains: API reference: `stitchkit/agent-runtime/browser`  (docs/api/reference.
 
 Also read:
 - see `llms/agent-runtime.txt` for the Agent application runtime guide
+- see `llms/agent-runtime-harness.txt` for the Agent composition guide
 
 ==============================================================================
 # API reference: `stitchkit/agent-runtime/browser`  (docs/api/reference.md)
@@ -31,3 +32,28 @@ Use this entrypoint from client components and shared DTO packages. The full
 `stitchkit/agent-runtime` entrypoint remains server-only.
 
 ---
+
+### Browser control composition
+
+`AgentBrowserRequestSchema` / `AgentBrowserRequest` derive from the trusted control
+protocol but exclude runtime `context`. Submit permits only strict text/file parts;
+file ownership and metadata policy are checked by server authorization. The shared
+`agentControlRealtimeContract` owns `agent:control` acknowledgements and `agent:delivery`.
+
+`createAgentController` / `AgentControllerConfig` take an existing Stitchkit
+realtime `transport`, `conversationId`, `access` (`observe` or `control`), optional
+`timeoutMs` (10000), `maxBufferedEvents` (256), `maxBufferedBytes` (1048576) and
+`maxPendingRequests` (32). All bounds are positive safe integers. One controller owns one
+attachment per conversation on that transport; share the controller between views.
+
+`AgentController` exposes stable `subscribe`, `getSnapshot`, `request(command)` and async
+`close`. `AgentBrowserCommand` uses the canonical operations, without request/conversation identity;
+`submit` requires a caller-owned idempotency key. Unknown-outcome mutations are never
+replayed automatically. `AgentControllerState` distinguishes connecting, ready,
+disconnected, error and closed and retains the canonical full `view` plus safe error
+code/message. Errors in automatic attach/refresh appear there. Reconnect attaches again
+and reads a snapshot; snapshot gaps coalesce, stale generations cannot overwrite state,
+and buffers/queues are bounded. Overflow or failed refresh is visible and requires
+explicit recovery. Closing detaches without closing the shared transport or remote run.
+
+See [agent composition](../guide/agent-composition.md) for a complete wiring example.

package/llms/agent-runtime-harness-tools.txt

@@ -0,0 +1,25 @@
+# stitchkit/agent-runtime/harness-tools — stitchkit docs slice
+
+> Generated from the `docs/` tree by `bun run gen:llms`. The index of all slices is
+> `llms.txt` in this package.
+
+Contains: API reference: `stitchkit/agent-runtime/harness-tools`  (docs/api/reference.md)
+
+Also read:
+- see `llms/agent-runtime.txt` for the Agent application runtime guide
+- see `llms/agent-runtime-harness.txt` for the Agent composition guide
+
+==============================================================================
+# API reference: `stitchkit/agent-runtime/harness-tools`  (docs/api/reference.md)
+==============================================================================
+
+## `stitchkit/agent-runtime/harness-tools`
+
+Optional evolving composition of the full `mountAgent` configuration with the runtime
+fence. Its runtime peer is `ai`; its full tool presenter declarations also require
+`@modelcontextprotocol/server`, as `stitchkit/tools` does. The base harness retains its
+AI-only peer boundary. Existing custom tool callbacks need no new import.
+
+| Export | Kind | Summary |
+|--------|------|---------|
+| `createAgentHarnessTools` / `AgentHarnessToolsConfig` | function / _type_ | async per-run full mount configuration (`services` plus all `AgentMountConfig` options); composes application lifecycle then runtime fence exactly once |