@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/acp.js

@@ -1 +1 @@
-export * from "./protocol/acp/server.js";
+export*from"./protocol/acp/server.js";

package/dist/api.js

@@ -1,404 +1 @@
-import { AgentHarnessRuntime } from "./runtime/harness.js";
-import { buildFlowGraph, exportFlowGraphToMermaid as exportFlowGraphFromGraph, exportFlowGraphToSequenceMermaid as exportSequenceGraphFromGraph, } from "./flow/index.js";
-import { serveA2aOverHttp } from "./protocol/a2a/http.js";
-import { serveAgUiOverHttp } from "./protocol/ag-ui/http.js";
-import { serveAcpOverHttp } from "./protocol/acp/http.js";
-import { serveAcpOverStdio } from "./protocol/acp/stdio.js";
-import { normalizeMessageContent } from "./utils/message-content.js";
-import { loadWorkspace } from "./workspace/compile.js";
-import { traceStartupStage } from "./runtime/startup-tracing.js";
-export { AgentHarnessAcpServer, createAcpServer } from "./acp.js";
-export { createAcpStdioClient } from "./protocol/acp/client.js";
-export { AgentHarnessRuntime } from "./runtime/harness.js";
-export { createUpstreamTimelineReducer } from "./projections/upstream-events.js";
-function toApprovalRecord(record) {
-    return {
-        approvalId: record.approvalId,
-        pendingActionId: record.pendingActionId,
-        sessionId: record.sessionId,
-        requestId: record.requestId,
-        toolName: record.toolName,
-        ...(record.approvalReason ? { approvalReason: record.approvalReason } : {}),
-        status: record.status,
-        requestedAt: record.requestedAt,
-        resolvedAt: record.resolvedAt,
-        allowedDecisions: record.allowedDecisions,
-        inputPreview: record.inputPreview,
-    };
-}
-function toPublicEventType(eventType) {
-    return eventType;
-}
-function toPublicEvent(event) {
-    return {
-        eventId: event.eventId,
-        eventType: toPublicEventType(event.eventType),
-        timestamp: event.timestamp,
-        sessionId: event.sessionId,
-        requestId: event.requestId,
-        sequence: event.sequence,
-        source: event.source,
-        payload: event.payload,
-    };
-}
-function toPublicTraceItem(input) {
-    const typed = typeof input.item === "object" && input.item !== null
-        ? input.item
-        : null;
-    if (!typed?.surfaceItem) {
-        return null;
-    }
-    return {
-        sessionId: input.sessionId,
-        requestId: input.requestId,
-        surfaceItem: typed.surfaceItem,
-        event: typed.event,
-    };
-}
-function toPublicRequestListeners(listeners) {
-    if (!listeners) {
-        return undefined;
-    }
-    return {
-        onEvent: listeners.onEvent ? async (event) => listeners.onEvent(toPublicEvent(event)) : undefined,
-        onUpstreamEvent: listeners.onUpstreamEvent,
-        onTraceItem: listeners.onTraceItem
-            ? async (item) => listeners.onTraceItem({
-                sessionId: item.sessionId,
-                requestId: item.requestId,
-                surfaceItem: item.surfaceItem,
-                event: item.event,
-            })
-            : undefined,
-        onPlanState: listeners.onPlanState,
-    };
-}
-function toRequestArtifactListing(listing) {
-    return {
-        sessionId: listing.sessionId,
-        requestId: listing.requestId,
-        items: listing.items,
-    };
-}
-function toRequestPackage(pkg) {
-    return {
-        session: pkg.session,
-        request: pkg.request,
-        approvals: pkg.approvals.map(toApprovalRecord),
-        transcript: pkg.transcript,
-        events: pkg.events.map(toPublicEvent),
-        artifacts: pkg.artifacts,
-        governance: pkg.governance,
-        ...(pkg.runtimeHealth ? { runtimeHealth: pkg.runtimeHealth } : {}),
-    };
-}
-function toPublicRequestResult(result) {
-    return {
-        sessionId: result.sessionId,
-        requestId: result.requestId,
-        state: result.state,
-        output: result.output,
-        finalMessageText: result.finalMessageText,
-        outputContent: result.outputContent,
-        contentBlocks: result.contentBlocks,
-        structuredResponse: result.structuredResponse,
-        interruptContent: result.interruptContent,
-        agentId: result.agentId,
-        approvalId: result.approvalId,
-        pendingActionId: result.pendingActionId,
-        delegationId: result.delegationId,
-        artifacts: result.artifacts,
-        metadata: result.metadata,
-    };
-}
-function toInternalRequestOptions(options) {
-    const legacyListeners = toPublicRequestListeners(options.listeners);
-    const mergedListeners = legacyListeners || options.eventListener || options.dataListener
-        ? {
-            ...(legacyListeners ?? {}),
-            ...(options.eventListener ? { eventListener: options.eventListener } : {}),
-            ...(options.dataListener ? { dataListener: options.dataListener } : {}),
-        }
-        : undefined;
-    if ("decision" in options) {
-        return {
-            approvalId: options.approvalId,
-            decision: options.decision,
-            editedInput: options.editedInput,
-            listeners: mergedListeners,
-            requestId: options.requestId,
-            sessionId: options.sessionId,
-        };
-    }
-    return {
-        agentId: options.agentId,
-        input: options.input,
-        invocation: options.invocation,
-        listeners: mergedListeners,
-        priority: options.priority,
-        sessionId: options.sessionId,
-    };
-}
-function toInternalResumeOptions(options) {
-    return {
-        approvalId: options.approvalId,
-        decision: options.decision,
-        editedInput: options.editedInput,
-        requestId: options.requestId,
-        sessionId: options.sessionId,
-    };
-}
-function toPublicRequestSummary(summary) {
-    return {
-        requestId: summary.requestId,
-        sessionId: summary.sessionId,
-        agentId: summary.agentId,
-        parentRequestId: summary.parentRequestId,
-        executionMode: summary.executionMode,
-        adapterKind: summary.adapterKind,
-        createdAt: summary.createdAt,
-        updatedAt: summary.updatedAt,
-        state: summary.state,
-        checkpointRef: summary.checkpointRef,
-        resumable: summary.resumable,
-        startedAt: summary.startedAt,
-        endedAt: summary.endedAt,
-        lastActivityAt: summary.lastActivityAt,
-        currentAgentId: summary.currentAgentId,
-        delegationChain: summary.delegationChain,
-        runtimeSnapshot: summary.runtimeSnapshot,
-    };
-}
-export async function createAgentHarness(workspaceRoot = process.cwd(), options = {}) {
-    const workspace = await traceStartupStage("createAgentHarness.loadWorkspace", () => loadWorkspace(workspaceRoot, options.load ?? {}), {
-        workspaceRoot,
-    });
-    const harness = await traceStartupStage("createAgentHarness.constructRuntime", async () => new AgentHarnessRuntime(workspace, options.adapter ?? {}), {
-        workspaceRoot,
-    });
-    await traceStartupStage("createAgentHarness.initializeRuntime", () => harness.initialize(), {
-        workspaceRoot,
-    });
-    return harness;
-}
-export function normalizeUserChatInput(input, options = {}) {
-    const content = typeof input === "object" && input !== null && "role" in input
-        ? normalizeUserChatMessage(input).content
-        : normalizeMessageContent(input);
-    return options.invocation ? { input: content, invocation: options.invocation } : { input: content };
-}
-export async function request(runtime, options) {
-    return toPublicRequestResult(await runtime.run(toInternalRequestOptions(options)));
-}
-export async function memorize(runtime, input) {
-    return runtime.memorize(input);
-}
-export async function recall(runtime, input) {
-    return runtime.recall(input);
-}
-export async function listMemories(runtime, input = {}) {
-    return runtime.listMemories(input);
-}
-export async function updateMemory(runtime, input) {
-    return runtime.updateMemory(input);
-}
-export async function removeMemory(runtime, input) {
-    return runtime.removeMemory(input);
-}
-export function subscribe(runtime, listener) {
-    return runtime.subscribe(async (event) => {
-        await listener(toPublicEvent(event));
-    });
-}
-export async function listSessions(runtime, filter) {
-    return runtime.listSessions(filter);
-}
-export async function listSessionSummaries(runtime, filter) {
-    return runtime.listSessionSummaries(filter);
-}
-export async function listRequests(runtime, filter) {
-    return runtime.listRequests(filter);
-}
-export async function getSession(runtime, sessionId) {
-    return runtime.getSessionRecord(sessionId);
-}
-export async function getRequest(runtime, requestId) {
-    return runtime.getRequest(requestId);
-}
-async function buildRequestFlowGraph(runtime, input) {
-    const request = await runtime.getRequest(input.requestId);
-    if (!request) {
-        throw new Error(`Request ${input.requestId} was not found.`);
-    }
-    if (request.sessionId !== input.sessionId) {
-        throw new Error(`Request ${input.requestId} belongs to session ${request.sessionId}, not ${input.sessionId}.`);
-    }
-    const traceItems = (request.traceItems ?? [])
-        .map((item) => toPublicTraceItem({
-        sessionId: input.sessionId,
-        requestId: input.requestId,
-        item,
-    }))
-        .filter((item) => item !== null);
-    return buildFlowGraph({
-        sessionId: input.sessionId,
-        requestId: input.requestId,
-        runtimeTimeline: request.runtimeTimeline,
-        upstreamEvents: traceItems,
-        metadata: {
-            state: request.state,
-            ...(request.runtimeSnapshot ? { runtimeSnapshot: request.runtimeSnapshot } : {}),
-        },
-    });
-}
-export async function exportFlow(runtime, input) {
-    return exportFlowGraphFromGraph(await buildRequestFlowGraph(runtime, input), {
-        direction: "TD",
-        includeGroups: false,
-        includeKinds: ["agent", "llm", "tool", "skill", "memory"],
-    });
-}
-export async function exportSequence(runtime, input) {
-    return exportSequenceGraphFromGraph(await buildRequestFlowGraph(runtime, input));
-}
-export async function deleteSession(runtime, sessionId) {
-    return runtime.deleteSession(sessionId);
-}
-export async function listApprovals(runtime, filter) {
-    return (await runtime.listApprovals({
-        requestId: filter?.requestId,
-        status: filter?.status,
-        sessionId: filter?.sessionId,
-    })).map(toApprovalRecord);
-}
-export async function getApproval(runtime, approvalId) {
-    const record = await runtime.getApproval(approvalId);
-    return record ? toApprovalRecord(record) : null;
-}
-export async function listRequestArtifacts(runtime, input) {
-    return toRequestArtifactListing(await runtime.listRequestArtifacts(input.sessionId, input.requestId));
-}
-export async function getArtifact(runtime, input) {
-    return runtime.readRequestArtifact(input.sessionId, input.requestId, input.artifactPath);
-}
-export async function getRequestPlanState(runtime, input) {
-    return runtime.getRequestPlanState(input.sessionId, input.requestId);
-}
-export async function recordArtifact(runtime, input) {
-    return runtime.recordArtifact(input);
-}
-export async function listRequestEvents(runtime, input) {
-    return (await runtime.listRequestEvents(input.sessionId, input.requestId)).map(toPublicEvent);
-}
-export async function listRequestTraceItems(runtime, input) {
-    const request = await runtime.getRequest(input.requestId);
-    if (!request) {
-        throw new Error(`Request ${input.requestId} was not found.`);
-    }
-    if (request.sessionId !== input.sessionId) {
-        throw new Error(`Request ${input.requestId} belongs to session ${request.sessionId}, not ${input.sessionId}.`);
-    }
-    return (request.traceItems ?? [])
-        .map((item) => toPublicTraceItem({
-        sessionId: input.sessionId,
-        requestId: input.requestId,
-        item,
-    }))
-        .filter((item) => item !== null);
-}
-export async function getHealth(runtime) {
-    return runtime.getHealth();
-}
-export async function getOperatorOverview(runtime, options) {
-    const overview = await runtime.getOperatorOverview(options);
-    const requestOverview = {
-        total: overview.requests.total,
-        states: overview.requests.states,
-        items: overview.requests.items.map(toPublicRequestSummary),
-    };
-    return {
-        ...overview,
-        approvals: {
-            total: overview.approvals.total,
-            items: overview.approvals.items.map(toApprovalRecord),
-        },
-        requests: requestOverview,
-    };
-}
-export async function exportRequestPackage(runtime, input) {
-    const pkg = await runtime.exportRequestPackage(input);
-    return {
-        ...toRequestPackage(pkg),
-        planState: await runtime.getRequestPlanState(input.sessionId, input.requestId),
-    };
-}
-export async function exportSessionPackage(runtime, input) {
-    return runtime.exportSessionPackage(input);
-}
-export async function exportEvaluationBundle(runtime, input) {
-    return runtime.exportEvaluationBundle(input);
-}
-export async function replayEvaluationBundle(runtime, input) {
-    const replayed = await runtime.replayEvaluationBundle(input);
-    return {
-        ...replayed,
-        result: toPublicRequestResult(replayed.result),
-    };
-}
-export function serveAcpStdio(runtime, options) {
-    return serveAcpOverStdio(runtime, options);
-}
-export async function serveAcpHttp(runtime, options) {
-    return serveAcpOverHttp(runtime, options);
-}
-export async function serveAgUiHttp(runtime, options) {
-    return serveAgUiOverHttp(runtime, options);
-}
-export async function serveA2aHttp(runtime, options) {
-    return serveA2aOverHttp(runtime, options);
-}
-export function listAgentSkills(runtime, agentId, options) {
-    return runtime.listAgentSkills(agentId, options);
-}
-export function getAgent(runtime, agentId, options) {
-    return runtime.getAgent(agentId, options);
-}
-export function describeInventory(runtime, options) {
-    return runtime.describeWorkspaceInventory(options);
-}
-export function analyzeBoundaries(runtime, options) {
-    return runtime.analyzeWorkspaceBoundaries(options);
-}
-export async function resolveApproval(runtime, options) {
-    return toPublicRequestResult(await runtime.resume(toInternalResumeOptions(options)));
-}
-export async function cancelRequest(runtime, options) {
-    return toPublicRequestResult(await runtime.cancelRequest(options));
-}
-export async function stop(runtime) {
-    return runtime.stop();
-}
-export async function createToolMcpServer(runtime, options) {
-    return runtime.createToolMcpServer(options);
-}
-export async function serveToolsOverStdio(runtime, options) {
-    return runtime.serveToolsOverStdio(options);
-}
-export async function createRuntimeMcpServer(runtime, options) {
-    return runtime.createRuntimeMcpServer(options);
-}
-export async function serveRuntimeMcpOverStdio(runtime, options) {
-    return runtime.serveRuntimeMcpOverStdio(options);
-}
-export async function serveRuntimeMcpOverStreamableHttp(runtime, options) {
-    return runtime.serveRuntimeMcpOverStreamableHttp(options);
-}
-function normalizeUserChatMessage(message) {
-    if (message.role !== "user") {
-        throw new Error("normalizeUserChatInput only accepts user-role chat messages.");
-    }
-    return {
-        role: "user",
-        content: normalizeMessageContent(message.content),
-    };
-}
+import{AgentHarnessRuntime as l}from"./runtime/harness.js";import{buildFlowGraph as I,exportFlowGraphToMermaid as f,exportFlowGraphToSequenceMermaid as v}from"./flow/index.js";import{serveA2aOverHttp as m}from"./protocol/a2a/http.js";import{serveAgUiOverHttp as q}from"./protocol/ag-ui/http.js";import{serveAcpOverHttp as x}from"./protocol/acp/http.js";import{serveAcpOverStdio as A}from"./protocol/acp/stdio.js";import{normalizeMessageContent as c}from"./utils/message-content.js";import{loadWorkspace as g}from"./workspace/compile.js";import{traceStartupStage as u}from"./runtime/startup-tracing.js";import{AgentHarnessAcpServer as Le,createAcpServer as Ce}from"./acp.js";import{createAcpStdioClient as Ge}from"./protocol/acp/client.js";import{AgentHarnessRuntime as Fe}from"./runtime/harness.js";import{createUpstreamTimelineReducer as $e}from"./projections/upstream-events.js";function s(e){return{approvalId:e.approvalId,pendingActionId:e.pendingActionId,sessionId:e.sessionId,requestId:e.requestId,toolName:e.toolName,...e.approvalReason?{approvalReason:e.approvalReason}:{},status:e.status,requestedAt:e.requestedAt,resolvedAt:e.resolvedAt,allowedDecisions:e.allowedDecisions,inputPreview:e.inputPreview}}function B(e){return e}function o(e){return{eventId:e.eventId,eventType:e.eventType,timestamp:e.timestamp,sessionId:e.sessionId,requestId:e.requestId,sequence:e.sequence,source:e.source,payload:e.payload}}function d(e){const t=typeof e.item=="object"&&e.item!==null?e.item:null;return t?.surfaceItem?{sessionId:e.sessionId,requestId:e.requestId,surfaceItem:t.surfaceItem,event:t.event}:null}function y(e){if(e)return{onEvent:e.onEvent?async t=>e.onEvent(o(t)):void 0,onUpstreamEvent:e.onUpstreamEvent,onTraceItem:e.onTraceItem?async t=>e.onTraceItem({sessionId:t.sessionId,requestId:t.requestId,surfaceItem:t.surfaceItem,event:t.event}):void 0,onPlanState:e.onPlanState}}function R(e){return{sessionId:e.sessionId,requestId:e.requestId,items:e.items}}function S(e){return{session:e.session,request:e.request,approvals:e.approvals.map(s),transcript:e.transcript,events:e.events.map(o),artifacts:e.artifacts,governance:e.governance,...e.runtimeHealth?{runtimeHealth:e.runtimeHealth}:{}}}function a(e){return{sessionId:e.sessionId,requestId:e.requestId,state:e.state,output:e.output,finalMessageText:e.finalMessageText,outputContent:e.outputContent,contentBlocks:e.contentBlocks,structuredResponse:e.structuredResponse,interruptContent:e.interruptContent,agentId:e.agentId,approvalId:e.approvalId,pendingActionId:e.pendingActionId,delegationId:e.delegationId,artifacts:e.artifacts,metadata:e.metadata}}function w(e){const t=y(e.listeners),n=t||e.eventListener||e.dataListener?{...t??{},...e.eventListener?{eventListener:e.eventListener}:{},...e.dataListener?{dataListener:e.dataListener}:{}}:void 0;return"decision"in e?{approvalId:e.approvalId,decision:e.decision,editedInput:e.editedInput,listeners:n,requestId:e.requestId,sessionId:e.sessionId}:{agentId:e.agentId,input:e.input,invocation:e.invocation,listeners:n,priority:e.priority,sessionId:e.sessionId}}function h(e){return{approvalId:e.approvalId,decision:e.decision,editedInput:e.editedInput,requestId:e.requestId,sessionId:e.sessionId}}function b(e){return{requestId:e.requestId,sessionId:e.sessionId,agentId:e.agentId,parentRequestId:e.parentRequestId,executionMode:e.executionMode,adapterKind:e.adapterKind,createdAt:e.createdAt,updatedAt:e.updatedAt,state:e.state,checkpointRef:e.checkpointRef,resumable:e.resumable,startedAt:e.startedAt,endedAt:e.endedAt,lastActivityAt:e.lastActivityAt,currentAgentId:e.currentAgentId,delegationChain:e.delegationChain,runtimeSnapshot:e.runtimeSnapshot}}async function F(e=process.cwd(),t={}){const n=await u("createAgentHarness.loadWorkspace",()=>g(e,t.load??{}),{workspaceRoot:e}),r=await u("createAgentHarness.constructRuntime",async()=>new l(n,t.adapter??{}),{workspaceRoot:e});return await u("createAgentHarness.initializeRuntime",()=>r.initialize(),{workspaceRoot:e}),r}function U(e,t={}){const n=typeof e=="object"&&e!==null&&"role"in e?M(e).content:c(e);return t.invocation?{input:n,invocation:t.invocation}:{input:n}}async function $(e,t){return a(await e.run(w(t)))}async function k(e,t){return e.memorize(t)}async function W(e,t){return e.recall(t)}async function D(e,t={}){return e.listMemories(t)}async function K(e,t){return e.updateMemory(t)}async function j(e,t){return e.removeMemory(t)}function N(e,t){return e.subscribe(async n=>{await t(o(n))})}async function J(e,t){return e.listSessions(t)}async function Q(e,t){return e.listSessionSummaries(t)}async function V(e,t){return e.listRequests(t)}async function X(e,t){return e.getSessionRecord(t)}async function Y(e,t){return e.getRequest(t)}async function p(e,t){const n=await e.getRequest(t.requestId);if(!n)throw new Error(`Request ${t.requestId} was not found.`);if(n.sessionId!==t.sessionId)throw new Error(`Request ${t.requestId} belongs to session ${n.sessionId}, not ${t.sessionId}.`);const r=(n.traceItems??[]).map(i=>d({sessionId:t.sessionId,requestId:t.requestId,item:i})).filter(i=>i!==null);return I({sessionId:t.sessionId,requestId:t.requestId,runtimeTimeline:n.runtimeTimeline,upstreamEvents:r,metadata:{state:n.state,...n.runtimeSnapshot?{runtimeSnapshot:n.runtimeSnapshot}:{}}})}async function Z(e,t){return f(await p(e,t),{direction:"TD",includeGroups:!1,includeKinds:["agent","llm","tool","skill","memory"]})}async function _(e,t){return v(await p(e,t))}async function ee(e,t){return e.deleteSession(t)}async function te(e,t){return(await e.listApprovals({requestId:t?.requestId,status:t?.status,sessionId:t?.sessionId})).map(s)}async function ne(e,t){const n=await e.getApproval(t);return n?s(n):null}async function re(e,t){return R(await e.listRequestArtifacts(t.sessionId,t.requestId))}async function se(e,t){return e.readRequestArtifact(t.sessionId,t.requestId,t.artifactPath)}async function oe(e,t){return e.getRequestPlanState(t.sessionId,t.requestId)}async function ae(e,t){return e.recordArtifact(t)}async function ie(e,t){return(await e.listRequestEvents(t.sessionId,t.requestId)).map(o)}async function ue(e,t){const n=await e.getRequest(t.requestId);if(!n)throw new Error(`Request ${t.requestId} was not found.`);if(n.sessionId!==t.sessionId)throw new Error(`Request ${t.requestId} belongs to session ${n.sessionId}, not ${t.sessionId}.`);return(n.traceItems??[]).map(r=>d({sessionId:t.sessionId,requestId:t.requestId,item:r})).filter(r=>r!==null)}async function ce(e){return e.getHealth()}async function de(e,t){const n=await e.getOperatorOverview(t),r={total:n.requests.total,states:n.requests.states,items:n.requests.items.map(b)};return{...n,approvals:{total:n.approvals.total,items:n.approvals.items.map(s)},requests:r}}async function pe(e,t){const n=await e.exportRequestPackage(t);return{...S(n),planState:await e.getRequestPlanState(t.sessionId,t.requestId)}}async function le(e,t){return e.exportSessionPackage(t)}async function Ie(e,t){return e.exportEvaluationBundle(t)}async function fe(e,t){const n=await e.replayEvaluationBundle(t);return{...n,result:a(n.result)}}function ve(e,t){return A(e,t)}async function me(e,t){return x(e,t)}async function qe(e,t){return q(e,t)}async function xe(e,t){return m(e,t)}function Ae(e,t,n){return e.listAgentSkills(t,n)}function ge(e,t,n){return e.getAgent(t,n)}function ye(e,t){return e.describeWorkspaceInventory(t)}function Re(e,t){return e.analyzeWorkspaceBoundaries(t)}async function Se(e,t){return a(await e.resume(h(t)))}async function we(e,t){return a(await e.cancelRequest(t))}async function he(e){return e.stop()}async function be(e,t){return e.createToolMcpServer(t)}async function Me(e,t){return e.serveToolsOverStdio(t)}async function He(e,t){return e.createRuntimeMcpServer(t)}async function Te(e,t){return e.serveRuntimeMcpOverStdio(t)}async function Ee(e,t){return e.serveRuntimeMcpOverStreamableHttp(t)}function M(e){if(e.role!=="user")throw new Error("normalizeUserChatInput only accepts user-role chat messages.");return{role:"user",content:c(e.content)}}export{Le as AgentHarnessAcpServer,Fe as AgentHarnessRuntime,Re as analyzeBoundaries,we as cancelRequest,Ce as createAcpServer,Ge as createAcpStdioClient,F as createAgentHarness,He as createRuntimeMcpServer,be as createToolMcpServer,$e as createUpstreamTimelineReducer,ee as deleteSession,ye as describeInventory,Ie as exportEvaluationBundle,Z as exportFlow,pe as exportRequestPackage,_ as exportSequence,le as exportSessionPackage,ge as getAgent,ne as getApproval,se as getArtifact,ce as getHealth,de as getOperatorOverview,Y as getRequest,oe as getRequestPlanState,X as getSession,Ae as listAgentSkills,te as listApprovals,D as listMemories,re as listRequestArtifacts,ie as listRequestEvents,ue as listRequestTraceItems,V as listRequests,Q as listSessionSummaries,J as listSessions,k as memorize,U as normalizeUserChatInput,W as recall,ae as recordArtifact,j as removeMemory,fe as replayEvaluationBundle,$ as request,Se as resolveApproval,xe as serveA2aHttp,me as serveAcpHttp,ve as serveAcpStdio,qe as serveAgUiHttp,Te as serveRuntimeMcpOverStdio,Ee as serveRuntimeMcpOverStreamableHttp,Me as serveToolsOverStdio,he as stop,N as subscribe,K as updateMemory};

package/dist/benchmark/checkpoint-resume-cost-benchmark.js

@@ -1,55 +1 @@
-export const DEFAULT_CHECKPOINT_RESUME_CHECKPOINTERS = Object.freeze(["memory", "sqlite"]);
-export const DEFAULT_RESUME_COST_INFRA_RETRIES = 2;
-function average(values) {
-    return Number((values.reduce((sum, value) => sum + value, 0) / values.length).toFixed(2));
-}
-function averageOrNull(values) {
-    return values.length > 0 ? average(values) : null;
-}
-export function resolveCheckpointResumeCheckpointers(rawValue) {
-    if (!rawValue) {
-        return [...DEFAULT_CHECKPOINT_RESUME_CHECKPOINTERS];
-    }
-    const parsed = rawValue
-        .split(",")
-        .map((value) => value.trim().toLowerCase())
-        .filter((value) => value === "memory" || value === "sqlite");
-    return parsed.length > 0 ? parsed : [...DEFAULT_CHECKPOINT_RESUME_CHECKPOINTERS];
-}
-export function resolveResumeCostInfraRetries(rawValue) {
-    if (!rawValue) {
-        return DEFAULT_RESUME_COST_INFRA_RETRIES;
-    }
-    const parsed = Number(rawValue);
-    return Number.isInteger(parsed) && parsed >= 0 ? parsed : DEFAULT_RESUME_COST_INFRA_RETRIES;
-}
-export function isRetryableResumeCostError(message) {
-    if (!message) {
-        return false;
-    }
-    const normalized = message.toLowerCase();
-    return (normalized.includes("connection error") ||
-        normalized.includes("network error") ||
-        normalized.includes("fetch failed") ||
-        normalized.includes("socket hang up") ||
-        normalized.includes("econnreset") ||
-        normalized.includes("timed out"));
-}
-export function aggregateCheckpointResumeRuns(model, checkpointerKind, runs) {
-    const successfulRuns = runs.filter((run) => run.status === "completed");
-    return {
-        model,
-        checkpointerKind,
-        repetitions: runs.length,
-        successCount: successfulRuns.length,
-        failureCount: runs.length - successfulRuns.length,
-        avgInitialApprovalMs: averageOrNull(successfulRuns.map((run) => run.initialApprovalMs)),
-        avgSameProcessResumeMs: averageOrNull(successfulRuns.map((run) => run.sameProcessResumeMs)),
-        avgCrossRestartResumeMs: averageOrNull(successfulRuns
-            .map((run) => run.crossRestartResumeMs)
-            .filter((value) => value !== null)),
-        avgTotalMeasuredMs: averageOrNull(successfulRuns.map((run) => run.totalMeasuredMs)),
-        avgApprovalPassCount: averageOrNull(successfulRuns.map((run) => run.approvalPassCount)),
-        crossRestartSuccessCount: successfulRuns.filter((run) => run.crossRestartSupported).length,
-    };
-}
+const u=Object.freeze(["memory","sqlite"]),i=2;function a(t){return Number((t.reduce((e,s)=>e+s,0)/t.length).toFixed(2))}function o(t){return t.length>0?a(t):null}function c(t){if(!t)return[...u];const e=t.split(",").map(s=>s.trim().toLowerCase()).filter(s=>s==="memory"||s==="sqlite");return e.length>0?e:[...u]}function l(t){if(!t)return i;const e=Number(t);return Number.isInteger(e)&&e>=0?e:i}function p(t){if(!t)return!1;const e=t.toLowerCase();return e.includes("connection error")||e.includes("network error")||e.includes("fetch failed")||e.includes("socket hang up")||e.includes("econnreset")||e.includes("timed out")}function m(t,e,s){const n=s.filter(r=>r.status==="completed");return{model:t,checkpointerKind:e,repetitions:s.length,successCount:n.length,failureCount:s.length-n.length,avgInitialApprovalMs:o(n.map(r=>r.initialApprovalMs)),avgSameProcessResumeMs:o(n.map(r=>r.sameProcessResumeMs)),avgCrossRestartResumeMs:o(n.map(r=>r.crossRestartResumeMs).filter(r=>r!==null)),avgTotalMeasuredMs:o(n.map(r=>r.totalMeasuredMs)),avgApprovalPassCount:o(n.map(r=>r.approvalPassCount)),crossRestartSuccessCount:n.filter(r=>r.crossRestartSupported).length}}export{u as DEFAULT_CHECKPOINT_RESUME_CHECKPOINTERS,i as DEFAULT_RESUME_COST_INFRA_RETRIES,m as aggregateCheckpointResumeRuns,p as isRetryableResumeCostError,c as resolveCheckpointResumeCheckpointers,l as resolveResumeCostInfraRetries};

package/dist/benchmark/deepagent-local-model-benchmark.js

@@ -1,35 +1,2 @@
-export const DEFAULT_SERIAL_BENCHMARK_MODELS = Object.freeze([
-    "qwen3.5:0.8b",
-    "qwen3.5:2b",
-    "qwen3.5:4b",
-    "qwen3.5:9b",
-    "gpt-oss",
-]);
-export function resolveSerialBenchmarkModels(rawValue) {
-    if (!rawValue) {
-        return [...DEFAULT_SERIAL_BENCHMARK_MODELS];
-    }
-    const parsed = rawValue.split(",").map((value) => value.trim()).filter(Boolean);
-    return parsed.length > 0 ? parsed : [...DEFAULT_SERIAL_BENCHMARK_MODELS];
-}
-export function buildWarmupRequestPayload(model, token) {
-    return {
-        model,
-        temperature: 0,
-        max_tokens: 32,
-        messages: [
-            {
-                role: "user",
-                content: `Reply with exactly: WARMUP_OK ${token}`,
-            },
-        ],
-    };
-}
-export function extractWarmupOutput(payload) {
-    const content = payload.choices?.[0]?.message?.content ?? "";
-    const reasoning = payload.choices?.[0]?.message?.reasoning ?? "";
-    return {
-        output: `${content}\n${reasoning}`.trim(),
-        completionTokens: payload.usage?.completion_tokens ?? 0,
-    };
-}
+const o=Object.freeze(["qwen3.5:0.8b","qwen3.5:2b","qwen3.5:4b","qwen3.5:9b","gpt-oss"]);function r(e){if(!e)return[...o];const t=e.split(",").map(n=>n.trim()).filter(Boolean);return t.length>0?t:[...o]}function s(e,t){return{model:e,temperature:0,max_tokens:32,messages:[{role:"user",content:`Reply with exactly: WARMUP_OK ${t}`}]}}function c(e){const t=e.choices?.[0]?.message?.content??"",n=e.choices?.[0]?.message?.reasoning??"";return{output:`${t}
+${n}`.trim(),completionTokens:e.usage?.completion_tokens??0}}export{o as DEFAULT_SERIAL_BENCHMARK_MODELS,s as buildWarmupRequestPayload,c as extractWarmupOutput,r as resolveSerialBenchmarkModels};