@botbotgo/agent-harness 0.0.308 → 0.0.310

package/dist/mcp.d.ts

@@ -1,62 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ApprovalRecord, ArtifactListing, CompiledTool, HarnessEvent, ParsedToolObject, RequestRecord, RequestResult, RequestState, RequestSummary, RuntimeSessionPackage, RuntimeSessionPackageInput, SessionRecord, SessionSummary } from "./contracts/types.js";
-export type ToolMcpServerOptions = {
-    agentId: string;
-    serverInfo?: {
-        name?: string;
-        version?: string;
-    };
-    includeToolNames?: string[];
-};
-export type ToolMcpServerTool = {
-    compiledTool: CompiledTool;
-    resolvedTool: unknown;
-    sourceTool?: ParsedToolObject;
-};
-export type RuntimeMcpServerOptions = {
-    serverInfo?: {
-        name?: string;
-        version?: string;
-    };
-};
-type RuntimeMcpRuntime = {
-    listSessions: (filter?: {
-        agentId?: string;
-    }) => Promise<SessionSummary[]>;
-    getSessionRecord: (sessionId: string) => Promise<SessionRecord | null>;
-    listRequests: (filter?: {
-        agentId?: string;
-        sessionId?: string;
-        state?: RequestState;
-    }) => Promise<RequestSummary[]>;
-    getRequest: (requestId: string) => Promise<RequestRecord | null>;
-    listApprovals: (filter?: {
-        status?: ApprovalRecord["status"];
-        sessionId?: string;
-        requestId?: string;
-    }) => Promise<ApprovalRecord[]>;
-    getApproval: (approvalId: string) => Promise<ApprovalRecord | null>;
-    resume: (options: {
-        approvalId?: string;
-        sessionId?: string;
-        requestId?: string;
-        decision?: "approve" | "edit" | "reject";
-        editedInput?: Record<string, unknown>;
-    }) => Promise<RequestResult>;
-    listRequestArtifacts: (sessionId: string, requestId: string) => Promise<ArtifactListing>;
-    readRequestArtifact: (sessionId: string, requestId: string, artifactPath: string) => Promise<unknown>;
-    listRequestEvents: (sessionId: string, requestId: string) => Promise<HarnessEvent[]>;
-    exportRequestPackage: (input: {
-        sessionId: string;
-        requestId: string;
-        includeArtifacts?: boolean;
-        includeArtifactContents?: boolean;
-        includeRuntimeHealth?: boolean;
-    }) => Promise<unknown>;
-    exportSessionPackage: (input: RuntimeSessionPackageInput) => Promise<RuntimeSessionPackage>;
-};
-export declare function createToolMcpServerFromTools(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
-export declare function serveToolsOverStdioFromHarness(tools: ToolMcpServerTool[], options: ToolMcpServerOptions): Promise<McpServer>;
-export declare function createRuntimeMcpServer(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
-export declare function serveRuntimeMcpOverStdio(runtime: RuntimeMcpRuntime, options?: RuntimeMcpServerOptions): Promise<McpServer>;
-export {};
+export { AGENT_HARNESS_VERSION } from "./package-version.js";
+export * from "./protocol/mcp/server.js";

package/dist/mcp.js

@@ -1,253 +1,2 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { pathToFileURL } from "node:url";
-import { z } from "zod";
-import { AGENT_HARNESS_VERSION } from "./package-version.js";
-import { loadToolModuleDefinition } from "./tool-modules.js";
-function asResolvedTool(value) {
-    return typeof value === "object" && value !== null ? value : null;
-}
-async function buildRawShapeForTool(sourceTool, resolvedTool) {
-    if (!sourceTool) {
-        return undefined;
-    }
-    if (sourceTool.type === "function") {
-        const imported = await import(pathToFileURL(sourceTool.sourcePath).href);
-        const definition = loadToolModuleDefinition(imported, sourceTool.implementationName ?? sourceTool.id);
-        return typeof definition.schema.shape === "object" && definition.schema.shape !== null
-            ? definition.schema.shape
-            : undefined;
-    }
-    const typedResolvedTool = asResolvedTool(resolvedTool);
-    if (!typedResolvedTool?.inputSchemaPromise) {
-        return undefined;
-    }
-    return jsonSchemaObjectToRawShape(await typedResolvedTool.inputSchemaPromise);
-}
-async function invokeResolvedTool(resolvedTool, input) {
-    const typed = asResolvedTool(resolvedTool);
-    if (!typed) {
-        throw new Error("Resolved tool is not invokable.");
-    }
-    if (typeof typed.invoke === "function") {
-        return typed.invoke(input);
-    }
-    if (typeof typed.call === "function") {
-        return typed.call(input);
-    }
-    if (typeof typed.func === "function") {
-        return typed.func(input);
-    }
-    throw new Error("Resolved tool does not expose invoke, call, or func.");
-}
-function renderToolOutput(output) {
-    if (typeof output === "string") {
-        return output;
-    }
-    return JSON.stringify(output, null, 2);
-}
-function jsonSchemaObjectToRawShape(schema) {
-    if (!schema || schema.type !== "object") {
-        return undefined;
-    }
-    const properties = typeof schema.properties === "object" && schema.properties
-        ? schema.properties
-        : {};
-    const required = Array.isArray(schema.required)
-        ? new Set(schema.required.filter((item) => typeof item === "string"))
-        : new Set();
-    const shape = {};
-    for (const [key, propertySchema] of Object.entries(properties)) {
-        const built = jsonSchemaToZod(propertySchema);
-        shape[key] = required.has(key) ? built : built.optional();
-    }
-    return shape;
-}
-function jsonSchemaToZod(schema) {
-    switch (schema?.type) {
-        case "string":
-            return z.string();
-        case "number":
-            return z.number();
-        case "integer":
-            return z.number().int();
-        case "boolean":
-            return z.boolean();
-        case "array":
-            return z.array(jsonSchemaToZod(typeof schema.items === "object" && schema.items ? schema.items : undefined));
-        case "object": {
-            const shape = jsonSchemaObjectToRawShape(schema);
-            return z.object(shape ?? {}).passthrough();
-        }
-        default:
-            return z.any();
-    }
-}
-export async function createToolMcpServerFromTools(tools, options) {
-    const server = new McpServer({
-        name: options.serverInfo?.name ?? `agent-harness-${options.agentId}`,
-        version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
-    });
-    const allowedNames = options.includeToolNames ? new Set(options.includeToolNames) : null;
-    for (const { compiledTool, resolvedTool, sourceTool } of tools) {
-        if (allowedNames && !allowedNames.has(compiledTool.name)) {
-            continue;
-        }
-        const rawShape = await buildRawShapeForTool(sourceTool, resolvedTool);
-        server.tool(compiledTool.name, compiledTool.description, rawShape ?? {}, async (input) => ({
-            content: [
-                {
-                    type: "text",
-                    text: renderToolOutput(await invokeResolvedTool(resolvedTool, input)),
-                },
-            ],
-        }));
-    }
-    return server;
-}
-export async function serveToolsOverStdioFromHarness(tools, options) {
-    const server = await createToolMcpServerFromTools(tools, options);
-    await server.connect(new StdioServerTransport());
-    return server;
-}
-export async function createRuntimeMcpServer(runtime, options = {}) {
-    const server = new McpServer({
-        name: options.serverInfo?.name ?? "agent-harness-runtime",
-        version: options.serverInfo?.version ?? AGENT_HARNESS_VERSION,
-    });
-    server.tool("list_sessions", "List persisted runtime sessions.", {
-        agentId: z.string().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listSessions(input.agentId ? { agentId: input.agentId } : undefined)),
-            }],
-    }));
-    server.tool("get_session", "Get one persisted runtime session by id.", {
-        sessionId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.getSessionRecord(input.sessionId)),
-            }],
-    }));
-    server.tool("list_requests", "List persisted runtime requests.", {
-        agentId: z.string().optional(),
-        sessionId: z.string().optional(),
-        state: z.enum(["queued", "running", "waiting_for_approval", "completed", "failed", "cancelled"]).optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listRequests({
-                    ...(input.agentId ? { agentId: input.agentId } : {}),
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    ...(input.state ? { state: input.state } : {}),
-                })),
-            }],
-    }));
-    server.tool("get_request", "Get one persisted runtime request by id.", {
-        requestId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.getRequest(input.requestId)),
-            }],
-    }));
-    server.tool("list_approvals", "List runtime approvals.", {
-        status: z.enum(["pending", "approved", "edited", "rejected", "expired"]).optional(),
-        sessionId: z.string().optional(),
-        requestId: z.string().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listApprovals({
-                    ...(input.status ? { status: input.status } : {}),
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    ...(input.requestId ? { requestId: input.requestId } : {}),
-                })),
-            }],
-    }));
-    server.tool("get_approval", "Get one runtime approval by id.", {
-        approvalId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.getApproval(input.approvalId)),
-            }],
-    }));
-    server.tool("resolve_approval", "Resolve one runtime approval.", {
-        approvalId: z.string(),
-        decision: z.enum(["approve", "edit", "reject"]),
-        sessionId: z.string().optional(),
-        requestId: z.string().optional(),
-        editedInput: z.record(z.string(), z.any()).optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.resume({
-                    approvalId: input.approvalId,
-                    decision: input.decision,
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    ...(input.requestId ? { requestId: input.requestId } : {}),
-                    ...(input.editedInput ? { editedInput: input.editedInput } : {}),
-                })),
-            }],
-    }));
-    server.tool("list_artifacts", "List artifacts for one runtime request.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listRequestArtifacts(input.sessionId, input.requestId)),
-            }],
-    }));
-    server.tool("read_artifact", "Read one runtime artifact.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-        artifactPath: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.readRequestArtifact(input.sessionId, input.requestId, input.artifactPath)),
-            }],
-    }));
-    server.tool("list_request_events", "List persisted runtime events for one request.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.listRequestEvents(input.sessionId, input.requestId)),
-            }],
-    }));
-    server.tool("export_request_package", "Export a stable runtime request package for one request.", {
-        sessionId: z.string(),
-        requestId: z.string(),
-        includeArtifacts: z.boolean().optional(),
-        includeArtifactContents: z.boolean().optional(),
-        includeRuntimeHealth: z.boolean().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.exportRequestPackage(input)),
-            }],
-    }));
-    server.tool("export_session_package", "Export a stable runtime session package.", {
-        sessionId: z.string(),
-        includeArtifacts: z.boolean().optional(),
-        includeArtifactContents: z.boolean().optional(),
-        includeRuntimeHealth: z.boolean().optional(),
-    }, async (input) => ({
-        content: [{
-                type: "text",
-                text: renderToolOutput(await runtime.exportSessionPackage(input)),
-            }],
-    }));
-    return server;
-}
-export async function serveRuntimeMcpOverStdio(runtime, options = {}) {
-    const server = await createRuntimeMcpServer(runtime, options);
-    await server.connect(new StdioServerTransport());
-    return server;
-}
+export { AGENT_HARNESS_VERSION } from "./package-version.js";
+export * from "./protocol/mcp/server.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.307";
+export declare const AGENT_HARNESS_VERSION = "0.0.309";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.307";
+export const AGENT_HARNESS_VERSION = "0.0.309";

package/dist/persistence/file-store.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { appendFile, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import { ensureDir, fileExists, readJson, writeJson } from "../utils/fs.js";
-import { resolveRuntimeArtifactsRoot } from "../runtime/support/runtime-layout.js";
+import { resolveRuntimeArtifactsRoot } from "../runtime/layout/runtime-layout.js";
 function nowIso() {
     return new Date(Date.now()).toISOString();
 }

package/dist/persistence/sqlite-runtime.d.ts

@@ -0,0 +1,19 @@
+import type { Client, InValue } from "@libsql/client";
+export type SqlRow = Record<string, unknown>;
+export declare const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
+export declare const SQLITE_BUSY_RETRY_DELAY_MS = 100;
+export declare function asRow(value: unknown): SqlRow;
+export declare function asString(value: unknown): string;
+export declare function asNullableString(value: unknown): string | null;
+export declare function asBoolean(value: unknown): boolean;
+export declare function parseJson<T>(value: unknown): T;
+export declare function toSqliteUrl(filePath: string): string;
+export declare function nowIso(): string;
+export declare function throwWrappedRuntimeSqliteError(dbPath: string, sql: string | undefined, error: unknown): never;
+export declare function isSqliteBusyError(error: unknown): boolean;
+export declare function sleep(ms: number): Promise<void>;
+export declare function executeWithBusyRetry<T>(client: Client, dbPath: string, sql: string, args: InValue[] | undefined, run: () => Promise<T>): Promise<T>;
+export declare function buildWhereClause(filters: Array<[sql: string, value: InValue | undefined]>): {
+    clause: string;
+    args: InValue[];
+};

package/dist/persistence/sqlite-runtime.js

@@ -0,0 +1,86 @@
+export const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
+export const SQLITE_BUSY_RETRY_DELAY_MS = 100;
+export function asRow(value) {
+    return value;
+}
+export function asString(value) {
+    return typeof value === "string" ? value : String(value ?? "");
+}
+export function asNullableString(value) {
+    return value == null ? null : asString(value);
+}
+export function asBoolean(value) {
+    return value === true || value === 1 || value === "1";
+}
+export function parseJson(value) {
+    return JSON.parse(asString(value));
+}
+export function toSqliteUrl(filePath) {
+    return `file:${filePath}`;
+}
+export function nowIso() {
+    return new Date(Date.now()).toISOString();
+}
+function runtimeSqliteErrorShouldIncludeSql(baseMessage) {
+    if (process.env.AGENT_HARNESS_RUNTIME_SQLITE_DEBUG === "1") {
+        return true;
+    }
+    return /SQLITE_CONSTRAINT|FOREIGN KEY|UNIQUE constraint|NOT NULL/i.test(baseMessage);
+}
+function formatRuntimeSqliteErrorMessage(dbPath, sql, baseMessage) {
+    let detail = `agent-harness runtime SQLite (${dbPath}): ${baseMessage}`;
+    if (sql && runtimeSqliteErrorShouldIncludeSql(baseMessage)) {
+        const sqlPreview = sql.replace(/\s+/g, " ").trim();
+        const truncated = sqlPreview.length > 220 ? `${sqlPreview.slice(0, 220)}…` : sqlPreview;
+        detail += ` [sql=${truncated}]`;
+    }
+    return detail;
+}
+export function throwWrappedRuntimeSqliteError(dbPath, sql, error) {
+    const base = error instanceof Error ? error.message : String(error);
+    const wrapped = new Error(formatRuntimeSqliteErrorMessage(dbPath, sql, base));
+    wrapped.cause = error;
+    throw wrapped;
+}
+function collectErrorMessages(error) {
+    const messages = [];
+    let current = error;
+    while (current instanceof Error) {
+        messages.push(current.message);
+        current = current.cause;
+    }
+    if (typeof current === "string" && current.length > 0) {
+        messages.push(current);
+    }
+    return messages;
+}
+export function isSqliteBusyError(error) {
+    return collectErrorMessages(error).some((message) => /SQLITE_BUSY|database is locked/i.test(message));
+}
+export function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export async function executeWithBusyRetry(client, dbPath, sql, args, run) {
+    void client;
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await run();
+        }
+        catch (error) {
+            if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
+                throwWrappedRuntimeSqliteError(dbPath, sql, error);
+            }
+            await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
+        }
+    }
+}
+export function buildWhereClause(filters) {
+    const active = filters.filter(([, value]) => value !== undefined);
+    if (active.length === 0) {
+        return { clause: "", args: [] };
+    }
+    return {
+        clause: ` WHERE ${active.map(([sql]) => sql).join(" AND ")}`,
+        args: active.map(([, value]) => value),
+    };
+}

package/dist/persistence/sqlite-store.js

@@ -2,7 +2,8 @@ import path from "node:path";
 import { mkdir, rm } from "node:fs/promises";
 import { createClient } from "@libsql/client";
 import { fileExists, readJson, writeJson } from "../utils/fs.js";
-import { resolveRuntimeRoot, resolveRuntimeSqlitePath } from "../runtime/support/runtime-layout.js";
+import { resolveRuntimeRoot, resolveRuntimeSqlitePath } from "../runtime/layout/runtime-layout.js";
+import { asBoolean, asNullableString, asRow, asString, buildWhereClause, executeWithBusyRetry, nowIso, parseJson, throwWrappedRuntimeSqliteError, toSqliteUrl, } from "./sqlite-runtime.js";
 import { SqliteRequestContextStore } from "./sqlite-request-context-store.js";
 import { SqliteRequestQueueStore } from "./sqlite-request-queue-store.js";
 const RUNTIME_SQLITE_SCHEMA_VERSION = 7;
@@ -15,78 +16,6 @@ const ACTIVE_REQUEST_STATES = new Set([
     "resuming",
     "cancelling",
 ]);
-function asRow(value) {
-    return value;
-}
-function asString(value) {
-    return typeof value === "string" ? value : String(value ?? "");
-}
-function asNullableString(value) {
-    return value == null ? null : asString(value);
-}
-function asBoolean(value) {
-    return value === true || value === 1 || value === "1";
-}
-function parseJson(value) {
-    return JSON.parse(asString(value));
-}
-function toSqliteUrl(filePath) {
-    return `file:${filePath}`;
-}
-const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
-const SQLITE_BUSY_RETRY_DELAY_MS = 100;
-function nowIso() {
-    return new Date(Date.now()).toISOString();
-}
-function runtimeSqliteErrorShouldIncludeSql(baseMessage) {
-    if (process.env.AGENT_HARNESS_RUNTIME_SQLITE_DEBUG === "1") {
-        return true;
-    }
-    return /SQLITE_CONSTRAINT|FOREIGN KEY|UNIQUE constraint|NOT NULL/i.test(baseMessage);
-}
-function formatRuntimeSqliteErrorMessage(dbPath, sql, baseMessage) {
-    let detail = `agent-harness runtime SQLite (${dbPath}): ${baseMessage}`;
-    if (sql && runtimeSqliteErrorShouldIncludeSql(baseMessage)) {
-        const sqlPreview = sql.replace(/\s+/g, " ").trim();
-        const truncated = sqlPreview.length > 220 ? `${sqlPreview.slice(0, 220)}…` : sqlPreview;
-        detail += ` [sql=${truncated}]`;
-    }
-    return detail;
-}
-function throwWrappedRuntimeSqliteError(dbPath, sql, error) {
-    const base = error instanceof Error ? error.message : String(error);
-    const wrapped = new Error(formatRuntimeSqliteErrorMessage(dbPath, sql, base));
-    wrapped.cause = error;
-    throw wrapped;
-}
-function collectErrorMessages(error) {
-    const messages = [];
-    let current = error;
-    while (current instanceof Error) {
-        messages.push(current.message);
-        current = current.cause;
-    }
-    if (typeof current === "string" && current.length > 0) {
-        messages.push(current);
-    }
-    return messages;
-}
-function isSqliteBusyError(error) {
-    return collectErrorMessages(error).some((message) => /SQLITE_BUSY|database is locked/i.test(message));
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-function buildWhereClause(filters) {
-    const active = filters.filter(([, value]) => value !== undefined);
-    if (active.length === 0) {
-        return { clause: "", args: [] };
-    }
-    return {
-        clause: ` WHERE ${active.map(([sql]) => sql).join(" AND ")}`,
-        args: active.map(([, value]) => value),
-    };
-}
 async function selectProtectedSessionIds(dbPath) {
     if (!(await fileExists(dbPath))) {
         return [];
@@ -141,37 +70,20 @@ export class SqlitePersistence {
     }
     async rawExecute(sql, args) {
         const client = await this.getClient();
-        for (let attempt = 0;; attempt += 1) {
-            try {
-                if (args) {
-                    await client.execute(sql, args);
-                    return;
-                }
-                await client.execute(sql);
+        await executeWithBusyRetry(client, this.dbPath, sql, args, async () => {
+            if (args) {
+                await client.execute(sql, args);
                 return;
             }
-            catch (error) {
-                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
-                    throwWrappedRuntimeSqliteError(this.dbPath, sql, error);
-                }
-                await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
-            }
-        }
+            await client.execute(sql);
+        });
     }
     async rawSelectAll(sql, args) {
         const client = await this.getClient();
-        for (let attempt = 0;; attempt += 1) {
-            try {
-                const result = args ? await client.execute(sql, args) : await client.execute(sql);
-                return result.rows.map((row) => asRow(row));
-            }
-            catch (error) {
-                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
-                    throwWrappedRuntimeSqliteError(this.dbPath, sql, error);
-                }
-                await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
-            }
-        }
+        return executeWithBusyRetry(client, this.dbPath, sql, args, async () => {
+            const result = args ? await client.execute(sql, args) : await client.execute(sql);
+            return result.rows.map((row) => asRow(row));
+        });
     }
     async ensureInitialized() {
         if (this.initialized) {

package/dist/{request-events.d.ts → projections/request-events.d.ts}

@@ -1,4 +1,4 @@
-import type { HarnessEvent, RequestDataEvent, RequestEventSnapshot, RequestExecutionStep, RequestPlanState, RequestResult, RuntimeSurfaceItem, UpstreamRuntimeEvent } from "./contracts/types.js";
+import type { HarnessEvent, RequestDataEvent, RequestEventSnapshot, RequestExecutionStep, RequestPlanState, RequestResult, RuntimeSurfaceItem, UpstreamRuntimeEvent } from "../contracts/types.js";
 type StreamEventItem = {
     type: "event";
     event: HarnessEvent;

package/dist/{upstream-events.js → projections/upstream-events.js}

@@ -1,4 +1,4 @@
-import { extractInterruptPayload, extractReasoningStreamOutput, extractToolResult } from "./runtime/parsing/index.js";
+import { extractInterruptPayload, extractReasoningStreamOutput, extractToolResult } from "../runtime/parsing/stream-event-parsing.js";
 function asObject(value) {
     return typeof value === "object" && value !== null ? value : null;
 }

package/dist/protocol/a2a/http-discovery.d.ts

@@ -0,0 +1,39 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { AgentHarnessRuntime } from "../../runtime/harness.js";
+import type { A2aAgentCard, A2aExtendedAgentCard, A2aHttpServerOptions } from "./http.js";
+export declare const SUPPORTED_A2A_VERSIONS: readonly ["1.0", "0.3"];
+export type A2aServiceParameters = {
+    version: string;
+    extensions: string[];
+};
+export declare function normalizePath(value: string | undefined, fallback: string): string;
+export declare function writeJson(response: ServerResponse, statusCode: number, payload: unknown): void;
+export declare function writeA2aDiscoveryHeaders(response: ServerResponse): void;
+export declare function writeOptionalAgentCardIntegrityHeaders(response: ServerResponse, options: {
+    registryUrls?: string[];
+    agentCardSignature?: A2aHttpServerOptions["agentCardSignature"];
+}): void;
+export declare function parseA2aServiceParameters(requestUrl: URL, request: IncomingMessage): A2aServiceParameters | null;
+export declare function acceptsSse(request: IncomingMessage): boolean;
+export declare function buildAgentCard(runtime: AgentHarnessRuntime, options: Required<Pick<A2aHttpServerOptions, "agentName" | "agentDescription">> & {
+    rpcUrl: string;
+    documentationUrl?: string;
+    provider?: {
+        organization?: string;
+        url?: string;
+    };
+    defaultAgentId?: string;
+    registryUrls?: string[];
+    agentCardSignature?: A2aHttpServerOptions["agentCardSignature"];
+}): A2aAgentCard;
+export declare function buildExtendedAgentCard(runtime: AgentHarnessRuntime, options: Required<Pick<A2aHttpServerOptions, "agentName" | "agentDescription">> & {
+    rpcUrl: string;
+    documentationUrl?: string;
+    provider?: {
+        organization?: string;
+        url?: string;
+    };
+    defaultAgentId?: string;
+    registryUrls?: string[];
+    agentCardSignature?: A2aHttpServerOptions["agentCardSignature"];
+}): A2aExtendedAgentCard;