@botbotgo/agent-harness 0.0.308 → 0.0.310

package/dist/protocol/a2a/http.js

@@ -1,910 +1,7 @@
 import { createServer } from "node:http";
-import { AGENT_HARNESS_VERSION } from "../../package-version.js";
 import { createPersistentId } from "../../utils/id.js";
-const SUPPORTED_A2A_VERSIONS = ["1.0", "0.3"];
-function normalizePath(value, fallback) {
-    const source = typeof value === "string" && value.trim().length > 0 ? value.trim() : fallback;
-    return source.startsWith("/") ? source : `/${source}`;
-}
-function writeJson(response, statusCode, payload) {
-    response.statusCode = statusCode;
-    response.setHeader("content-type", "application/json; charset=utf-8");
-    response.end(JSON.stringify(payload));
-}
-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 } : {}),
-                },
-            }
-            : {}),
-    };
-}
-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 writeSseHeaders(response) {
-    response.statusCode = 200;
-    response.setHeader("content-type", "text/event-stream; charset=utf-8");
-    response.setHeader("cache-control", "no-cache, no-transform");
-    response.setHeader("connection", "keep-alive");
-}
-function writeSseEvent(response, event, payload) {
-    return new Promise((resolve, reject) => {
-        response.write(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`, (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
-function readRequestBody(request) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        request.on("data", (chunk) => {
-            chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        });
-        request.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
-        request.on("error", reject);
-    });
-}
-function toError(id, code, message, data) {
-    return {
-        jsonrpc: "2.0",
-        id,
-        error: {
-            code,
-            message,
-            ...(data === undefined ? {} : { data }),
-        },
-    };
-}
-function toSuccess(id, result) {
-    return {
-        jsonrpc: "2.0",
-        id,
-        result,
-    };
-}
-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;
-}
-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),
-    };
-}
-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"));
-}
-function parseTextPart(part) {
-    if (!part || typeof part !== "object" || Array.isArray(part)) {
-        return null;
-    }
-    const typed = part;
-    if (typeof typed.text !== "string"
-        || typed.text.trim().length === 0
-        || (typed.type !== undefined && typed.type !== "text")) {
-        return null;
-    }
-    return typed.text;
-}
-function normalizeUserRole(role) {
-    return typeof role === "string" ? role.toLowerCase().replace(/^role_/, "") : "";
-}
-function parseMessageSendParams(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params)) {
-        throw new Error("A2A message/send requires params object.");
-    }
-    const typed = params;
-    const message = typed.message;
-    if (!message || typeof message !== "object" || Array.isArray(message)) {
-        throw new Error("A2A message/send requires `message`.");
-    }
-    const typedMessage = message;
-    const role = normalizeUserRole(typedMessage.role);
-    if (role !== "user") {
-        throw new Error("A2A message/send currently supports only `user` / `ROLE_USER` role messages.");
-    }
-    const parts = Array.isArray(typedMessage.parts) ? typedMessage.parts : [];
-    const textParts = parts.map(parseTextPart).filter((item) => Boolean(item));
-    if (textParts.length === 0) {
-        throw new Error("A2A message/send requires at least one text part.");
-    }
-    const sessionId = typeof typed.contextId === "string" && typed.contextId.trim().length > 0
-        ? typed.contextId.trim()
-        : typeof typedMessage.contextId === "string" && typedMessage.contextId.trim().length > 0
-            ? typedMessage.contextId.trim()
-            : undefined;
-    const agentId = typeof typed.agentId === "string" && typed.agentId.trim().length > 0
-        ? typed.agentId.trim()
-        : undefined;
-    const metadata = typed.metadata;
-    const invocation = metadata && typeof metadata === "object" && !Array.isArray(metadata)
-        ? metadata
-        : undefined;
-    const configuration = typed.configuration;
-    const nestedPushNotificationConfig = configuration && typeof configuration === "object" && !Array.isArray(configuration)
-        ? configuration.pushNotificationConfig
-            ?? configuration.taskPushNotificationConfig
-        : undefined;
-    const pushNotificationConfig = parsePendingPushNotificationConfig(typed.pushNotificationConfig ?? nestedPushNotificationConfig);
-    return {
-        input: textParts.join("\n\n"),
-        ...(agentId ? { agentId } : {}),
-        ...(sessionId ? { sessionId } : {}),
-        ...(invocation ? { invocation } : {}),
-        ...(pushNotificationConfig ? { pushNotificationConfig } : {}),
-    };
-}
-function parsePushNotificationAuthenticationInfo(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return undefined;
-    }
-    const typed = value;
-    const schemes = Array.isArray(typed.schemes)
-        ? typed.schemes
-            .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
-            .map((entry) => entry.trim())
-        : [];
-    if (schemes.length === 0) {
-        return undefined;
-    }
-    return {
-        schemes,
-        ...(typeof typed.credentials === "string" && typed.credentials.trim().length > 0
-            ? { credentials: typed.credentials.trim() }
-            : {}),
-    };
-}
-function parsePendingPushNotificationConfig(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return undefined;
-    }
-    const typed = value;
-    const rawUrl = typeof typed.url === "string" ? typed.url.trim() : "";
-    if (rawUrl.length === 0) {
-        throw new Error("A2A push notification config requires `url`.");
-    }
-    const parsedUrl = new URL(rawUrl);
-    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
-        throw new Error("A2A push notification config requires an http or https URL.");
-    }
-    const authentication = parsePushNotificationAuthenticationInfo(typed.authentication);
-    return {
-        url: parsedUrl.toString(),
-        ...(typeof typed.id === "string" && typed.id.trim().length > 0 ? { id: typed.id.trim() } : {}),
-        ...(typeof typed.token === "string" && typed.token.trim().length > 0 ? { token: typed.token.trim() } : {}),
-        ...(authentication ? { authentication } : {}),
-    };
-}
-function attachServiceParameters(invocation, serviceParameters) {
-    return {
-        ...(invocation ?? {}),
-        protocol: {
-            ...(invocation?.protocol && typeof invocation.protocol === "object" && !Array.isArray(invocation.protocol)
-                ? invocation.protocol
-                : {}),
-            a2a: {
-                version: serviceParameters.version,
-                ...(serviceParameters.extensions.length > 0 ? { extensions: serviceParameters.extensions } : {}),
-            },
-        },
-    };
-}
-function parseTaskLocatorParams(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params)) {
-        throw new Error("A2A task lookup requires params object.");
-    }
-    const typed = params;
-    const taskId = typeof typed.id === "string" && typed.id.trim().length > 0
-        ? typed.id.trim()
-        : typeof typed.taskId === "string" && typed.taskId.trim().length > 0
-            ? typed.taskId.trim()
-            : "";
-    if (!taskId) {
-        throw new Error("A2A task lookup requires `id`.");
-    }
-    return { taskId };
-}
-function parseTaskListParams(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params)) {
-        return { limit: 20 };
-    }
-    const typed = params;
-    const rawLimit = typeof typed.pageSize === "number" && Number.isFinite(typed.pageSize)
-        ? typed.pageSize
-        : typeof typed.limit === "number" && Number.isFinite(typed.limit)
-            ? typed.limit
-            : 20;
-    const limitValue = typeof rawLimit === "number" && Number.isFinite(rawLimit)
-        ? Math.max(1, Math.min(100, Math.trunc(rawLimit)))
-        : 20;
-    return {
-        ...(typeof typed.agentId === "string" && typed.agentId.trim().length > 0 ? { agentId: typed.agentId.trim() } : {}),
-        ...(typeof typed.contextId === "string" && typed.contextId.trim().length > 0 ? { contextId: typed.contextId.trim() } : {}),
-        ...(typeof typed.status === "string" && typed.status.trim().length > 0
-            ? { state: typed.status.trim() }
-            : typeof typed.state === "string" && typed.state.trim().length > 0
-                ? { state: typed.state.trim() }
-                : {}),
-        ...(typeof typed.pageToken === "string" && typed.pageToken.trim().length > 0
-            ? { cursor: typed.pageToken.trim() }
-            : typeof typed.cursor === "string" && typed.cursor.trim().length > 0
-                ? { cursor: typed.cursor.trim() }
-                : {}),
-        limit: limitValue,
-    };
-}
-function parsePushNotificationLocatorParams(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params)) {
-        throw new Error("A2A push notification lookup requires params object.");
-    }
-    const typed = params;
-    const taskId = typeof typed.taskId === "string" && typed.taskId.trim().length > 0 ? typed.taskId.trim() : "";
-    const configId = typeof typed.id === "string" && typed.id.trim().length > 0 ? typed.id.trim() : "";
-    if (!taskId) {
-        throw new Error("A2A push notification lookup requires `taskId`.");
-    }
-    if (!configId) {
-        throw new Error("A2A push notification lookup requires `id`.");
-    }
-    return { taskId, configId };
-}
-function parsePushNotificationListParams(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params)) {
-        throw new Error("A2A push notification list requires params object.");
-    }
-    const typed = params;
-    const taskId = typeof typed.taskId === "string" && typed.taskId.trim().length > 0 ? typed.taskId.trim() : "";
-    if (!taskId) {
-        throw new Error("A2A push notification list requires `taskId`.");
-    }
-    const pageSize = typeof typed.pageSize === "number" && Number.isFinite(typed.pageSize)
-        ? Math.max(1, Math.min(100, Math.trunc(typed.pageSize)))
-        : 20;
-    return {
-        taskId,
-        pageSize,
-        ...(typeof typed.pageToken === "string" && typed.pageToken.trim().length > 0 ? { pageToken: typed.pageToken.trim() } : {}),
-    };
-}
-function parseCreatePushNotificationConfigParams(params) {
-    if (!params || typeof params !== "object" || Array.isArray(params)) {
-        throw new Error("A2A push notification create requires params object.");
-    }
-    const typed = params;
-    const taskId = typeof typed.taskId === "string" && typed.taskId.trim().length > 0 ? typed.taskId.trim() : "";
-    if (!taskId) {
-        throw new Error("A2A push notification create requires `taskId`.");
-    }
-    const config = parsePendingPushNotificationConfig(typed.pushNotificationConfig ?? typed.config ?? typed);
-    if (!config) {
-        throw new Error("A2A push notification create requires a config object.");
-    }
-    return { taskId, config };
-}
-function mapRequestState(state) {
-    switch (state) {
-        case "queued":
-            return "TASK_STATE_SUBMITTED";
-        case "running":
-            return "TASK_STATE_WORKING";
-        case "waiting_for_approval":
-            return "TASK_STATE_INPUT_REQUIRED";
-        case "completed":
-            return "TASK_STATE_COMPLETED";
-        case "cancelled":
-            return "TASK_STATE_CANCELED";
-        case "failed":
-        default:
-            return "TASK_STATE_FAILED";
-    }
-}
-function mapTaskStatusToRequestState(state) {
-    switch (state?.toLowerCase().replace(/^task_state_/, "").replace(/_/g, "-")) {
-        case "submitted":
-            return "queued";
-        case "working":
-            return "running";
-        case "input-required":
-            return "waiting_for_approval";
-        case "completed":
-            return "completed";
-        case "failed":
-            return "failed";
-        case "canceled":
-        case "cancelled":
-            return "cancelled";
-        default:
-            return undefined;
-    }
-}
-function toTextParts(text) {
-    if (typeof text !== "string" || text.length === 0) {
-        return [];
-    }
-    return [{ text, mediaType: "text/plain" }];
-}
-function contentToText(content) {
-    if (typeof content === "string") {
-        return content;
-    }
-    if (!Array.isArray(content)) {
-        return undefined;
-    }
-    const text = content
-        .filter((part) => part.type === "text" && typeof part.text === "string")
-        .map((part) => part.text)
-        .join("\n\n")
-        .trim();
-    return text.length > 0 ? text : undefined;
-}
-function toSessionRecord(session) {
-    if (!session) {
-        return null;
-    }
-    return {
-        sessionId: session.sessionId,
-        entryAgentId: session.entryAgentId,
-        currentAgentId: session.currentAgentId,
-        currentState: session.currentState,
-        latestRequestId: session.latestRequestId,
-        createdAt: session.createdAt,
-        updatedAt: session.updatedAt,
-        messages: session.messages,
-        requests: session.requests.map((request) => ({
-            requestId: request.requestId,
-            sessionId: request.sessionId,
-            agentId: request.agentId,
-            executionMode: request.executionMode,
-            adapterKind: request.adapterKind,
-            createdAt: request.createdAt,
-            updatedAt: request.updatedAt,
-            state: request.state,
-            checkpointRef: request.checkpointRef,
-            resumable: request.resumable,
-            startedAt: request.startedAt,
-            endedAt: request.endedAt,
-            lastActivityAt: request.lastActivityAt,
-            currentAgentId: request.currentAgentId,
-            delegationChain: request.delegationChain,
-            runtimeSnapshot: request.runtimeSnapshot,
-            traceItems: request.traceItems,
-            runtimeTimeline: request.runtimeTimeline,
-        })),
-        pendingDecision: session.pendingDecision,
-    };
-}
-function toRequestRecord(request) {
-    if (!request) {
-        return null;
-    }
-    return {
-        requestId: request.requestId,
-        sessionId: request.sessionId,
-        agentId: request.agentId,
-        executionMode: request.executionMode,
-        adapterKind: request.adapterKind,
-        createdAt: request.createdAt,
-        updatedAt: request.updatedAt,
-        state: request.state,
-        checkpointRef: request.checkpointRef,
-        resumable: request.resumable,
-        startedAt: request.startedAt,
-        endedAt: request.endedAt,
-        lastActivityAt: request.lastActivityAt,
-        currentAgentId: request.currentAgentId,
-        delegationChain: request.delegationChain,
-        runtimeSnapshot: request.runtimeSnapshot,
-        traceItems: request.traceItems,
-        runtimeTimeline: request.runtimeTimeline,
-    };
-}
-function buildTaskFromSessionAndRequest(session, request, approvals, output, failureMessage) {
-    if (!session || !request) {
-        return null;
-    }
-    const latestUserMessage = [...session.messages].reverse().find((message) => message.role === "user");
-    const latestAgentMessage = [...session.messages].reverse().find((message) => message.role === "assistant");
-    const approval = approvals.find((item) => item.status === "pending");
-    const latestAgentText = contentToText(latestAgentMessage?.content);
-    const latestUserText = contentToText(latestUserMessage?.content);
-    const statusText = request.state === "waiting_for_approval"
-        ? approval
-            ? `Approval required for tool ${approval.toolName}.`
-            : "Approval required."
-        : output ?? latestAgentText ?? failureMessage;
-    return {
-        id: request.requestId,
-        contextId: session.sessionId,
-        kind: "task",
-        status: {
-            state: mapRequestState(request.state),
-            timestamp: request.updatedAt,
-            ...(statusText ? {
-                message: {
-                    role: "ROLE_AGENT",
-                    messageId: `${request.requestId}:status`,
-                    parts: toTextParts(statusText),
-                },
-            } : {}),
-        },
-        history: [
-            ...(latestUserText
-                ? [{
-                        role: "ROLE_USER",
-                        messageId: `${request.requestId}:user`,
-                        parts: toTextParts(latestUserText),
-                    }]
-                : []),
-            ...(latestAgentText
-                ? [{
-                        role: "ROLE_AGENT",
-                        messageId: `${request.requestId}:agent`,
-                        parts: toTextParts(latestAgentText),
-                    }]
-                : []),
-        ],
-        artifacts: [],
-        metadata: {
-            agentId: request.agentId,
-            sessionId: session.sessionId,
-            requestId: request.requestId,
-            state: request.state,
-            approvalIds: approvals.map((item) => item.approvalId),
-        },
-    };
-}
-async function buildTaskFromRuntime(runtime, requestId) {
-    const request = await runtime.getRequest(requestId);
-    if (!request) {
-        return null;
-    }
-    const session = await runtime.getSessionRecord(request.sessionId);
-    const approvals = await runtime.listApprovals({ sessionId: request.sessionId, requestId: request.requestId });
-    return buildTaskFromSessionAndRequest(toSessionRecord(session), toRequestRecord(request), approvals);
-}
-async function hydrateTaskStateFromEvents(runtime, task) {
-    if (!task) {
-        return null;
-    }
-    const events = await runtime.listRequestEvents(task.contextId, task.id);
-    const lastStateChange = [...events].reverse().find((event) => event.eventType === "request.state.changed");
-    const observedState = typeof lastStateChange?.payload?.state === "string" ? lastStateChange.payload.state : undefined;
-    if (!observedState) {
-        return task;
-    }
-    return {
-        ...task,
-        status: {
-            ...task.status,
-            state: mapRequestState(observedState),
-        },
-        metadata: {
-            ...task.metadata,
-            state: observedState,
-        },
-    };
-}
-async function listTasksFromRuntime(runtime, params) {
-    const runState = mapTaskStatusToRequestState(params.state);
-    const requests = await runtime.listRequests({
-        ...(params.agentId ? { agentId: params.agentId } : {}),
-        ...(params.contextId ? { sessionId: params.contextId } : {}),
-        ...(runState ? { state: runState } : {}),
-    });
-    const startIndex = params.cursor ? Number.parseInt(Buffer.from(params.cursor, "base64url").toString("utf8"), 10) || 0 : 0;
-    const page = requests.slice(startIndex, startIndex + params.limit);
-    const tasks = (await Promise.all(page.map((request) => buildTaskFromRuntime(runtime, request.requestId)))).filter((task) => Boolean(task));
-    const nextIndex = startIndex + page.length;
-    const nextPageToken = nextIndex < requests.length ? Buffer.from(String(nextIndex), "utf8").toString("base64url") : "";
-    return {
-        tasks,
-        pageSize: params.limit,
-        totalSize: requests.length,
-        nextPageToken,
-        ...(nextPageToken ? { nextCursor: nextPageToken } : {}),
-    };
-}
-function buildAgentCard(runtime, options) {
-    const inventory = runtime.describeWorkspaceInventory();
-    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,
-        // Older JSON-RPC clients may still read these top-level fields; A2A v1.0 discovery uses `supportedInterfaces`.
-        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,
-        ...(buildDiscoveryMetadata({
-            registryUrls: options.registryUrls,
-            agentCardSignature: options.agentCardSignature,
-        })
-            ? {
-                metadata: {
-                    agentHarness: {
-                        discovery: buildDiscoveryMetadata({
-                            registryUrls: options.registryUrls,
-                            agentCardSignature: options.agentCardSignature,
-                        }),
-                    },
-                },
-            }
-            : {}),
-        ...(options.documentationUrl ? { documentationUrl: options.documentationUrl } : {}),
-        ...(options.provider ? { provider: options.provider } : {}),
-        ...(options.defaultAgentId ? { defaultAgentId: options.defaultAgentId } : {}),
-    };
-}
-function buildExtendedAgentCard(runtime, options) {
-    const inventory = runtime.describeWorkspaceInventory();
-    const card = buildAgentCard(runtime, options);
-    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,
-                },
-                ...(buildDiscoveryMetadata({
-                    registryUrls: options.registryUrls,
-                    agentCardSignature: options.agentCardSignature,
-                })
-                    ? {
-                        discovery: buildDiscoveryMetadata({
-                            registryUrls: options.registryUrls,
-                            agentCardSignature: options.agentCardSignature,
-                        }),
-                    }
-                    : {}),
-                agents: inventory.agents.map((agent) => ({
-                    id: agent.id,
-                    name: agent.id,
-                    description: agent.description || `Agent ${agent.id}`,
-                    kind: agent.parentAgentId ? "subagent" : "agent",
-                })),
-            },
-        },
-    };
-}
-function isV1Method(method) {
-    return /^[A-Z]/.test(method);
-}
-function toSendMessageResult(method, task) {
-    if (!task || !isV1Method(method)) {
-        return task;
-    }
-    return { task };
-}
-function toStatusUpdate(task) {
-    return {
-        taskId: task.id,
-        contextId: task.contextId,
-        kind: "status-update",
-        status: task.status,
-        final: isTerminalTaskState(task.status.state),
-        metadata: task.metadata,
-    };
-}
-function toStreamingResult(method, task, mode) {
-    if (!task) {
-        return null;
-    }
-    if (!isV1Method(method)) {
-        return task;
-    }
-    if (mode === "status-update") {
-        return {
-            statusUpdate: toStatusUpdate(task),
-        };
-    }
-    return { task };
-}
-function withStreamingStatusText(task, text) {
-    if (!task || typeof text !== "string" || text.length === 0) {
-        return task;
-    }
-    return {
-        ...task,
-        status: {
-            ...task.status,
-            message: {
-                role: "ROLE_AGENT",
-                messageId: `${task.id}:status`,
-                parts: toTextParts(text),
-            },
-        },
-    };
-}
-function withRunResult(task, result, streamedText) {
-    if (!task) {
-        return null;
-    }
-    const statusText = streamedText || result.output;
-    return {
-        ...task,
-        status: {
-            ...task.status,
-            state: mapRequestState(result.state),
-            ...(statusText
-                ? {
-                    message: {
-                        role: "ROLE_AGENT",
-                        messageId: `${task.id}:status`,
-                        parts: toTextParts(statusText),
-                    },
-                }
-                : {}),
-        },
-        metadata: {
-            ...task.metadata,
-            state: result.state,
-        },
-    };
-}
-function isTerminalTaskState(state) {
-    return state === "TASK_STATE_COMPLETED" || state === "TASK_STATE_FAILED" || state === "TASK_STATE_CANCELED";
-}
-function clonePushNotificationConfig(config) {
-    return {
-        id: config.id,
-        taskId: config.taskId,
-        url: config.url,
-        ...(config.token ? { token: config.token } : {}),
-        ...(config.authentication ? { authentication: config.authentication } : {}),
-    };
-}
-function fingerprintTaskForPush(task) {
-    return JSON.stringify({
-        state: task.status.state,
-        timestamp: task.status.timestamp,
-        message: task.status.message,
-    });
-}
-async function sendPushNotification(config, task) {
-    const headers = {
-        "content-type": "application/json",
-    };
-    if (config.token) {
-        headers["x-a2a-notification-token"] = config.token;
-    }
-    const scheme = config.authentication?.schemes[0]?.toLowerCase();
-    if (scheme === "bearer" && config.authentication?.credentials) {
-        headers.authorization = `Bearer ${config.authentication.credentials}`;
-    }
-    else if (scheme === "basic" && config.authentication?.credentials) {
-        headers.authorization = `Basic ${config.authentication.credentials}`;
-    }
-    await fetch(config.url, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({ task }),
-    });
-}
-async function streamTaskUpdates(response, id, method, iterator) {
-    writeSseHeaders(response);
-    for await (const item of iterator) {
-        if (!item.task) {
-            continue;
-        }
-        await writeSseEvent(response, "task-update", toSuccess(id, toStreamingResult(method, item.task, item.mode)));
-    }
-    response.end();
-}
-async function* streamSendMessageTaskUpdates(runtime, options, method) {
-    let requestId;
-    let streamedText = "";
-    let emittedInitialTask = false;
-    for await (const item of runtime.streamEvents(options)) {
-        if (item.type === "event") {
-            requestId = requestId ?? item.event.requestId;
-            if (item.event.eventType === "output.delta" && typeof item.event.payload.content === "string") {
-                streamedText += item.event.payload.content;
-            }
-            if (item.event.eventType === "request.created"
-                || item.event.eventType === "request.state.changed"
-                || item.event.eventType === "output.delta"
-                || item.event.eventType === "approval.requested") {
-                const task = withStreamingStatusText(await buildTaskFromRuntime(runtime, item.event.requestId), streamedText || undefined);
-                if (task) {
-                    yield { task, mode: emittedInitialTask ? "status-update" : "task" };
-                    emittedInitialTask = true;
-                }
-            }
-            continue;
-        }
-        if (item.type === "result") {
-            requestId = item.result.requestId;
-            const task = withRunResult(await buildTaskFromRuntime(runtime, item.result.requestId), item.result, streamedText || item.result.output);
-            yield { task, mode: emittedInitialTask ? "status-update" : "task" };
-            return;
-        }
-        if (item.type === "upstream-event" && requestId) {
-            const task = withStreamingStatusText(await buildTaskFromRuntime(runtime, requestId), streamedText || undefined);
-            if (task) {
-                yield { task, mode: emittedInitialTask ? "status-update" : "task" };
-                emittedInitialTask = true;
-            }
-        }
-    }
-}
-async function streamExistingTaskUpdates(runtime, response, id, method, taskId) {
-    writeSseHeaders(response);
-    let currentTask = await hydrateTaskStateFromEvents(runtime, await buildTaskFromRuntime(runtime, taskId));
-    if (!currentTask) {
-        await writeSseEvent(response, "error", toError(id, -32001, "Task not found."));
-        response.end();
-        return;
-    }
-    await writeSseEvent(response, "task-update", toSuccess(id, toStreamingResult(method, currentTask, "task")));
-    if (isTerminalTaskState(currentTask.status.state)) {
-        response.end();
-        return;
-    }
-    await new Promise((resolve) => {
-        let closed = false;
-        let idleTimer;
-        let lastFingerprint = JSON.stringify({
-            state: currentTask?.status.state,
-            message: currentTask?.status.message,
-        });
-        const armIdleTimer = () => {
-            if (idleTimer) {
-                clearTimeout(idleTimer);
-            }
-            idleTimer = setTimeout(() => {
-                response.end();
-                finish();
-            }, 1_000);
-        };
-        const finish = () => {
-            if (closed) {
-                return;
-            }
-            closed = true;
-            unsubscribe();
-            clearInterval(pollTimer);
-            if (idleTimer) {
-                clearTimeout(idleTimer);
-            }
-            resolve();
-        };
-        const emitLatestTask = async () => {
-            currentTask = await hydrateTaskStateFromEvents(runtime, await buildTaskFromRuntime(runtime, taskId));
-            if (!currentTask) {
-                await writeSseEvent(response, "error", toError(id, -32001, "Task not found."));
-                response.end();
-                finish();
-                return;
-            }
-            const fingerprint = JSON.stringify({
-                state: currentTask.status.state,
-                message: currentTask.status.message,
-            });
-            if (fingerprint !== lastFingerprint) {
-                lastFingerprint = fingerprint;
-                await writeSseEvent(response, "task-update", toSuccess(id, toStreamingResult(method, currentTask, isV1Method(method) ? "status-update" : "task")));
-                armIdleTimer();
-            }
-            if (isTerminalTaskState(currentTask.status.state)) {
-                response.end();
-                finish();
-            }
-        };
-        const unsubscribe = runtime.subscribe((event) => {
-            if (event.requestId !== taskId) {
-                return;
-            }
-            if (event.eventType !== "request.state.changed"
-                && event.eventType !== "output.delta"
-                && event.eventType !== "approval.requested"
-                && event.eventType !== "approval.resolved") {
-                return;
-            }
-            void emitLatestTask();
-        });
-        const pollTimer = setInterval(() => {
-            void emitLatestTask();
-        }, 250);
-        armIdleTimer();
-        response.on("close", finish);
-    });
-}
+import { buildAgentCard, normalizePath, parseA2aServiceParameters, SUPPORTED_A2A_VERSIONS, writeA2aDiscoveryHeaders, writeJson, writeOptionalAgentCardIntegrityHeaders, } from "./http-discovery.js";
+import { createPushNotificationRegistry, handleA2aJsonRpcRequest, readRequestBody, toError } from "./http-rpc.js";
 export async function serveA2aOverHttp(runtime, options = {}) {
     const hostname = options.hostname?.trim() || "127.0.0.1";
     const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
@@ -920,67 +17,7 @@ export async function serveA2aOverHttp(runtime, options = {}) {
         ...(options.registryUrls ? { registryUrls: options.registryUrls } : {}),
         ...(options.agentCardSignature ? { agentCardSignature: options.agentCardSignature } : {}),
     });
-    const pushConfigsByTask = new Map();
-    const registerPushNotificationConfig = (taskId, config) => {
-        const entry = {
-            id: config.id ?? `push-${createPersistentId()}`,
-            taskId,
-            url: config.url,
-            ...(config.token ? { token: config.token } : {}),
-            ...(config.authentication ? { authentication: config.authentication } : {}),
-        };
-        let taskConfigs = pushConfigsByTask.get(taskId);
-        if (!taskConfigs) {
-            taskConfigs = new Map();
-            pushConfigsByTask.set(taskId, taskConfigs);
-        }
-        taskConfigs.set(entry.id, entry);
-        return entry;
-    };
-    const listPushNotificationConfigs = (taskId) => [...(pushConfigsByTask.get(taskId)?.values() ?? [])].sort((left, right) => left.id.localeCompare(right.id));
-    const getPushNotificationConfig = (taskId, configId) => pushConfigsByTask.get(taskId)?.get(configId);
-    const deletePushNotificationConfig = (taskId, configId) => {
-        const taskConfigs = pushConfigsByTask.get(taskId);
-        if (!taskConfigs) {
-            return false;
-        }
-        const deleted = taskConfigs.delete(configId);
-        if (taskConfigs.size === 0) {
-            pushConfigsByTask.delete(taskId);
-        }
-        return deleted;
-    };
-    const dispatchPushNotificationsForTask = async (taskId) => {
-        const task = await hydrateTaskStateFromEvents(runtime, await buildTaskFromRuntime(runtime, taskId));
-        if (!task) {
-            return;
-        }
-        const fingerprint = fingerprintTaskForPush(task);
-        const configs = listPushNotificationConfigs(taskId);
-        await Promise.all(configs.map(async (config) => {
-            if (config.lastFingerprint === fingerprint) {
-                return;
-            }
-            try {
-                await sendPushNotification(config, task);
-                config.lastFingerprint = fingerprint;
-            }
-            catch {
-                // Push delivery is best-effort and should not fail the transport request.
-            }
-        }));
-    };
-    const pushRelevantEventTypes = new Set([
-        "request.state.changed",
-        "approval.requested",
-        "approval.resolved",
-    ]);
-    const unsubscribePushNotifications = runtime.subscribe((event) => {
-        if (!pushRelevantEventTypes.has(event.eventType) || !pushConfigsByTask.has(event.requestId)) {
-            return;
-        }
-        void dispatchPushNotificationsForTask(event.requestId);
-    });
+    const pushNotifications = createPushNotificationRegistry(runtime, createPersistentId);
     const httpServer = createServer(async (request, response) => {
         try {
             const requestUrl = new URL(request.url ?? "/", `http://${hostname}`);
@@ -1039,163 +76,16 @@ export async function serveA2aOverHttp(runtime, options = {}) {
                     return;
                 }
                 try {
-                    if (payload.method === "message/send" || payload.method === "tasks/send" || payload.method === "SendMessage") {
-                        const parsed = parseMessageSendParams(payload.params);
-                        const result = await runtime.run({
-                            agentId: parsed.agentId ?? options.defaultAgentId,
-                            input: parsed.input,
-                            ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
-                            invocation: attachServiceParameters(parsed.invocation, serviceParameters),
-                        });
-                        const session = await runtime.getSessionRecord(result.sessionId);
-                        const requestRecord = await runtime.getRequest(result.requestId);
-                        const approvals = await runtime.listApprovals({ sessionId: result.sessionId, requestId: result.requestId });
-                        const task = buildTaskFromSessionAndRequest(toSessionRecord(session), toRequestRecord(requestRecord), approvals, result.output);
-                        if (task && parsed.pushNotificationConfig) {
-                            registerPushNotificationConfig(task.id, parsed.pushNotificationConfig);
-                            await dispatchPushNotificationsForTask(task.id);
-                        }
-                        writeJson(response, 200, toSuccess(payload.id ?? null, toSendMessageResult(payload.method, task)));
-                        return;
-                    }
-                    if (payload.method === "GetAgentCard") {
-                        writeOptionalAgentCardIntegrityHeaders(response, {
-                            registryUrls: options.registryUrls,
-                            agentCardSignature: options.agentCardSignature,
-                        });
-                        writeJson(response, 200, toSuccess(payload.id ?? null, buildAgentCard(runtime, buildCardOptions())));
-                        return;
-                    }
-                    if (payload.method === "message/stream" || payload.method === "SendStreamingMessage") {
-                        if (!acceptsSse(request)) {
-                            writeJson(response, 406, toError(payload.id ?? null, -32004, "A2A streaming requires `Accept: text/event-stream`."));
-                            return;
-                        }
-                        const parsed = parseMessageSendParams(payload.params);
-                        let registeredPushTaskId;
-                        const sourceIterator = streamSendMessageTaskUpdates(runtime, {
-                            agentId: parsed.agentId ?? options.defaultAgentId,
-                            input: parsed.input,
-                            ...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
-                            invocation: attachServiceParameters(parsed.invocation, serviceParameters),
-                        }, payload.method);
-                        const iterator = (async function* () {
-                            for await (const item of sourceIterator) {
-                                if (item.task && parsed.pushNotificationConfig && !registeredPushTaskId) {
-                                    registeredPushTaskId = item.task.id;
-                                    registerPushNotificationConfig(item.task.id, parsed.pushNotificationConfig);
-                                    await dispatchPushNotificationsForTask(item.task.id);
-                                }
-                                yield item;
-                            }
-                        }());
-                        await streamTaskUpdates(response, payload.id ?? null, payload.method, iterator);
-                        return;
-                    }
-                    if (payload.method === "tasks/get" || payload.method === "GetTask") {
-                        const { taskId } = parseTaskLocatorParams(payload.params);
-                        const task = await buildTaskFromRuntime(runtime, taskId);
-                        if (!task) {
-                            writeJson(response, 200, toError(payload.id ?? null, -32001, "Task not found."));
-                            return;
-                        }
-                        writeJson(response, 200, toSuccess(payload.id ?? null, task));
-                        return;
-                    }
-                    if (payload.method === "tasks/list" || payload.method === "ListTasks") {
-                        const taskList = await listTasksFromRuntime(runtime, parseTaskListParams(payload.params));
-                        writeJson(response, 200, toSuccess(payload.id ?? null, taskList));
-                        return;
-                    }
-                    if (payload.method === "tasks/cancel" || payload.method === "CancelTask") {
-                        const { taskId } = parseTaskLocatorParams(payload.params);
-                        const result = await runtime.cancelRequest({ requestId: taskId, reason: "Cancelled via A2A bridge." });
-                        const task = await buildTaskFromRuntime(runtime, result.requestId);
-                        writeJson(response, 200, toSuccess(payload.id ?? null, task));
-                        return;
-                    }
-                    if (payload.method === "tasks/subscribe" || payload.method === "SubscribeToTask") {
-                        const { taskId } = parseTaskLocatorParams(payload.params);
-                        const task = await buildTaskFromRuntime(runtime, taskId);
-                        if (!task) {
-                            writeJson(response, 200, toError(payload.id ?? null, -32001, "Task not found."));
-                            return;
-                        }
-                        if (payload.method === "SubscribeToTask") {
-                            if (isTerminalTaskState(task.status.state)) {
-                                writeJson(response, 200, toError(payload.id ?? null, -32004, "SubscribeToTask is not supported for tasks in terminal state."));
-                                return;
-                            }
-                            if (!acceptsSse(request)) {
-                                writeJson(response, 406, toError(payload.id ?? null, -32004, "A2A streaming subscriptions require `Accept: text/event-stream`."));
-                                return;
-                            }
-                            await streamExistingTaskUpdates(runtime, response, payload.id ?? null, payload.method, taskId);
-                            return;
-                        }
-                        writeJson(response, 200, toSuccess(payload.id ?? null, {
-                            task,
-                            streamable: false,
-                            pushNotifications: true,
-                            nextPollAfterMs: task.status.state === "TASK_STATE_COMPLETED" || task.status.state === "TASK_STATE_FAILED" || task.status.state === "TASK_STATE_CANCELED"
-                                ? 0
-                                : 1_000,
-                        }));
-                        return;
-                    }
-                    if (payload.method === "CreateTaskPushNotificationConfig") {
-                        const { taskId, config } = parseCreatePushNotificationConfigParams(payload.params);
-                        if (!await buildTaskFromRuntime(runtime, taskId)) {
-                            writeJson(response, 200, toError(payload.id ?? null, -32001, "Task not found."));
-                            return;
-                        }
-                        const created = registerPushNotificationConfig(taskId, config);
-                        await dispatchPushNotificationsForTask(taskId);
-                        writeJson(response, 200, toSuccess(payload.id ?? null, clonePushNotificationConfig(created)));
-                        return;
-                    }
-                    if (payload.method === "GetTaskPushNotificationConfig") {
-                        const { taskId, configId } = parsePushNotificationLocatorParams(payload.params);
-                        const config = getPushNotificationConfig(taskId, configId);
-                        if (!config) {
-                            writeJson(response, 200, toError(payload.id ?? null, -32001, "Push notification config not found."));
-                            return;
-                        }
-                        writeJson(response, 200, toSuccess(payload.id ?? null, clonePushNotificationConfig(config)));
-                        return;
-                    }
-                    if (payload.method === "ListTaskPushNotificationConfigs") {
-                        const { taskId, pageSize, pageToken } = parsePushNotificationListParams(payload.params);
-                        const configs = listPushNotificationConfigs(taskId);
-                        const startIndex = pageToken ? Number.parseInt(Buffer.from(pageToken, "base64url").toString("utf8"), 10) || 0 : 0;
-                        const page = configs.slice(startIndex, startIndex + pageSize).map(clonePushNotificationConfig);
-                        const nextIndex = startIndex + page.length;
-                        const nextPageToken = nextIndex < configs.length ? Buffer.from(String(nextIndex), "utf8").toString("base64url") : "";
-                        const result = {
-                            configs: page,
-                            nextPageToken,
-                        };
-                        writeJson(response, 200, toSuccess(payload.id ?? null, result));
-                        return;
-                    }
-                    if (payload.method === "DeleteTaskPushNotificationConfig") {
-                        const { taskId, configId } = parsePushNotificationLocatorParams(payload.params);
-                        if (!deletePushNotificationConfig(taskId, configId)) {
-                            writeJson(response, 200, toError(payload.id ?? null, -32001, "Push notification config not found."));
-                            return;
-                        }
-                        writeJson(response, 200, toSuccess(payload.id ?? null, { deleted: true, id: configId, taskId }));
-                        return;
-                    }
-                    if (payload.method === "GetExtendedAgentCard") {
-                        writeOptionalAgentCardIntegrityHeaders(response, {
-                            registryUrls: options.registryUrls,
-                            agentCardSignature: options.agentCardSignature,
-                        });
-                        writeJson(response, 200, toSuccess(payload.id ?? null, buildExtendedAgentCard(runtime, buildCardOptions())));
-                        return;
-                    }
-                    writeJson(response, 200, toError(payload.id ?? null, -32601, `Unknown A2A method: ${payload.method}`));
+                    await handleA2aJsonRpcRequest({
+                        runtime,
+                        request,
+                        response,
+                        payload,
+                        serviceParameters,
+                        serverOptions: options,
+                        buildCardOptions,
+                        pushNotifications,
+                    });
                 }
                 catch (error) {
                     writeJson(response, 200, toError(payload.id ?? null, -32000, error instanceof Error ? error.message : String(error)));
@@ -1233,7 +123,7 @@ export async function serveA2aOverHttp(runtime, options = {}) {
         agentCardUrl: `http://${hostname}:${resolvedPort}${agentCardPath}`,
         completed,
         close: async () => {
-            unsubscribePushNotifications();
+            pushNotifications.unsubscribe();
             await new Promise((resolve, reject) => {
                 httpServer.close((error) => {
                     if (error) {