@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/protocol/acp/client.js

@@ -1,294 +1,8 @@
-import { createInterface } from "node:readline";
-class AcpClientError extends Error {
-    error;
-    constructor(error) {
-        super(error.message);
-        this.error = error;
-        this.name = "AcpClientError";
-    }
-}
-function writeJsonLine(output, payload) {
-    return new Promise((resolve, reject) => {
-        output.write(`${JSON.stringify(payload)}\n`, (error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-}
-function isResponse(value) {
-    return typeof value === "object"
-        && value !== null
-        && !Array.isArray(value)
-        && value.jsonrpc === "2.0"
-        && Object.hasOwn(value, "id");
-}
-function isNotification(value) {
-    return typeof value === "object"
-        && value !== null
-        && !Array.isArray(value)
-        && value.jsonrpc === "2.0"
-        && typeof value.method === "string"
-        && !Object.hasOwn(value, "id");
-}
-async function parseJsonResponse(response) {
-    const text = await response.text();
-    if (!text.trim()) {
-        return undefined;
-    }
-    return JSON.parse(text);
-}
-export function createAcpStdioClient(options) {
-    const idPrefix = options.idPrefix?.trim() || "acp";
-    let sequence = 0;
-    let closed = false;
-    const pending = new Map();
-    const listeners = new Set();
-    const reader = createInterface({
-        input: options.output,
-        crlfDelay: Infinity,
-    });
-    const completed = (async () => {
-        try {
-            for await (const line of reader) {
-                const trimmed = line.trim();
-                if (!trimmed) {
-                    continue;
-                }
-                let parsed;
-                try {
-                    parsed = JSON.parse(trimmed);
-                }
-                catch {
-                    continue;
-                }
-                if (isNotification(parsed)) {
-                    for (const listener of Array.from(listeners)) {
-                        try {
-                            listener(parsed);
-                        }
-                        catch {
-                            // Ignore listener failures so one subscriber cannot tear down the transport.
-                        }
-                    }
-                    continue;
-                }
-                if (!isResponse(parsed)) {
-                    continue;
-                }
-                const request = pending.get(parsed.id);
-                if (!request) {
-                    continue;
-                }
-                pending.delete(parsed.id);
-                if ("error" in parsed) {
-                    request.reject(new AcpClientError(parsed.error));
-                }
-                else {
-                    request.resolve(parsed.result);
-                }
-            }
-        }
-        catch (error) {
-            closed = true;
-            for (const request of pending.values()) {
-                request.reject(error);
-            }
-            pending.clear();
-        }
-    })();
-    return {
-        async request(method, params) {
-            if (closed) {
-                throw new Error("ACP stdio client is closed.");
-            }
-            const id = `${idPrefix}-${++sequence}`;
-            const payload = {
-                jsonrpc: "2.0",
-                id,
-                method,
-                ...(params === undefined ? {} : { params }),
-            };
-            const result = new Promise((resolve, reject) => {
-                pending.set(id, { resolve, reject });
-            });
-            try {
-                await writeJsonLine(options.input, payload);
-            }
-            catch (error) {
-                pending.delete(id);
-                throw error;
-            }
-            return result;
-        },
-        async notify(method, params) {
-            if (closed) {
-                throw new Error("ACP stdio client is closed.");
-            }
-            await writeJsonLine(options.input, {
-                jsonrpc: "2.0",
-                method,
-                ...(params === undefined ? {} : { params }),
-            });
-        },
-        subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        async close() {
-            closed = true;
-            reader.close();
-            if (typeof options.output.destroy === "function") {
-                options.output.destroy();
-            }
-            if (typeof options.input.end === "function") {
-                options.input.end();
-            }
-            await completed.catch(() => undefined);
-            for (const request of pending.values()) {
-                request.reject(new Error("ACP stdio client closed before response."));
-            }
-            pending.clear();
-        },
-    };
-}
-export function createAcpHttpClient(options) {
-    let closed = false;
-    let requestSequence = 0;
-    const listeners = new Set();
-    const eventsAbort = new AbortController();
-    let resolveReady;
-    let rejectReady;
-    const ready = new Promise((resolve, reject) => {
-        resolveReady = resolve;
-        rejectReady = reject;
-    });
-    const completed = (async () => {
-        const response = await fetch(options.eventsUrl, {
-            method: "GET",
-            headers: {
-                accept: "text/event-stream",
-            },
-            signal: eventsAbort.signal,
-        });
-        if (!response.ok || !response.body) {
-            throw new Error(`ACP HTTP events request failed with status ${response.status}.`);
-        }
-        resolveReady?.();
-        resolveReady = undefined;
-        rejectReady = undefined;
-        const reader = response.body
-            .pipeThrough(new TextDecoderStream())
-            .getReader();
-        let buffer = "";
-        try {
-            for (;;) {
-                const { done, value } = await reader.read();
-                if (done) {
-                    break;
-                }
-                buffer += value;
-                let splitIndex = buffer.indexOf("\n\n");
-                while (splitIndex >= 0) {
-                    const frame = buffer.slice(0, splitIndex);
-                    buffer = buffer.slice(splitIndex + 2);
-                    const dataLines = frame
-                        .split("\n")
-                        .map((line) => line.trimEnd())
-                        .filter((line) => line.startsWith("data:"))
-                        .map((line) => line.slice("data:".length).trim());
-                    if (dataLines.length > 0) {
-                        try {
-                            const parsed = JSON.parse(dataLines.join("\n"));
-                            if (isNotification(parsed)) {
-                                for (const listener of Array.from(listeners)) {
-                                    try {
-                                        listener(parsed);
-                                    }
-                                    catch {
-                                        // Ignore malformed listener failures.
-                                    }
-                                }
-                            }
-                        }
-                        catch {
-                            // Ignore malformed SSE payloads.
-                        }
-                    }
-                    splitIndex = buffer.indexOf("\n\n");
-                }
-            }
-        }
-        finally {
-            reader.releaseLock();
-        }
-    })().catch((error) => {
-        rejectReady?.(error);
-        resolveReady = undefined;
-        rejectReady = undefined;
-        if (!closed && !(error instanceof DOMException && error.name === "AbortError")) {
-            throw error;
-        }
-    });
-    return {
-        async request(method, params) {
-            if (closed) {
-                throw new Error("ACP http client is closed.");
-            }
-            await ready;
-            const response = await fetch(options.rpcUrl, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    id: `acp-http-${++requestSequence}`,
-                    method,
-                    ...(params === undefined ? {} : { params }),
-                }),
-            });
-            const parsed = await parseJsonResponse(response);
-            if (!isResponse(parsed)) {
-                throw new Error("ACP http client received a non-JSON-RPC response.");
-            }
-            if ("error" in parsed) {
-                throw new AcpClientError(parsed.error);
-            }
-            return parsed.result;
-        },
-        async notify(method, params) {
-            if (closed) {
-                throw new Error("ACP http client is closed.");
-            }
-            await ready;
-            await fetch(options.rpcUrl, {
-                method: "POST",
-                headers: {
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                    jsonrpc: "2.0",
-                    method,
-                    ...(params === undefined ? {} : { params }),
-                }),
-            });
-        },
-        subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-        async close() {
-            closed = true;
-            eventsAbort.abort();
-            await completed.catch(() => undefined);
-            listeners.clear();
-        },
-    };
-}
+import{createInterface as E}from"node:readline";class m extends Error{error;constructor(n){super(n.message),this.error=n,this.name="AcpClientError"}}function A(e,n){return new Promise((p,c)=>{e.write(`${JSON.stringify(n)}
+`,i=>{if(i){c(i);return}p()})})}function b(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)&&e.jsonrpc==="2.0"&&Object.hasOwn(e,"id")}function j(e){return typeof e=="object"&&e!==null&&!Array.isArray(e)&&e.jsonrpc==="2.0"&&typeof e.method=="string"&&!Object.hasOwn(e,"id")}async function S(e){const n=await e.text();if(n.trim())return JSON.parse(n)}function x(e){const n=e.idPrefix?.trim()||"acp";let p=0,c=!1;const i=new Map,d=new Set,l=E({input:e.output,crlfDelay:1/0}),w=(async()=>{try{for await(const o of l){const t=o.trim();if(!t)continue;let r;try{r=JSON.parse(t)}catch{continue}if(j(r)){for(const a of Array.from(d))try{a(r)}catch{}continue}if(!b(r))continue;const s=i.get(r.id);s&&(i.delete(r.id),"error"in r?s.reject(new m(r.error)):s.resolve(r.result))}}catch(o){c=!0;for(const t of i.values())t.reject(o);i.clear()}})();return{async request(o,t){if(c)throw new Error("ACP stdio client is closed.");const r=`${n}-${++p}`,s={jsonrpc:"2.0",id:r,method:o,...t===void 0?{}:{params:t}},a=new Promise((y,u)=>{i.set(r,{resolve:y,reject:u})});try{await A(e.input,s)}catch(y){throw i.delete(r),y}return a},async notify(o,t){if(c)throw new Error("ACP stdio client is closed.");await A(e.input,{jsonrpc:"2.0",method:o,...t===void 0?{}:{params:t}})},subscribe(o){return d.add(o),()=>{d.delete(o)}},async close(){c=!0,l.close(),typeof e.output.destroy=="function"&&e.output.destroy(),typeof e.input.end=="function"&&e.input.end(),await w.catch(()=>{});for(const o of i.values())o.reject(new Error("ACP stdio client closed before response."));i.clear()}}}function C(e){let n=!1,p=0;const c=new Set,i=new AbortController;let d,l;const w=new Promise((t,r)=>{d=t,l=r}),o=(async()=>{const t=await fetch(e.eventsUrl,{method:"GET",headers:{accept:"text/event-stream"},signal:i.signal});if(!t.ok||!t.body)throw new Error(`ACP HTTP events request failed with status ${t.status}.`);d?.(),d=void 0,l=void 0;const r=t.body.pipeThrough(new TextDecoderStream).getReader();let s="";try{for(;;){const{done:a,value:y}=await r.read();if(a)break;s+=y;let u=s.indexOf(`
+
+`);for(;u>=0;){const O=s.slice(0,u);s=s.slice(u+2);const h=O.split(`
+`).map(f=>f.trimEnd()).filter(f=>f.startsWith("data:")).map(f=>f.slice(5).trim());if(h.length>0)try{const f=JSON.parse(h.join(`
+`));if(j(f))for(const P of Array.from(c))try{P(f)}catch{}}catch{}u=s.indexOf(`
+
+`)}}}finally{r.releaseLock()}})().catch(t=>{if(l?.(t),d=void 0,l=void 0,!n&&!(t instanceof DOMException&&t.name==="AbortError"))throw t});return{async request(t,r){if(n)throw new Error("ACP http client is closed.");await w;const s=await fetch(e.rpcUrl,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({jsonrpc:"2.0",id:`acp-http-${++p}`,method:t,...r===void 0?{}:{params:r}})}),a=await S(s);if(!b(a))throw new Error("ACP http client received a non-JSON-RPC response.");if("error"in a)throw new m(a.error);return a.result},async notify(t,r){if(n)throw new Error("ACP http client is closed.");await w,await fetch(e.rpcUrl,{method:"POST",headers:{"content-type":"application/json"},body:JSON.stringify({jsonrpc:"2.0",method:t,...r===void 0?{}:{params:r}})})},subscribe(t){return c.add(t),()=>{c.delete(t)}},async close(){n=!0,i.abort(),await o.catch(()=>{}),c.clear()}}}export{C as createAcpHttpClient,x as createAcpStdioClient};

package/dist/protocol/acp/harness-client.js

@@ -1,218 +1 @@
-import { createAcpHttpClient, createAcpStdioClient, } from "./client.js";
-import { applyRequestStreamItemToSnapshot, createInitialRequestEventSnapshot, toRequestDataEvents, } from "../../projections/request-events.js";
-function toEvent(notification) {
-    return notification.params.event;
-}
-function isRuntimeEventNotification(notification) {
-    return notification.method === "events.runtime";
-}
-function isStreamNotification(notification) {
-    return notification.method === "requests.stream";
-}
-export class AcpHarnessClient {
-    transport;
-    streamSequence = 0;
-    constructor(transport) {
-        this.transport = transport;
-    }
-    request(options) {
-        if (this.hasStreamingListeners(options)) {
-            return this.requestWithStreamingListeners(options);
-        }
-        return this.transport.request("requests.submit", options);
-    }
-    hasStreamingListeners(options) {
-        return Boolean(("eventListener" in options && options.eventListener)
-            || ("dataListener" in options && options.dataListener)
-            || options.listeners);
-    }
-    async *streamRequestInternal(options) {
-        const streamId = `harness-stream-${++this.streamSequence}`;
-        const queued = [];
-        let notify;
-        let settled = false;
-        let streamedResult = false;
-        let responseResolved = false;
-        let failure;
-        let fallbackTimer;
-        const waitForItem = () => new Promise((resolve) => {
-            notify = resolve;
-        });
-        const push = (item) => {
-            queued.push(item);
-            notify?.();
-            notify = undefined;
-        };
-        const settle = () => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            notify?.();
-            notify = undefined;
-        };
-        const unsubscribe = this.transport.subscribe((notification) => {
-            if (!isStreamNotification(notification) || notification.params.streamId !== streamId) {
-                return;
-            }
-            if (notification.params.item.type === "result") {
-                streamedResult = true;
-                if (fallbackTimer) {
-                    clearTimeout(fallbackTimer);
-                    fallbackTimer = undefined;
-                }
-                if (responseResolved) {
-                    settle();
-                }
-            }
-            push(notification.params.item);
-        });
-        const resultPromise = this.transport.request("requests.submit", {
-            ...options,
-            streamId,
-            listeners: undefined,
-            eventListener: undefined,
-            dataListener: undefined,
-        });
-        resultPromise
-            .then((result) => {
-            responseResolved = true;
-            if (streamedResult) {
-                settle();
-                return;
-            }
-            fallbackTimer = setTimeout(() => {
-                push({
-                    type: "result",
-                    result,
-                });
-                settle();
-            }, 50);
-        })
-            .catch((error) => {
-            failure = error;
-            settle();
-        })
-            .finally(() => undefined);
-        try {
-            while (!settled || queued.length > 0) {
-                if (queued.length === 0) {
-                    await waitForItem();
-                    continue;
-                }
-                const item = queued.shift();
-                if (item) {
-                    yield item;
-                }
-            }
-            if (failure) {
-                throw failure;
-            }
-        }
-        finally {
-            if (fallbackTimer) {
-                clearTimeout(fallbackTimer);
-            }
-            unsubscribe();
-        }
-    }
-    async requestWithStreamingListeners(options) {
-        const legacyListeners = options.listeners;
-        const eventListener = "eventListener" in options ? options.eventListener : undefined;
-        const dataListener = "dataListener" in options ? options.dataListener : undefined;
-        let snapshot = createInitialRequestEventSnapshot();
-        let finalResult;
-        for await (const item of this.streamRequestInternal(options)) {
-            snapshot = applyRequestStreamItemToSnapshot(snapshot, item);
-            if (item.type === "event") {
-                await legacyListeners?.onEvent?.(item.event);
-            }
-            else if (item.type === "upstream-event") {
-                await legacyListeners?.onUpstreamEvent?.(item.event);
-                if (item.surfaceItem) {
-                    await legacyListeners?.onTraceItem?.({
-                        sessionId: item.sessionId,
-                        requestId: item.requestId,
-                        surfaceItem: item.surfaceItem,
-                        event: item.event,
-                    });
-                }
-            }
-            else if (item.type === "plan-state") {
-                await legacyListeners?.onPlanState?.(item.planState);
-            }
-            else if (item.type === "result") {
-                finalResult = item.result;
-            }
-            for (const dataEvent of toRequestDataEvents(item)) {
-                await dataListener?.(dataEvent);
-            }
-            await eventListener?.(snapshot);
-        }
-        if (!finalResult) {
-            throw new Error("ACP streaming request completed without a terminal result.");
-        }
-        return finalResult;
-    }
-    resolveApproval(options) {
-        return this.transport.request("approvals.resolve", options);
-    }
-    cancelRequest(options) {
-        return this.transport.request("requests.cancel", options);
-    }
-    subscribe(listener) {
-        return this.transport.subscribe((notification) => {
-            if (isRuntimeEventNotification(notification)) {
-                void listener(toEvent(notification));
-            }
-        });
-    }
-    listSessions(filter) {
-        return this.transport.request("sessions.list", filter);
-    }
-    listSessionSummaries(filter) {
-        return this.transport.request("sessions.summaries", filter);
-    }
-    listRequests(filter) {
-        return this.transport.request("requests.list", filter);
-    }
-    getSession(sessionId) {
-        return this.transport.request("sessions.get", { sessionId });
-    }
-    getRequest(requestId) {
-        return this.transport.request("requests.get", { requestId });
-    }
-    listApprovals(filter) {
-        return this.transport.request("approvals.list", filter);
-    }
-    getApproval(approvalId) {
-        return this.transport.request("approvals.get", { approvalId });
-    }
-    getRequestPlanState(input) {
-        return this.transport.request("requests.plan.get", input);
-    }
-    listRequestEvents(input) {
-        return this.transport.request("events.list", input);
-    }
-    listRequestTraceItems(input) {
-        return this.transport.request("requests.trace.list", input);
-    }
-    getHealth() {
-        return this.transport.request("runtime.health");
-    }
-    getOperatorOverview(options) {
-        return this.transport.request("runtime.overview", options);
-    }
-    stop() {
-        return this.transport.close();
-    }
-}
-export function createAcpHarnessClient(transport) {
-    return new AcpHarnessClient(transport);
-}
-export function createAcpStdioHarnessClient(options) {
-    return new AcpHarnessClient(createAcpStdioClient(options));
-}
-export function createAcpHttpHarnessClient(options) {
-    return new AcpHarnessClient(createAcpHttpClient(options));
-}
+import{createAcpHttpClient as d,createAcpStdioClient as v}from"./client.js";import{applyRequestStreamItemToSnapshot as w,createInitialRequestEventSnapshot as S,toRequestDataEvents as g}from"../../projections/request-events.js";function L(r){return r.params.event}function I(r){return r.method==="events.runtime"}function y(r){return r.method==="requests.stream"}class m{transport;streamSequence=0;constructor(e){this.transport=e}request(e){return this.hasStreamingListeners(e)?this.requestWithStreamingListeners(e):this.transport.request("requests.submit",e)}hasStreamingListeners(e){return!!("eventListener"in e&&e.eventListener||"dataListener"in e&&e.dataListener||e.listeners)}async*streamRequestInternal(e){const n=`harness-stream-${++this.streamSequence}`,u=[];let i,a=!1,l=!1,t=!1,p,o;const h=()=>new Promise(s=>{i=s}),f=s=>{u.push(s),i?.(),i=void 0},c=()=>{a||(a=!0,i?.(),i=void 0)},q=this.transport.subscribe(s=>{!y(s)||s.params.streamId!==n||(s.params.item.type==="result"&&(l=!0,o&&(clearTimeout(o),o=void 0),t&&c()),f(s.params.item))});this.transport.request("requests.submit",{...e,streamId:n,listeners:void 0,eventListener:void 0,dataListener:void 0}).then(s=>{if(t=!0,l){c();return}o=setTimeout(()=>{f({type:"result",result:s}),c()},50)}).catch(s=>{p=s,c()}).finally(()=>{});try{for(;!a||u.length>0;){if(u.length===0){await h();continue}const s=u.shift();s&&(yield s)}if(p)throw p}finally{o&&clearTimeout(o),q()}}async requestWithStreamingListeners(e){const n=e.listeners,u="eventListener"in e?e.eventListener:void 0,i="dataListener"in e?e.dataListener:void 0;let a=S(),l;for await(const t of this.streamRequestInternal(e)){a=w(a,t),t.type==="event"?await n?.onEvent?.(t.event):t.type==="upstream-event"?(await n?.onUpstreamEvent?.(t.event),t.surfaceItem&&await n?.onTraceItem?.({sessionId:t.sessionId,requestId:t.requestId,surfaceItem:t.surfaceItem,event:t.event})):t.type==="plan-state"?await n?.onPlanState?.(t.planState):t.type==="result"&&(l=t.result);for(const p of g(t))await i?.(p);await u?.(a)}if(!l)throw new Error("ACP streaming request completed without a terminal result.");return l}resolveApproval(e){return this.transport.request("approvals.resolve",e)}cancelRequest(e){return this.transport.request("requests.cancel",e)}subscribe(e){return this.transport.subscribe(n=>{I(n)&&e(L(n))})}listSessions(e){return this.transport.request("sessions.list",e)}listSessionSummaries(e){return this.transport.request("sessions.summaries",e)}listRequests(e){return this.transport.request("requests.list",e)}getSession(e){return this.transport.request("sessions.get",{sessionId:e})}getRequest(e){return this.transport.request("requests.get",{requestId:e})}listApprovals(e){return this.transport.request("approvals.list",e)}getApproval(e){return this.transport.request("approvals.get",{approvalId:e})}getRequestPlanState(e){return this.transport.request("requests.plan.get",e)}listRequestEvents(e){return this.transport.request("events.list",e)}listRequestTraceItems(e){return this.transport.request("requests.trace.list",e)}getHealth(){return this.transport.request("runtime.health")}getOperatorOverview(e){return this.transport.request("runtime.overview",e)}stop(){return this.transport.close()}}function E(r){return new m(r)}function C(r){return new m(v(r))}function H(r){return new m(d(r))}export{m as AcpHarnessClient,E as createAcpHarnessClient,H as createAcpHttpHarnessClient,C as createAcpStdioHarnessClient};

package/dist/protocol/acp/http.js

@@ -1,130 +1,5 @@
-import { createServer } from "node:http";
-import { createAcpServer } from "../../acp.js";
-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 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);
-    });
-}
-export async function serveAcpOverHttp(runtime, options = {}) {
-    const hostname = options.hostname?.trim() || "127.0.0.1";
-    const port = typeof options.port === "number" && Number.isFinite(options.port) ? options.port : 0;
-    const rpcPath = normalizePath(options.rpcPath, "/rpc");
-    const eventsPath = normalizePath(options.eventsPath, "/events");
-    const server = createAcpServer(runtime);
-    const eventSubscribers = new Set();
-    const unsubscribe = server.subscribe((notification) => {
-        const payload = `data: ${JSON.stringify(notification)}\n\n`;
-        for (const response of Array.from(eventSubscribers)) {
-            if (response.writableEnded || response.destroyed) {
-                eventSubscribers.delete(response);
-                continue;
-            }
-            response.write(payload);
-        }
-    });
-    const httpServer = createServer(async (request, response) => {
-        try {
-            const requestUrl = new URL(request.url ?? "/", `http://${hostname}`);
-            if (request.method === "GET" && requestUrl.pathname === eventsPath) {
-                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");
-                response.write(": connected\n\n");
-                eventSubscribers.add(response);
-                request.on("close", () => {
-                    eventSubscribers.delete(response);
-                    response.end();
-                });
-                return;
-            }
-            if (request.method === "POST" && requestUrl.pathname === rpcPath) {
-                const body = await readRequestBody(request);
-                let payload;
-                try {
-                    payload = JSON.parse(body);
-                }
-                catch {
-                    writeJson(response, 400, {
-                        jsonrpc: "2.0",
-                        id: null,
-                        error: {
-                            code: -32700,
-                            message: "Invalid JSON payload.",
-                        },
-                    });
-                    return;
-                }
-                const rpcResponse = await server.handle(payload);
-                if (!rpcResponse) {
-                    response.statusCode = 204;
-                    response.end();
-                    return;
-                }
-                writeJson(response, 200, rpcResponse);
-                return;
-            }
-            writeJson(response, 404, {
-                error: "Not Found",
-                rpcPath,
-                eventsPath,
-            });
-        }
-        catch (error) {
-            writeJson(response, 500, {
-                error: error instanceof Error ? error.message : "ACP HTTP transport failed.",
-            });
-        }
-    });
-    const completed = new Promise((resolve, reject) => {
-        httpServer.once("close", resolve);
-        httpServer.once("error", reject);
-    });
-    await new Promise((resolve, reject) => {
-        httpServer.listen(port, hostname, () => resolve());
-        httpServer.once("error", reject);
-    });
-    const address = httpServer.address();
-    const resolvedPort = typeof address === "object" && address ? address.port : port;
-    return {
-        hostname,
-        port: resolvedPort,
-        rpcPath,
-        eventsPath,
-        rpcUrl: `http://${hostname}:${resolvedPort}${rpcPath}`,
-        eventsUrl: `http://${hostname}:${resolvedPort}${eventsPath}`,
-        completed,
-        close: async () => {
-            unsubscribe();
-            for (const response of Array.from(eventSubscribers)) {
-                response.end();
-            }
-            eventSubscribers.clear();
-            await new Promise((resolve, reject) => {
-                httpServer.close((error) => {
-                    if (error) {
-                        reject(error);
-                        return;
-                    }
-                    resolve();
-                });
-            });
-        },
-    };
-}
+import{createServer as S}from"node:http";import{createAcpServer as $}from"../../acp.js";function w(r,c){const n=typeof r=="string"&&r.trim().length>0?r.trim():c;return n.startsWith("/")?n:`/${n}`}function m(r,c,n){r.statusCode=c,r.setHeader("content-type","application/json; charset=utf-8"),r.end(JSON.stringify(n))}function g(r){return new Promise((c,n)=>{const d=[];r.on("data",a=>{d.push(Buffer.isBuffer(a)?a:Buffer.from(a))}),r.on("end",()=>{c(Buffer.concat(d).toString("utf8"))}),r.on("error",n)})}async function O(r,c={}){const n=c.hostname?.trim()||"127.0.0.1",d=typeof c.port=="number"&&Number.isFinite(c.port)?c.port:0,a=w(c.rpcPath,"/rpc"),f=w(c.eventsPath,"/events"),h=$(r),s=new Set,v=h.subscribe(e=>{const t=`data: ${JSON.stringify(e)}
+
+`;for(const o of Array.from(s)){if(o.writableEnded||o.destroyed){s.delete(o);continue}o.write(t)}}),i=S(async(e,t)=>{try{const o=new URL(e.url??"/",`http://${n}`);if(e.method==="GET"&&o.pathname===f){t.statusCode=200,t.setHeader("content-type","text/event-stream; charset=utf-8"),t.setHeader("cache-control","no-cache, no-transform"),t.setHeader("connection","keep-alive"),t.write(`: connected
+
+`),s.add(t),e.on("close",()=>{s.delete(t),t.end()});return}if(e.method==="POST"&&o.pathname===a){const b=await g(e);let p;try{p=JSON.parse(b)}catch{m(t,400,{jsonrpc:"2.0",id:null,error:{code:-32700,message:"Invalid JSON payload."}});return}const y=await h.handle(p);if(!y){t.statusCode=204,t.end();return}m(t,200,y);return}m(t,404,{error:"Not Found",rpcPath:a,eventsPath:f})}catch(o){m(t,500,{error:o instanceof Error?o.message:"ACP HTTP transport failed."})}}),P=new Promise((e,t)=>{i.once("close",e),i.once("error",t)});await new Promise((e,t)=>{i.listen(d,n,()=>e()),i.once("error",t)});const l=i.address(),u=typeof l=="object"&&l?l.port:d;return{hostname:n,port:u,rpcPath:a,eventsPath:f,rpcUrl:`http://${n}:${u}${a}`,eventsUrl:`http://${n}:${u}${f}`,completed:P,close:async()=>{v();for(const e of Array.from(s))e.end();s.clear(),await new Promise((e,t)=>{i.close(o=>{if(o){t(o);return}e()})})}}}export{O as serveAcpOverHttp};