@botbotgo/agent-harness 0.0.309 → 0.0.311

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;

package/dist/protocol/a2a/http-discovery.js

@@ -0,0 +1,178 @@
+import { AGENT_HARNESS_VERSION } from "../../package-version.js";
+export const SUPPORTED_A2A_VERSIONS = ["1.0", "0.3"];
+export function normalizePath(value, fallback) {
+    const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
+    return source.startsWith("/") ? source : `/${source}`;
+}
+export function writeJson(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader("content-type", "application/json; charset=utf-8");
+    response.end(JSON.stringify(payload));
+}
+export function writeA2aDiscoveryHeaders(response) {
+    response.setHeader("A2A-Version", "1.0");
+    response.setHeader("A2A-Supported-Versions", SUPPORTED_A2A_VERSIONS.join(", "));
+}
+function normalizeNonEmptyStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value.map((item) => item.trim()).filter((item) => item.length > 0);
+    return items.length > 0 ? items : undefined;
+}
+function buildDiscoveryMetadata(options) {
+    const registryUrls = normalizeNonEmptyStringArray(options.registryUrls);
+    const signature = options.agentCardSignature?.signature?.trim();
+    const algorithm = options.agentCardSignature?.algorithm?.trim();
+    const keyId = options.agentCardSignature?.keyId?.trim();
+    if (!registryUrls && (!signature || !algorithm)) {
+        return undefined;
+    }
+    return {
+        ...(registryUrls ? { registryUrls } : {}),
+        ...(signature && algorithm
+            ? {
+                signedAgentCard: {
+                    algorithm,
+                    signature,
+                    ...(keyId ? { keyId } : {}),
+                },
+            }
+            : {}),
+    };
+}
+export function writeOptionalAgentCardIntegrityHeaders(response, options) {
+    const registryUrls = normalizeNonEmptyStringArray(options.registryUrls);
+    if (registryUrls) {
+        response.setHeader("X-A2A-Registry-Urls", registryUrls.join(", "));
+    }
+    const signature = options.agentCardSignature?.signature?.trim();
+    const algorithm = options.agentCardSignature?.algorithm?.trim();
+    const keyId = options.agentCardSignature?.keyId?.trim();
+    if (signature && algorithm) {
+        response.setHeader("X-A2A-Agent-Card-Signature", signature);
+        response.setHeader("X-A2A-Agent-Card-Alg", algorithm);
+        if (keyId) {
+            response.setHeader("X-A2A-Agent-Card-Key-Id", keyId);
+        }
+    }
+}
+function readServiceParameter(requestUrl, request, name) {
+    const headerValue = request.headers[name.toLowerCase()];
+    if (typeof headerValue === "string") {
+        return headerValue;
+    }
+    if (Array.isArray(headerValue)) {
+        return headerValue.join(",");
+    }
+    return requestUrl.searchParams.get(name) ?? undefined;
+}
+export function parseA2aServiceParameters(requestUrl, request) {
+    const requestedVersion = readServiceParameter(requestUrl, request, "A2A-Version")?.trim() ?? "";
+    const normalizedVersion = requestedVersion.length === 0 ? "0.3" : requestedVersion;
+    if (!SUPPORTED_A2A_VERSIONS.includes(normalizedVersion)) {
+        return null;
+    }
+    const requestedExtensions = readServiceParameter(requestUrl, request, "A2A-Extensions") ?? "";
+    return {
+        version: normalizedVersion,
+        extensions: requestedExtensions
+            .split(",")
+            .map((entry) => entry.trim())
+            .filter((entry) => entry.length > 0),
+    };
+}
+export function acceptsSse(request) {
+    const accept = request.headers.accept;
+    if (accept === undefined) {
+        return false;
+    }
+    const values = Array.isArray(accept) ? accept : [accept];
+    return values.some((value) => value.includes("text/event-stream"));
+}
+export function buildAgentCard(runtime, options) {
+    const inventory = runtime.describeWorkspaceInventory();
+    const discovery = buildDiscoveryMetadata({
+        registryUrls: options.registryUrls,
+        agentCardSignature: options.agentCardSignature,
+    });
+    const skills = inventory.agents.map((agent) => ({
+        id: agent.id,
+        name: agent.id,
+        description: agent.description || `Agent ${agent.id}`,
+        tags: ["agent-harness", agent.parentAgentId ? "subagent" : "agent"],
+        examples: [`Send a task to ${agent.id}.`],
+    }));
+    return {
+        name: options.agentName,
+        description: options.agentDescription,
+        version: AGENT_HARNESS_VERSION,
+        protocolVersion: "1.0",
+        url: options.rpcUrl,
+        preferredTransport: "JSONRPC",
+        supportedInterfaces: [
+            {
+                url: options.rpcUrl,
+                protocolBinding: "JSONRPC",
+                protocolVersion: "1.0",
+            },
+            {
+                url: options.rpcUrl,
+                protocolBinding: "JSONRPC",
+                protocolVersion: "0.3",
+            },
+        ],
+        capabilities: {
+            streaming: true,
+            pushNotifications: true,
+            extendedAgentCard: true,
+        },
+        defaultInputModes: ["text/plain"],
+        defaultOutputModes: ["text/plain"],
+        skills,
+        ...(discovery
+            ? {
+                metadata: {
+                    agentHarness: {
+                        discovery,
+                    },
+                },
+            }
+            : {}),
+        ...(options.documentationUrl ? { documentationUrl: options.documentationUrl } : {}),
+        ...(options.provider ? { provider: options.provider } : {}),
+        ...(options.defaultAgentId ? { defaultAgentId: options.defaultAgentId } : {}),
+    };
+}
+export function buildExtendedAgentCard(runtime, options) {
+    const inventory = runtime.describeWorkspaceInventory();
+    const card = buildAgentCard(runtime, options);
+    const discovery = buildDiscoveryMetadata({
+        registryUrls: options.registryUrls,
+        agentCardSignature: options.agentCardSignature,
+    });
+    return {
+        ...card,
+        metadata: {
+            agentHarness: {
+                runtime: {
+                    product: "agent-harness",
+                    protocolSurface: "a2a-http",
+                    ...(options.defaultAgentId ? { defaultAgentId: options.defaultAgentId } : {}),
+                },
+                protocolSurfaces: ["A2A", "ACP", "AG-UI", "runtime MCP"],
+                inventory: {
+                    agentCount: inventory.agents.length,
+                    subagentCount: inventory.agents.filter((agent) => Boolean(agent.parentAgentId)).length,
+                },
+                ...(discovery ? { discovery } : {}),
+                agents: inventory.agents.map((agent) => ({
+                    id: agent.id,
+                    name: agent.id,
+                    description: agent.description || `Agent ${agent.id}`,
+                    kind: agent.parentAgentId ? "subagent" : "agent",
+                })),
+            },
+        },
+    };
+}

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

@@ -0,0 +1,28 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { AgentHarnessRuntime } from "../../runtime/harness.js";
+import { type A2aServiceParameters } from "./http-discovery.js";
+import type { A2aAgentCardBuildOptions, A2aHttpServerOptions, A2aJsonRpcRequest, A2aJsonRpcResponse, PendingA2aPushNotificationConfig, StoredA2aPushNotificationConfig } from "./http.js";
+type PushNotificationRegistry = {
+    register: (taskId: string, config: PendingA2aPushNotificationConfig) => StoredA2aPushNotificationConfig;
+    list: (taskId: string) => StoredA2aPushNotificationConfig[];
+    get: (taskId: string, configId: string) => StoredA2aPushNotificationConfig | undefined;
+    delete: (taskId: string, configId: string) => boolean;
+    dispatch: (taskId: string) => Promise<void>;
+};
+type HandleA2aJsonRpcRequestInput = {
+    runtime: AgentHarnessRuntime;
+    request: IncomingMessage;
+    response: ServerResponse;
+    payload: A2aJsonRpcRequest;
+    serviceParameters: A2aServiceParameters;
+    serverOptions: A2aHttpServerOptions;
+    buildCardOptions: () => A2aAgentCardBuildOptions;
+    pushNotifications: PushNotificationRegistry;
+};
+export declare function toError(id: string | number | null, code: number, message: string, data?: unknown): A2aJsonRpcResponse;
+export declare function readRequestBody(request: IncomingMessage): Promise<string>;
+export declare function createPushNotificationRegistry(runtime: AgentHarnessRuntime, createId: () => string): PushNotificationRegistry & {
+    unsubscribe: () => void;
+};
+export declare function handleA2aJsonRpcRequest(input: HandleA2aJsonRpcRequestInput): Promise<void>;
+export {};