acp-runtime 0.1.0

package/dist/mqttTransport.js

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+import mqtt from "mqtt";
+import { invalidArgument, transportError, validationError } from "./errors.js";
+export const DEFAULT_MQTT_QOS = 1;
+export const DEFAULT_MQTT_TOPIC_PREFIX = "acp/agent";
+function toQos(qos) {
+    if (qos <= 0) {
+        return 0;
+    }
+    if (qos >= 2) {
+        return 2;
+    }
+    return 1;
+}
+function clampQos(qos) {
+    return Math.min(2, Math.max(0, qos));
+}
+function pickString(service, key, fallback) {
+    const value = service?.[key];
+    if (typeof value === "string" && value.trim()) {
+        return value.trim();
+    }
+    return fallback;
+}
+function valueAsNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+export function metadataProperties(message) {
+    const envelope = message.envelope && typeof message.envelope === "object" && !Array.isArray(message.envelope)
+        ? message.envelope
+        : {};
+    const metadata = {};
+    for (const [source, destination] of [
+        ["acp_version", "acp_version"],
+        ["message_class", "acp_message_class"],
+        ["message_id", "acp_message_id"],
+        ["operation_id", "acp_operation_id"],
+        ["sender", "acp_sender"]
+    ]) {
+        const value = envelope[source];
+        if (typeof value === "string" && value.trim()) {
+            metadata[destination] = value.trim();
+        }
+    }
+    return metadata;
+}
+export class MqttTransportClient {
+    broker_url;
+    qos;
+    topic_prefix;
+    timeout_seconds;
+    keepalive_seconds;
+    constructor(brokerUrl, qos = DEFAULT_MQTT_QOS, topicPrefix = DEFAULT_MQTT_TOPIC_PREFIX, timeoutSeconds = 10, keepaliveSeconds = 30) {
+        if (!brokerUrl.trim()) {
+            throw invalidArgument("broker_url must be provided");
+        }
+        this.broker_url = brokerUrl.trim();
+        this.qos = clampQos(qos);
+        this.topic_prefix = topicPrefix.trim().replace(/\/+$/, "") || DEFAULT_MQTT_TOPIC_PREFIX;
+        this.timeout_seconds = Math.max(1, timeoutSeconds);
+        this.keepalive_seconds = Math.max(5, keepaliveSeconds);
+    }
+    static agentIdentifierToken(agentId) {
+        const match = /^agent:(?<name>[^@]+)(?:@(?<domain>.+))?$/.exec(agentId);
+        if (!match?.groups?.name) {
+            throw validationError(`Invalid agent identifier: ${agentId}`);
+        }
+        const base = match.groups.domain ? `${match.groups.name}.${match.groups.domain}` : match.groups.name;
+        const normalized = base
+            .split("")
+            .map((char) => (/^[A-Za-z0-9._-]$/.test(char) ? char : "."))
+            .join("")
+            .split(".")
+            .filter((segment) => segment.length > 0)
+            .join(".")
+            .toLowerCase();
+        return normalized || "unknown";
+    }
+    static topicForAgent(agentId, topicPrefix = DEFAULT_MQTT_TOPIC_PREFIX) {
+        return `${topicPrefix.replace(/\/+$/, "")}/${MqttTransportClient.agentIdentifierToken(agentId)}`;
+    }
+    static buildServiceHint(agentId, brokerUrl, topic, qos = DEFAULT_MQTT_QOS, topicPrefix = DEFAULT_MQTT_TOPIC_PREFIX) {
+        return {
+            broker_url: brokerUrl,
+            topic: topic?.trim() || MqttTransportClient.topicForAgent(agentId, topicPrefix),
+            qos: clampQos(qos)
+        };
+    }
+    connectClient(brokerUrl) {
+        const options = {
+            protocolVersion: 5,
+            keepalive: this.keepalive_seconds,
+            reconnectPeriod: 0,
+            connectTimeout: this.timeout_seconds * 1000
+        };
+        return new Promise((resolve, reject) => {
+            const client = mqtt.connect(brokerUrl, options);
+            const onConnect = () => {
+                cleanup();
+                resolve(client);
+            };
+            const onError = (error) => {
+                cleanup();
+                client.end(true);
+                reject(error);
+            };
+            const cleanup = () => {
+                client.off("connect", onConnect);
+                client.off("error", onError);
+            };
+            client.once("connect", onConnect);
+            client.once("error", onError);
+        });
+    }
+    async publish(message, recipientAgentId, service) {
+        const brokerUrl = pickString(service, "broker_url", this.broker_url);
+        const topic = pickString(service, "topic", MqttTransportClient.topicForAgent(recipientAgentId, this.topic_prefix));
+        const qos = clampQos(valueAsNumber(service?.qos) ?? this.qos);
+        const properties = metadataProperties(message);
+        const client = await this.connectClient(brokerUrl);
+        try {
+            await new Promise((resolve, reject) => {
+                client.publish(topic, JSON.stringify(message), {
+                    qos: toQos(qos),
+                    properties: {
+                        userProperties: properties
+                    }
+                }, (error) => {
+                    if (error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+        catch (error) {
+            throw transportError(`mqtt publish failed: ${String(error)}`);
+        }
+        finally {
+            client.end(true);
+        }
+    }
+    async consume(agentId, handler, service, maxMessages = 0, pollTimeoutMs = 1000) {
+        const brokerUrl = pickString(service, "broker_url", this.broker_url);
+        const topic = pickString(service, "topic", MqttTransportClient.topicForAgent(agentId, this.topic_prefix));
+        const qos = clampQos(valueAsNumber(service?.qos) ?? this.qos);
+        const limit = maxMessages === 0 ? Number.MAX_SAFE_INTEGER : maxMessages;
+        const client = await this.connectClient(brokerUrl);
+        let processed = 0;
+        try {
+            await new Promise((resolve, reject) => {
+                client.subscribe(topic, { qos: toQos(qos) }, (error) => {
+                    if (error instanceof Error) {
+                        reject(error);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            await new Promise((resolve) => {
+                const timeout = setTimeout(() => {
+                    cleanup();
+                    resolve();
+                }, pollTimeoutMs);
+                const cleanup = () => {
+                    clearTimeout(timeout);
+                    client.off("message", onMessage);
+                };
+                const onMessage = async (_topic, payload) => {
+                    if (processed >= limit) {
+                        cleanup();
+                        resolve();
+                        return;
+                    }
+                    try {
+                        const parsed = JSON.parse(payload.toString("utf-8"));
+                        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                            await handler(parsed);
+                        }
+                    }
+                    catch {
+                        // Keep behavior tolerant: invalid messages are ignored.
+                    }
+                    processed += 1;
+                    if (processed >= limit) {
+                        cleanup();
+                        resolve();
+                    }
+                };
+                client.on("message", onMessage);
+            });
+            return processed;
+        }
+        catch (error) {
+            throw transportError(`mqtt consume failed: ${String(error)}`);
+        }
+        finally {
+            client.end(true);
+        }
+    }
+}

package/dist/options.d.ts

@@ -0,0 +1,34 @@
+import { JsonMap } from "./jsonSupport.js";
+import { DeliveryMode } from "./messages.js";
+export interface AcpAgentOptions {
+    storage_dir: string;
+    endpoint?: string;
+    relay_url: string;
+    relay_hints: string[];
+    enterprise_directory_hints: string[];
+    discovery_scheme: string;
+    trust_profile: string;
+    default_delivery_mode: DeliveryMode;
+    http_timeout_seconds: number;
+    allow_insecure_http: boolean;
+    allow_insecure_tls: boolean;
+    mtls_enabled: boolean;
+    ca_file?: string;
+    cert_file?: string;
+    key_file?: string;
+    key_provider: "local" | "vault";
+    vault_url?: string;
+    vault_path?: string;
+    vault_token_env: string;
+    vault_token?: string;
+    amqp_broker_url?: string;
+    amqp_exchange: string;
+    amqp_exchange_type: string;
+    mqtt_broker_url?: string;
+    mqtt_qos: number;
+    mqtt_topic_prefix: string;
+    extra: JsonMap;
+}
+export declare function defaultAgentOptions(): AcpAgentOptions;
+export declare function optionsFromConfigMap(config: JsonMap | undefined): AcpAgentOptions;
+export declare function optionsToConfigMap(options: AcpAgentOptions): JsonMap;

package/dist/options.js

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+export function defaultAgentOptions() {
+    return {
+        storage_dir: ".acp-data",
+        relay_url: "https://localhost:8080",
+        relay_hints: [],
+        enterprise_directory_hints: [],
+        discovery_scheme: "https",
+        trust_profile: "self_asserted",
+        default_delivery_mode: "auto",
+        http_timeout_seconds: 10,
+        allow_insecure_http: false,
+        allow_insecure_tls: false,
+        mtls_enabled: false,
+        key_provider: "local",
+        vault_token_env: "VAULT_TOKEN",
+        amqp_exchange: "acp.exchange",
+        amqp_exchange_type: "direct",
+        mqtt_qos: 1,
+        mqtt_topic_prefix: "acp/agent",
+        extra: {}
+    };
+}
+function asBoolean(value, fallback) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (["1", "true", "yes", "on"].includes(normalized)) {
+            return true;
+        }
+        if (["0", "false", "no", "off"].includes(normalized)) {
+            return false;
+        }
+    }
+    return fallback;
+}
+function asString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized ? normalized : undefined;
+}
+function asNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return undefined;
+}
+export function optionsFromConfigMap(config) {
+    const options = defaultAgentOptions();
+    if (!config) {
+        return options;
+    }
+    options.allow_insecure_http = asBoolean(config.allow_insecure_http, false);
+    options.allow_insecure_tls = asBoolean(config.allow_insecure_tls, false);
+    options.mtls_enabled = asBoolean(config.mtls_enabled, false);
+    options.ca_file = asString(config.ca_file);
+    options.cert_file = asString(config.cert_file);
+    options.key_file = asString(config.key_file);
+    options.key_provider = asString(config.key_provider) ?? "local";
+    options.vault_url = asString(config.vault_url);
+    options.vault_path = asString(config.vault_path);
+    options.vault_token_env = asString(config.vault_token_env) ?? "VAULT_TOKEN";
+    options.endpoint = asString(config.endpoint);
+    options.relay_url = asString(config.relay_url) ?? options.relay_url;
+    options.discovery_scheme = asString(config.discovery_scheme) ?? options.discovery_scheme;
+    options.storage_dir = asString(config.storage_dir) ?? options.storage_dir;
+    options.vault_token = asString(config.vault_token);
+    options.amqp_broker_url = asString(config.amqp_broker_url);
+    options.amqp_exchange = asString(config.amqp_exchange) ?? options.amqp_exchange;
+    options.amqp_exchange_type = asString(config.amqp_exchange_type) ?? options.amqp_exchange_type;
+    options.mqtt_broker_url = asString(config.mqtt_broker_url);
+    options.mqtt_topic_prefix = asString(config.mqtt_topic_prefix) ?? options.mqtt_topic_prefix;
+    options.mqtt_qos = Math.min(2, Math.max(0, asNumber(config.mqtt_qos) ?? options.mqtt_qos));
+    if (Array.isArray(config.relay_hints)) {
+        options.relay_hints = config.relay_hints.filter((item) => typeof item === "string");
+    }
+    if (Array.isArray(config.enterprise_directory_hints)) {
+        options.enterprise_directory_hints = config.enterprise_directory_hints.filter((item) => typeof item === "string");
+    }
+    return options;
+}
+export function optionsToConfigMap(options) {
+    return {
+        allow_insecure_http: options.allow_insecure_http,
+        allow_insecure_tls: options.allow_insecure_tls,
+        mtls_enabled: options.mtls_enabled,
+        ca_file: options.ca_file ?? null,
+        cert_file: options.cert_file ?? null,
+        key_file: options.key_file ?? null,
+        key_provider: options.key_provider,
+        vault_url: options.vault_url ?? null,
+        vault_path: options.vault_path ?? null,
+        vault_token_env: options.vault_token_env
+    };
+}

package/dist/overlay.d.ts

@@ -0,0 +1,37 @@
+import { AcpAgent } from "./agent.js";
+import { JsonMap } from "./jsonSupport.js";
+import { DeliveryMode } from "./messages.js";
+export interface OverlayTarget {
+    agent_id: string;
+    base_url: string;
+    well_known_url: string;
+    identity_document_url: string;
+}
+export interface OverlaySendResult {
+    target?: OverlayTarget;
+    send_result: JsonMap;
+}
+export type BusinessHandler = (payload: JsonMap) => JsonMap | undefined;
+export type PassthroughHandler = (payload: JsonMap) => JsonMap | undefined;
+export declare function isAcpHttpMessage(body: JsonMap): boolean;
+export declare function invalidOverlayRequest(detail: string): JsonMap;
+export declare class OverlayInboundAdapter {
+    agent: AcpAgent;
+    private readonly businessHandler;
+    private readonly passthroughHandler?;
+    constructor(agent: AcpAgent, businessHandler: BusinessHandler, passthroughHandler?: PassthroughHandler | undefined);
+    handleRequest(body: JsonMap): Promise<JsonMap>;
+}
+export declare class OverlayOutboundAdapter {
+    agent: AcpAgent;
+    constructor(agent: AcpAgent);
+    resolveTarget(targetBaseUrl: string, expectedAgentId?: string): Promise<OverlayTarget>;
+    sendBusinessPayload(input: {
+        payload: JsonMap;
+        target_base_url?: string;
+        recipient_agent_id?: string;
+        context?: string;
+        delivery_mode?: DeliveryMode;
+        expires_in_seconds?: number;
+    }): Promise<OverlaySendResult>;
+}

package/dist/overlay.js

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+import { toJsonMap } from "./jsonSupport.js";
+import { validationError } from "./errors.js";
+export function isAcpHttpMessage(body) {
+    return Boolean(body.envelope &&
+        typeof body.envelope === "object" &&
+        !Array.isArray(body.envelope) &&
+        body.protected &&
+        typeof body.protected === "object" &&
+        !Array.isArray(body.protected));
+}
+export function invalidOverlayRequest(detail) {
+    return {
+        mode: "invalid",
+        state: "FAILED",
+        reason_code: "POLICY_REJECTED",
+        detail,
+        response_message: null
+    };
+}
+export class OverlayInboundAdapter {
+    agent;
+    businessHandler;
+    passthroughHandler;
+    constructor(agent, businessHandler, passthroughHandler) {
+        this.agent = agent;
+        this.businessHandler = businessHandler;
+        this.passthroughHandler = passthroughHandler;
+    }
+    async handleRequest(body) {
+        if (!isAcpHttpMessage(body)) {
+            if (this.passthroughHandler) {
+                return {
+                    mode: "passthrough",
+                    payload: this.passthroughHandler(body) ?? {}
+                };
+            }
+            throw validationError("Request is not an ACP message and no passthrough_handler is configured");
+        }
+        const inbound = await this.agent.receive(body, (payload) => this.businessHandler(payload));
+        return {
+            mode: "acp",
+            acp_result: inbound,
+            state: inbound.state,
+            reason_code: inbound.reason_code ?? null,
+            detail: inbound.detail ?? null,
+            response_message: inbound.response_message ?? null
+        };
+    }
+}
+export class OverlayOutboundAdapter {
+    agent;
+    constructor(agent) {
+        this.agent = agent;
+    }
+    async resolveTarget(targetBaseUrl, expectedAgentId) {
+        const resolved = await this.agent.resolveWellKnown(targetBaseUrl, expectedAgentId);
+        const wellKnown = toJsonMap(resolved.well_known);
+        const identityDocument = toJsonMap(resolved.identity_document);
+        const agentId = identityDocument.agent_id;
+        if (typeof agentId !== "string" || !agentId.trim()) {
+            throw validationError("Resolved well-known metadata did not include a valid identity_document.agent_id");
+        }
+        const identityDocumentUrl = wellKnown.identity_document;
+        if (typeof identityDocumentUrl !== "string" || !identityDocumentUrl.trim()) {
+            throw validationError("Resolved well-known metadata did not include a valid identity_document URL");
+        }
+        return {
+            agent_id: agentId,
+            base_url: targetBaseUrl.replace(/\/+$/, ""),
+            well_known_url: typeof resolved.well_known_url === "string" ? resolved.well_known_url : "",
+            identity_document_url: identityDocumentUrl
+        };
+    }
+    async sendBusinessPayload(input) {
+        let target;
+        let recipientAgentId = input.recipient_agent_id;
+        if (input.target_base_url) {
+            target = await this.resolveTarget(input.target_base_url, recipientAgentId);
+            recipientAgentId = recipientAgentId ?? target.agent_id;
+        }
+        if (!recipientAgentId) {
+            throw validationError("send_business_payload requires recipient_agent_id or target_base_url for well-known bootstrap");
+        }
+        const sendResult = await this.agent.send([recipientAgentId], input.payload, input.context, "SEND", input.expires_in_seconds ?? 300, undefined, undefined, input.delivery_mode);
+        return {
+            target,
+            send_result: sendResult
+        };
+    }
+}

package/dist/overlayFramework.d.ts

@@ -0,0 +1,44 @@
+import { AcpAgent } from "./agent.js";
+import { JsonMap, JsonValue } from "./jsonSupport.js";
+import { DeliveryMode } from "./messages.js";
+import { BusinessHandler, OverlayInboundAdapter, OverlayOutboundAdapter, PassthroughHandler } from "./overlay.js";
+export declare const WELL_KNOWN_CACHE_CONTROL = "public, max-age=300";
+export interface OverlayHttpResponse {
+    status_code: number;
+    body: JsonMap;
+}
+export interface OverlayConfig {
+    agent: AcpAgent;
+    base_url: string;
+    passthrough_handler?: PassthroughHandler;
+}
+export declare class OverlayFrameworkRuntime {
+    readonly agent: AcpAgent;
+    readonly base_url: string;
+    readonly inbound_adapter: OverlayInboundAdapter;
+    readonly outbound_adapter: OverlayOutboundAdapter;
+    constructor(agent: AcpAgent, base_url: string, businessHandler: BusinessHandler, passthroughHandler?: PassthroughHandler);
+    static create(agent: AcpAgent, baseUrl: string, businessHandler: BusinessHandler, passthroughHandler?: PassthroughHandler): OverlayFrameworkRuntime;
+    handleMessageBody(body: JsonValue): Promise<OverlayHttpResponse>;
+    wellKnownDocument(): JsonMap;
+    static wellKnownHeaders(): JsonMap;
+    identityDocumentPayload(): JsonMap;
+    sendBusinessPayload(input: {
+        payload: JsonMap;
+        target_base_url?: string;
+        recipient_agent_id?: string;
+        context?: string;
+        delivery_mode?: DeliveryMode;
+        expires_in_seconds?: number;
+    }): Promise<JsonMap>;
+    sendAcp(targetUrl: string, payload: JsonMap, recipientAgentId?: string, context?: string, deliveryMode?: DeliveryMode, expiresInSeconds?: number): Promise<JsonMap>;
+    static handle(requestBody: JsonValue, businessHandler: BusinessHandler, config: OverlayConfig): Promise<OverlayHttpResponse>;
+}
+export declare class OverlayClient {
+    readonly agent: AcpAgent;
+    readonly outbound_adapter: OverlayOutboundAdapter;
+    constructor(agent: AcpAgent);
+    static create(agent: AcpAgent): OverlayClient;
+    sendAcp(targetUrl: string, payload: JsonMap, recipientAgentId?: string, context?: string, deliveryMode?: DeliveryMode, expiresInSeconds?: number): Promise<JsonMap>;
+}
+export declare function acpOverlayInbound(agent: AcpAgent, handler: BusinessHandler, passthrough?: boolean): (payload: JsonMap) => Promise<JsonMap>;

package/dist/overlayFramework.js

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2026 ACP Project
+ * Licensed under the Apache License, Version 2.0
+ * See LICENSE file for details.
+ */
+import { AcpError } from "./errors.js";
+import { toJsonMap } from "./jsonSupport.js";
+import { OverlayInboundAdapter, OverlayOutboundAdapter, invalidOverlayRequest } from "./overlay.js";
+export const WELL_KNOWN_CACHE_CONTROL = "public, max-age=300";
+function sendResultToMap(result) {
+    const output = {};
+    const target = result.target && typeof result.target === "object" && !Array.isArray(result.target)
+        ? result.target
+        : undefined;
+    output.target = target ?? null;
+    output.send_result =
+        result.send_result && typeof result.send_result === "object" && !Array.isArray(result.send_result)
+            ? result.send_result
+            : null;
+    return output;
+}
+export class OverlayFrameworkRuntime {
+    agent;
+    base_url;
+    inbound_adapter;
+    outbound_adapter;
+    constructor(agent, base_url, businessHandler, passthroughHandler) {
+        this.agent = agent;
+        this.base_url = base_url;
+        if (!base_url.trim()) {
+            throw new AcpError("VALIDATION", "base_url is required");
+        }
+        this.base_url = base_url.replace(/\/+$/, "");
+        this.inbound_adapter = new OverlayInboundAdapter(agent, businessHandler, passthroughHandler);
+        this.outbound_adapter = new OverlayOutboundAdapter(agent);
+    }
+    static create(agent, baseUrl, businessHandler, passthroughHandler) {
+        return new OverlayFrameworkRuntime(agent, baseUrl, businessHandler, passthroughHandler);
+    }
+    async handleMessageBody(body) {
+        if (!body || typeof body !== "object" || Array.isArray(body)) {
+            return {
+                status_code: 400,
+                body: invalidOverlayRequest("Expected JSON object request body")
+            };
+        }
+        try {
+            const response = await this.inbound_adapter.handleRequest(toJsonMap(body));
+            return { status_code: 200, body: response };
+        }
+        catch (error) {
+            return {
+                status_code: 400,
+                body: invalidOverlayRequest(String(error))
+            };
+        }
+    }
+    wellKnownDocument() {
+        return this.agent.buildWellKnownDocument(this.base_url);
+    }
+    static wellKnownHeaders() {
+        return {
+            "Cache-Control": WELL_KNOWN_CACHE_CONTROL
+        };
+    }
+    identityDocumentPayload() {
+        return {
+            identity_document: this.agent.identity_document
+        };
+    }
+    async sendBusinessPayload(input) {
+        const result = await this.outbound_adapter.sendBusinessPayload(input);
+        return sendResultToMap(result);
+    }
+    async sendAcp(targetUrl, payload, recipientAgentId, context, deliveryMode = "auto", expiresInSeconds = 300) {
+        return this.sendBusinessPayload({
+            payload,
+            target_base_url: targetUrl,
+            recipient_agent_id: recipientAgentId,
+            context,
+            delivery_mode: deliveryMode,
+            expires_in_seconds: expiresInSeconds
+        });
+    }
+    static async handle(requestBody, businessHandler, config) {
+        try {
+            const runtime = new OverlayFrameworkRuntime(config.agent, config.base_url, businessHandler, config.passthrough_handler);
+            return runtime.handleMessageBody(requestBody);
+        }
+        catch (error) {
+            return {
+                status_code: 400,
+                body: invalidOverlayRequest(String(error))
+            };
+        }
+    }
+}
+export class OverlayClient {
+    agent;
+    outbound_adapter;
+    constructor(agent) {
+        this.agent = agent;
+        this.outbound_adapter = new OverlayOutboundAdapter(agent);
+    }
+    static create(agent) {
+        return new OverlayClient(agent);
+    }
+    async sendAcp(targetUrl, payload, recipientAgentId, context, deliveryMode = "auto", expiresInSeconds = 300) {
+        const result = await this.outbound_adapter.sendBusinessPayload({
+            payload,
+            target_base_url: targetUrl,
+            recipient_agent_id: recipientAgentId,
+            context,
+            delivery_mode: deliveryMode,
+            expires_in_seconds: expiresInSeconds
+        });
+        return sendResultToMap(result);
+    }
+}
+export function acpOverlayInbound(agent, handler, passthrough = false) {
+    let currentAgent = agent;
+    const passthroughHandler = passthrough ? handler : undefined;
+    return async (payload) => {
+        const inbound = new OverlayInboundAdapter(currentAgent, handler, passthroughHandler);
+        const response = await inbound.handleRequest(payload);
+        currentAgent = inbound.agent;
+        return response;
+    };
+}

package/dist/transport.d.ts

@@ -0,0 +1,16 @@
+import { AcpMessage } from "./messages.js";
+import { HttpSecurityPolicy } from "./httpSecurity.js";
+import { JsonMap } from "./jsonSupport.js";
+export interface TransportResponse {
+    status_code: number;
+    body?: JsonMap;
+    raw_body: string;
+}
+export declare class TransportClient {
+    private readonly timeoutSeconds;
+    private readonly policy;
+    private readonly fetchOptions;
+    constructor(timeoutSeconds: number, policy: HttpSecurityPolicy);
+    postJson(url: string, body: JsonMap): Promise<TransportResponse>;
+    sendToRelay(relayUrl: string, message: AcpMessage): Promise<JsonMap>;
+}