stitchkit 0.93.0 → 0.94.1

package/dist/agent-runtime-harness.js

@@ -1,729 +0,0 @@
-import {
-  AgentControlRequestSchema,
-  AgentControlResponseSchema
-} from "./index-bt14acb5.js";
-import {
-  composeAgentPrompt,
-  createAgentRuntime,
-  createAgentRuntimeEventSink
-} from "./index-vk3kq9sb.js";
-import"./index-p13mwz16.js";
-import"./index-y64k3s0h.js";
-import {
-  AgentModelDescriptorSchema
-} from "./index-mqv3b5rh.js";
-import"./index-zwkgfq1s.js";
-import"./index-gtj3zc53.js";
-import"./index-wnfk50r0.js";
-import {
-  walkContainedFiles
-} from "./index-bn2cjajt.js";
-import"./index-kw9t5ayn.js";
-import"./index-yn8remb1.js";
-import"./index-tmwcrptx.js";
-import"./index-f9mb610r.js";
-import"./index-e0znv5gn.js";
-import"./index-0a349c33.js";
-import"./index-rxfy4cq7.js";
-import"./index-6k1937bx.js";
-import"./index-zcgf3gqf.js";
-import"./index-7zbps32p.js";
-import {
-  defineRuntimeTool
-} from "./index-vjpvjqpn.js";
-import"./index-h9etkkyk.js";
-import"./index-cby4ar3v.js";
-import"./index-2vtcmrj9.js";
-import"./index-kzfs85xp.js";
-import"./index-77fekveh.js";
-
-// src/agent-runtime/harness-contract.ts
-import { z } from "zod";
-var AgentHarnessResourceKindSchema = z.enum(["instruction", "skill", "resource"]);
-var AgentHarnessResourceSchema = z.object({
-  kind: AgentHarnessResourceKindSchema,
-  name: z.string().min(1),
-  text: z.string(),
-  provenance: z.string().min(1)
-}).strict();
-var AgentHarnessResourceDiagnosticSchema = z.object({
-  resource: z.string().min(1),
-  severity: z.enum(["warning", "error"]),
-  message: z.string().min(1)
-}).strict();
-var AgentHarnessLimitsSchema = z.object({
-  maxResources: z.int().positive(),
-  maxResourceBytes: z.int().positive(),
-  maxDiagnostics: z.int().nonnegative()
-}).strict();
-var AgentHarnessAppliedResourceSchema = AgentHarnessResourceSchema.omit({
-  text: true
-});
-var AgentHarnessProfileEventSchema = z.object({
-  schemaVersion: z.literal(1),
-  type: z.literal("profile-applied"),
-  conversationId: z.string().min(1),
-  runId: z.string().min(1),
-  model: AgentModelDescriptorSchema,
-  resources: z.array(AgentHarnessAppliedResourceSchema),
-  diagnostics: z.array(AgentHarnessResourceDiagnosticSchema),
-  toolNames: z.array(z.string().min(1))
-}).strict();
-
-// src/agent-runtime/harness-resources.ts
-var DEFAULT_LIMITS = {
-  maxResources: 64,
-  maxResourceBytes: 1048576,
-  maxDiagnostics: 128
-};
-function resolveHarnessLimits(input) {
-  return AgentHarnessLimitsSchema.parse({ ...DEFAULT_LIMITS, ...input });
-}
-function utf8Bytes(value) {
-  return new TextEncoder().encode(value).byteLength;
-}
-function validateHarnessResources(result, limits) {
-  if (result.resources.length > limits.maxResources) {
-    throw new Error("Agent harness resource count exceeds maxResources");
-  }
-  if (result.diagnostics.length > limits.maxDiagnostics) {
-    throw new Error("Agent harness diagnostic count exceeds maxDiagnostics");
-  }
-  const resources = AgentHarnessResourceSchema.array().parse(result.resources);
-  const diagnostics = AgentHarnessResourceDiagnosticSchema.array().parse(result.diagnostics);
-  const names = new Set;
-  let bytes = 0;
-  for (const resource of resources) {
-    if (names.has(resource.name)) {
-      throw new Error(`Duplicate Agent harness resource: ${resource.name}`);
-    }
-    names.add(resource.name);
-    bytes += utf8Bytes(resource.text);
-    if (bytes > limits.maxResourceBytes) {
-      throw new Error("Agent harness resources exceed maxResourceBytes");
-    }
-  }
-  return { resources, diagnostics };
-}
-function xmlAttribute(value) {
-  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-function renderHarnessResources(resources) {
-  return resources.map((resource) => `<resource kind="${resource.kind}" name="${xmlAttribute(resource.name)}" provenance="${xmlAttribute(resource.provenance)}">
-${resource.text}
-</resource>`).join(`
-`);
-}
-// src/agent-runtime/harness-file-resources.ts
-import { realpath } from "node:fs/promises";
-import path from "node:path";
-import { z as z2 } from "zod";
-var AgentHarnessFileRootSchema = z2.object({
-  id: z2.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/),
-  path: z2.string().min(1),
-  kind: z2.enum(["instruction", "skill", "resource"])
-}).strict();
-var AgentHarnessFileLimitsSchema = z2.object({
-  maxFiles: z2.int().positive(),
-  maxDepth: z2.int().nonnegative(),
-  maxFileBytes: z2.int().positive(),
-  maxTotalBytes: z2.int().positive()
-}).strict();
-var DEFAULT_LIMITS2 = {
-  maxFiles: 128,
-  maxDepth: 8,
-  maxFileBytes: 262144,
-  maxTotalBytes: 1048576
-};
-function metadata(text, fallbackName) {
-  const match = /^---\s*\n([\s\S]*?)\n---(?:\s*\n|$)/.exec(text.replaceAll(`\r
-`, `
-`));
-  if (!match)
-    throw new Error(`Skill ${fallbackName} requires YAML frontmatter`);
-  const fields = new Map;
-  const lines = (match[1] ?? "").split(`
-`);
-  for (let index = 0;index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
-    const field = /^(name|description):\s*(.*)$/.exec(line);
-    if (!field)
-      continue;
-    const key = field[1] ?? "";
-    if (fields.has(key))
-      throw new Error(`Skill ${fallbackName} repeats ${key} metadata`);
-    const raw = field[2] ?? "";
-    if (raw === ">" || raw === "|") {
-      const block = [];
-      while ((lines[index + 1] ?? "").match(/^\s+/)) {
-        index += 1;
-        block.push((lines[index] ?? "").replace(/^\s+/, ""));
-      }
-      fields.set(key, raw === ">" ? block.join(" ").trim() : block.join(`
-`).trim());
-    } else if (raw.startsWith('"')) {
-      let parsed;
-      try {
-        parsed = JSON.parse(raw);
-      } catch {
-        throw new Error(`Skill ${fallbackName} has invalid quoted ${key} metadata`);
-      }
-      if (typeof parsed !== "string")
-        throw new Error(`Skill ${fallbackName} has non-string ${key} metadata`);
-      fields.set(key, parsed);
-    } else if (raw.startsWith("'") && raw.endsWith("'")) {
-      fields.set(key, raw.slice(1, -1).replaceAll("''", "'"));
-    } else {
-      fields.set(key, raw.trim());
-    }
-  }
-  const name = fields.get("name");
-  const description = fields.get("description");
-  if (!name || !description) {
-    throw new Error(`Skill ${fallbackName} requires name and description metadata`);
-  }
-  return { name, description };
-}
-function safeName(relative) {
-  return relative.split(path.sep).join("/");
-}
-function createAgentHarnessFileResources(config) {
-  const roots = AgentHarnessFileRootSchema.array().min(1).parse(config.roots);
-  const ids = new Set;
-  for (const root of roots) {
-    if (!path.isAbsolute(root.path))
-      throw new Error("Agent harness resource roots must be absolute");
-    if (ids.has(root.id))
-      throw new Error(`Duplicate Agent harness resource root id: ${root.id}`);
-    ids.add(root.id);
-  }
-  const limits = AgentHarnessFileLimitsSchema.parse({ ...DEFAULT_LIMITS2, ...config.limits });
-  let exact = new Map;
-  let loaded;
-  const discover = async () => {
-    const next = new Map;
-    const projected = [];
-    let totalBytes = 0;
-    let fileCount = 0;
-    for (const root of roots) {
-      const resolvedRoot = await realpath(root.path);
-      const files = await walkContainedFiles({
-        root: resolvedRoot,
-        maxDepth: limits.maxDepth,
-        maxFiles: limits.maxFiles - fileCount,
-        readMaxBytes: limits.maxFileBytes
-      });
-      fileCount += files.length;
-      for (const file of files) {
-        if (root.kind === "skill" && path.basename(file.absolute) !== "SKILL.md")
-          continue;
-        const read = file.content;
-        if (!read)
-          throw new Error("Agent harness resource content is unavailable");
-        totalBytes += read.bytes;
-        if (totalBytes > limits.maxTotalBytes) {
-          throw new Error("Agent harness resources exceed maxTotalBytes");
-        }
-        const text = read.text;
-        const provenance = `${root.id}:${safeName(file.relative)}`;
-        const skill = root.kind === "skill" ? metadata(text, provenance) : undefined;
-        const name = skill?.name ?? safeName(file.relative);
-        if (next.has(name))
-          throw new Error(`Duplicate Agent harness resource: ${name}`);
-        const resource = {
-          kind: root.kind,
-          name,
-          text,
-          provenance
-        };
-        next.set(name, resource);
-        projected.push(root.kind === "instruction" ? resource : {
-          ...resource,
-          text: root.kind === "skill" ? `Available skill: ${name} — ${skill?.description ?? ""}. Read it by exact name when needed.` : `Available resource: ${name}. Read it by exact name when needed.`
-        });
-      }
-    }
-    exact = new Map(next);
-    return { resources: Object.freeze([...projected]), diagnostics: [] };
-  };
-  const load = () => {
-    loaded ??= discover();
-    return loaded;
-  };
-  const readResource = defineRuntimeTool({
-    name: "read_resource",
-    description: "Read one exact discovered harness skill or resource by canonical name.",
-    identity: { serviceName: "harness", action: "read-resource", method: "POST" },
-    input: z2.object({ name: z2.string().min(1) }).strict(),
-    output: z2.object({
-      kind: z2.enum(["instruction", "skill", "resource"]),
-      name: z2.string().min(1),
-      text: z2.string(),
-      provenance: z2.string().min(1)
-    }).strict(),
-    transports: ["AGENT"],
-    handler: ({ input }) => {
-      const resource = exact.get(input.name);
-      if (!resource)
-        throw new Error("Harness resource is missing or stale; refresh discovery");
-      return resource;
-    }
-  });
-  return { load, runtimeTools: [readResource] };
-}
-// src/agent-runtime/harness-control.ts
-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: createAgentRuntimeEventSink({
-          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 = AgentControlRequestSchema.parse(raw);
-          const fail = (code, message) => AgentControlResponseSchema.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 AgentControlResponseSchema.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 AgentControlResponseSchema.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 AgentControlResponseSchema.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");
-            }
-            if (request.operation === "interrupt") {
-              await harness.interrupt({
-                conversationId: request.conversationId,
-                runId: request.runId
-              });
-              return AgentControlResponseSchema.parse({
-                schemaVersion: 1,
-                requestId: request.requestId,
-                outcome: "ok",
-                snapshot: await harness.snapshot(request.conversationId)
-              });
-            }
-            if (request.operation === "respond-approval") {
-              const ticket2 = 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 admission2 = await ticket2.admission;
-              return AgentControlResponseSchema.parse({
-                schemaVersion: 1,
-                requestId: request.requestId,
-                outcome: "ok",
-                runId: admission2.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 AgentControlResponseSchema.parse({
-              schemaVersion: 1,
-              requestId: request.requestId,
-              outcome: "ok",
-              runId: admission.runId,
-              snapshot: await harness.snapshot(request.conversationId)
-            });
-          } 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 {
-  reason;
-  constructor(reason) {
-    super(`Approval response rejected: ${reason}`);
-    this.name = "AgentHarnessApprovalRejectedError";
-    this.reason = reason;
-  }
-}
-function activeRunId(snapshot) {
-  const active = snapshot.runs.filter((run2) => run2.state === "running" || run2.state === "interrupt_requested");
-  if (active.length !== 1) {
-    throw new Error("Agent harness prompt requires exactly one active run");
-  }
-  const run = active[0];
-  if (!run)
-    throw new Error("Agent harness active run is unavailable");
-  return run.id;
-}
-function createHeadlessAgentHarness(config) {
-  const {
-    models,
-    resources,
-    tools,
-    promptBudget,
-    estimateResourceTokens,
-    limits: inputLimits,
-    onProfile,
-    onProfileError,
-    publish: applicationPublish,
-    blockingPresentation = "local",
-    ...runtimeConfig
-  } = config;
-  const limits = resolveHarnessLimits(inputLimits);
-  const pending = new Map;
-  const subscribers = new Set;
-  const emitProfile = async (runId) => {
-    const entry = pending.get(runId);
-    if (!entry?.prompt || !entry.toolNames || entry.emitting)
-      return entry?.emitting;
-    const event = AgentHarnessProfileEventSchema.parse({
-      schemaVersion: 1,
-      type: "profile-applied",
-      conversationId: entry.prompt.conversationId,
-      runId,
-      model: entry.prompt.model.descriptor,
-      resources: entry.prompt.resources.map(({ kind, name, provenance }) => ({
-        kind,
-        name,
-        provenance
-      })),
-      diagnostics: entry.prompt.diagnostics,
-      toolNames: entry.toolNames
-    });
-    const emitting = (async () => {
-      try {
-        await onProfile?.(event);
-      } catch (error) {
-        try {
-          await onProfileError?.({ event, error });
-        } catch {}
-      } finally {
-        pending.delete(runId);
-      }
-    })();
-    entry.emitting = emitting;
-    return emitting;
-  };
-  const presentationMessage = (message) => blockingPresentation === "parent" ? {
-    ...message,
-    parts: message.parts.filter((part) => part.type !== "tool-approval-request")
-  } : message;
-  const publish = async (rawEvent) => {
-    let event = rawEvent;
-    if (blockingPresentation === "parent" && (event.type === "assistant-checkpoint" || event.type === "terminal")) {
-      event = { ...event, message: presentationMessage(event.message) };
-    }
-    try {
-      await applicationPublish?.(event);
-    } finally {
-      for (const subscriber of subscribers) {
-        Promise.resolve(subscriber(event)).catch(() => {});
-      }
-      if (event.type === "terminal")
-        pending.delete(event.runId);
-    }
-  };
-  const runtime = createAgentRuntime({
-    ...runtimeConfig,
-    models,
-    publish,
-    prompt: async ({ context, signal, model, snapshot, event }) => {
-      const loaded = validateHarnessResources(await resources.load({ context, signal, model, snapshot }), limits);
-      try {
-        await resources.onDiagnostics?.({ context, diagnostics: loaded.diagnostics });
-      } catch {}
-      const runId = activeRunId(snapshot);
-      const entry = pending.get(runId) ?? {};
-      entry.prompt = {
-        conversationId: snapshot.conversationId,
-        model,
-        resources: loaded.resources,
-        diagnostics: loaded.diagnostics
-      };
-      pending.set(runId, entry);
-      await emitProfile(runId);
-      const prompt = composeAgentPrompt([
-        {
-          name: "harness-resources",
-          stability: "dynamic",
-          render: () => renderHarnessResources(loaded.resources),
-          ...estimateResourceTokens && { estimateTokens: estimateResourceTokens }
-        }
-      ]);
-      return prompt({
-        context,
-        signal,
-        event,
-        budget: await promptBudget({
-          context,
-          contextWindow: model.descriptor.contextWindow
-        })
-      });
-    },
-    tools: async (runContext) => {
-      const mounted = await tools(runContext);
-      const entry = pending.get(runContext.run.id) ?? {};
-      entry.toolNames = Object.keys(mounted).sort();
-      pending.set(runContext.run.id, entry);
-      await emitProfile(runContext.run.id);
-      return mounted;
-    }
-  });
-  const pendingApprovals = async (conversationId) => {
-    const snapshot = await config.store.loadSnapshot(conversationId);
-    const responded = new Set(snapshot.messages.flatMap((message) => message.parts.filter((part) => part.type === "tool-approval-response").map((part) => part.approvalId)));
-    const pendingApprovals2 = [];
-    for (const message of snapshot.messages) {
-      const calls = new Map(message.parts.filter((part) => part.type === "tool-call").map((part) => [part.callId, part]));
-      for (const request of message.parts.filter((part) => part.type === "tool-approval-request")) {
-        if (responded.has(request.approvalId))
-          continue;
-        const call = calls.get(request.callId);
-        if (!call || !message.runId)
-          continue;
-        pendingApprovals2.push({
-          conversationId,
-          runId: message.runId,
-          messageId: message.id,
-          approvalId: request.approvalId,
-          callId: request.callId,
-          toolName: call.toolName,
-          input: call.input,
-          ...request.signature && { signature: request.signature }
-        });
-      }
-    }
-    return pendingApprovals2;
-  };
-  return {
-    ...runtime,
-    snapshot: async (conversationId) => {
-      const snapshot = await config.store.loadSnapshot(conversationId);
-      return { ...snapshot, messages: snapshot.messages.map(presentationMessage) };
-    },
-    subscribe(listener) {
-      subscribers.add(listener);
-      return () => subscribers.delete(listener);
-    },
-    pendingApprovals,
-    async respondToApproval(input) {
-      const pending2 = (await pendingApprovals(input.conversationId)).filter((approval) => approval.approvalId === input.approvalId);
-      if (pending2.length !== 1) {
-        throw new Error("Approval request is missing, stale or already answered");
-      }
-      const request = pending2[0];
-      if (!request) {
-        throw new Error("Approval request is missing, stale or already answered");
-      }
-      const authorization = config.authorizeApprovalResponse ? await config.authorizeApprovalResponse({
-        responder: input.context,
-        conversationId: input.conversationId,
-        request: {
-          approvalId: request.approvalId,
-          callId: request.callId,
-          toolName: request.toolName,
-          input: request.input
-        },
-        approved: input.approved
-      }) : { status: "allowed" };
-      if (authorization.status === "rejected") {
-        await runtimeConfig.store.appendEvent({
-          conversationId: input.conversationId,
-          kind: "approval/response-rejected",
-          payload: {
-            approvalId: request.approvalId,
-            callId: request.callId,
-            toolName: request.toolName,
-            reason: authorization.reason
-          }
-        });
-        throw new AgentHarnessApprovalRejectedError(authorization.reason);
-      }
-      const ticket = runtime.submit({
-        conversationId: input.conversationId,
-        idempotencyKey: `tool-approval:${input.approvalId}`,
-        context: input.context,
-        role: "tool",
-        ...input.metadata !== undefined && { metadata: input.metadata },
-        parts: [
-          {
-            type: "tool-approval-response",
-            approvalId: input.approvalId,
-            approved: input.approved,
-            ...input.reason && { reason: input.reason }
-          }
-        ]
-      });
-      const checkedAdmission = ticket.admission.then(async (admission) => {
-        const response = admission.input.parts.find((part) => part.type === "tool-approval-response");
-        if (!response || response.approvalId !== input.approvalId || response.approved !== input.approved || response.reason !== input.reason) {
-          throw new Error("Approval decision conflicts with the durable decision");
-        }
-        return admission;
-      });
-      return { ...ticket, admission: checkedAdmission };
-    }
-  };
-}
-export {
-  createHeadlessAgentHarness,
-  createAgentHarnessFileResources,
-  createAgentHarnessControlServer,
-  AgentHarnessResourceSchema,
-  AgentHarnessResourceKindSchema,
-  AgentHarnessResourceDiagnosticSchema,
-  AgentHarnessProfileEventSchema,
-  AgentHarnessLimitsSchema,
-  AgentHarnessFileRootSchema,
-  AgentHarnessFileLimitsSchema,
-  AgentHarnessApprovalRejectedError
-};