@botbotgo/agent-harness 0.0.309 → 0.0.310

package/dist/client/acp.d.ts

@@ -1,50 +1 @@
-import { type AcpHttpClientOptions, type AcpStdioClient, type AcpStdioClientOptions } from "../acp.js";
-import type { Approval, OperatorOverview, RequestEvent, RequestPlanState, RequestTraceItem } from "../api.js";
-import type { CancelOptions, RequestSummary, RuntimeHealthSnapshot, SessionListSummary, SessionRecord, SessionSummary } from "../contracts/types.js";
-import type { HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult } from "./types.js";
-export type AcpHarnessTransport = Pick<AcpStdioClient, "request" | "subscribe" | "close">;
-export declare class AcpHarnessClient implements HarnessClient {
-    private readonly transport;
-    private streamSequence;
-    constructor(transport: AcpHarnessTransport);
-    request(options: HarnessClientRequestOptions): Promise<HarnessClientRequestResult>;
-    private hasStreamingListeners;
-    private streamRequestInternal;
-    private requestWithStreamingListeners;
-    resolveApproval(options: Parameters<HarnessClient["resolveApproval"]>[0]): Promise<HarnessClientRequestResult>;
-    cancelRequest(options: CancelOptions): Promise<HarnessClientRequestResult>;
-    subscribe(listener: (event: RequestEvent) => void | Promise<void>): () => void;
-    listSessions(filter?: {
-        agentId?: string;
-        status?: RequestSummary["state"];
-    }): Promise<SessionSummary[]>;
-    listSessionSummaries(filter?: {
-        agentId?: string;
-        status?: RequestSummary["state"];
-    }): Promise<SessionListSummary[]>;
-    listRequests(filter?: HarnessClientRequestFilter): Promise<RequestSummary[]>;
-    getSession(sessionId: string): Promise<SessionRecord | null>;
-    getRequest(requestId: string): Promise<RequestSummary | null>;
-    listApprovals(filter?: HarnessClientApprovalFilter): Promise<Approval[]>;
-    getApproval(approvalId: string): Promise<Approval | null>;
-    getRequestPlanState(input: {
-        sessionId: string;
-        requestId: string;
-    }): Promise<RequestPlanState | null>;
-    listRequestEvents(input: {
-        sessionId: string;
-        requestId: string;
-    }): Promise<RequestEvent[]>;
-    listRequestTraceItems(input: {
-        sessionId: string;
-        requestId: string;
-    }): Promise<RequestTraceItem[]>;
-    getHealth(): Promise<RuntimeHealthSnapshot>;
-    getOperatorOverview(options?: {
-        limit?: number;
-    }): Promise<OperatorOverview>;
-    stop(): Promise<void>;
-}
-export declare function createAcpHarnessClient(transport: AcpHarnessTransport): HarnessClient;
-export declare function createAcpStdioHarnessClient(options: AcpStdioClientOptions): HarnessClient;
-export declare function createAcpHttpHarnessClient(options: AcpHttpClientOptions): HarnessClient;
+export * from "../protocol/acp/harness-client.js";

package/dist/client/acp.js

@@ -1,219 +1 @@
-import { createAcpHttpClient, createAcpStdioClient, } from "../acp.js";
-import { applyRequestStreamItemToSnapshot, createInitialRequestEventSnapshot, toRequestDataEvent, } from "../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;
-            }
-            const dataEvent = toRequestDataEvent(item);
-            if (dataEvent) {
-                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));
-}
+export * from "../protocol/acp/harness-client.js";

package/dist/client/in-process.d.ts

@@ -13,16 +13,16 @@ export declare class InProcessHarnessClient implements HarnessClient {
         status?: Parameters<typeof listSessions>[1] extends infer T ? T extends {
             status?: infer S;
         } ? S : never : never;
-    }): Promise<import("../contracts/runtime.js").SessionSummary[]>;
+    }): Promise<import("../contracts/runtime-observability.js").SessionSummary[]>;
     listSessionSummaries(filter?: {
         agentId?: string;
         status?: Parameters<typeof listSessionSummaries>[1] extends infer T ? T extends {
             status?: infer S;
         } ? S : never : never;
     }): Promise<import("../api.js").SessionListSummary[]>;
-    listRequests(filter?: HarnessClientRequestFilter): Promise<import("../contracts/runtime.js").SessionRequestRecord[]>;
-    getSession(sessionId: string): Promise<import("../contracts/runtime.js").SessionRecord | null>;
-    getRequest(requestId: string): Promise<import("../contracts/runtime.js").RequestRecord | null>;
+    listRequests(filter?: HarnessClientRequestFilter): Promise<import("../contracts/runtime-requests.js").SessionRequestRecord[]>;
+    getSession(sessionId: string): Promise<import("../contracts/runtime-requests.js").SessionRecord | null>;
+    getRequest(requestId: string): Promise<import("../contracts/runtime-requests.js").RequestRecord | null>;
     listApprovals(filter?: HarnessClientApprovalFilter): Promise<import("../api.js").Approval[]>;
     getApproval(approvalId: string): Promise<import("../api.js").Approval | null>;
     getRequestPlanState(input: {
@@ -37,7 +37,7 @@ export declare class InProcessHarnessClient implements HarnessClient {
         sessionId: string;
         requestId: string;
     }): Promise<import("../api.js").RequestTraceItem[]>;
-    getHealth(): Promise<import("../contracts/runtime.js").RuntimeHealthSnapshot>;
+    getHealth(): Promise<import("../contracts/runtime-observability.js").RuntimeHealthSnapshot>;
     getOperatorOverview(options?: {
         limit?: number;
     }): Promise<import("../api.js").OperatorOverview>;

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-export { AcpHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "./acp.js";
+export { AcpHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "../protocol/acp/harness-client.js";
 export { InProcessHarnessClient, createAgentHarnessClient, createInProcessHarnessClient } from "./in-process.js";
 export type { HarnessClient, HarnessClientApprovalFilter, HarnessClientRequestFilter, HarnessClientRequestOptions, HarnessClientRequestResult, HarnessClientRequestStartOptions, } from "./types.js";
-export type { AcpHarnessTransport } from "./acp.js";
+export type { AcpHarnessTransport } from "../protocol/acp/harness-client.js";

package/dist/client/index.js

@@ -1,2 +1,2 @@
-export { AcpHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "./acp.js";
+export { AcpHarnessClient, createAcpHarnessClient, createAcpHttpHarnessClient, createAcpStdioHarnessClient } from "../protocol/acp/harness-client.js";
 export { InProcessHarnessClient, createAgentHarnessClient, createInProcessHarnessClient } from "./in-process.js";

package/dist/contracts/runtime-evaluation.d.ts

@@ -0,0 +1,103 @@
+import type { WorkspaceBundle } from "./workspace.js";
+import type { HarnessEvent, RuntimeHealthSnapshot } from "./runtime-observability.js";
+import type { ApprovalRecord, ArtifactRecord, InvocationEnvelope, MessageContent, RequestRecord, RequestResult, RuntimeGovernanceEvidence, SessionRecord, TranscriptMessage } from "./runtime-requests.js";
+export type RuntimeEvaluationExportInput = {
+    sessionId: string;
+    requestId: string;
+    includeArtifacts?: boolean;
+    includeArtifactContents?: boolean;
+    expectedOutput?: string;
+    rubric?: string[];
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeArtifactWriteInput = {
+    sessionId: string;
+    requestId: string;
+    kind: string;
+    path: string;
+    content: unknown;
+    artifactId?: string;
+    createdAt?: string;
+};
+export type RuntimeEvaluationArtifact = ArtifactRecord & {
+    content?: unknown;
+};
+export type RuntimeEvaluationExport = {
+    session: SessionRecord | null;
+    request: RequestRecord | null;
+    requestInput: {
+        input: MessageContent;
+        invocation?: InvocationEnvelope;
+        priority?: number;
+    } | null;
+    approvals: ApprovalRecord[];
+    transcript: TranscriptMessage[];
+    events: HarnessEvent[];
+    artifacts: RuntimeEvaluationArtifact[];
+    runtimeHealth: RuntimeHealthSnapshot;
+    expectedOutput?: string;
+    rubric: string[];
+    tags: string[];
+    metadata?: Record<string, unknown>;
+};
+export type RuntimeEvaluationReplayInput = {
+    bundle: RuntimeEvaluationExport;
+    agentId?: string;
+    sessionId?: string;
+    invocation?: InvocationEnvelope;
+};
+export type RuntimeEvaluationReplayResult = {
+    request: {
+        agentId: string;
+        input: MessageContent;
+        invocation?: InvocationEnvelope;
+        sessionId?: string;
+    };
+    result: RequestResult;
+    assertions: {
+        expectedOutputMatched?: boolean;
+    };
+};
+export type RuntimeRequestPackageInput = {
+    sessionId: string;
+    requestId: string;
+    includeArtifacts?: boolean;
+    includeArtifactContents?: boolean;
+    includeRuntimeHealth?: boolean;
+};
+export type RuntimeRequestPackage = {
+    session: SessionRecord | null;
+    request: RequestRecord | null;
+    approvals: ApprovalRecord[];
+    transcript: TranscriptMessage[];
+    events: HarnessEvent[];
+    artifacts: RuntimeEvaluationArtifact[];
+    governance: RuntimeGovernanceEvidence;
+    runtimeHealth?: RuntimeHealthSnapshot;
+};
+export type RuntimeSessionPackageInput = {
+    sessionId: string;
+    includeArtifacts?: boolean;
+    includeArtifactContents?: boolean;
+    includeRuntimeHealth?: boolean;
+};
+export type RuntimeSessionPackage = {
+    session: SessionRecord | null;
+    requests: RequestRecord[];
+    approvals: ApprovalRecord[];
+    transcript: TranscriptMessage[];
+    requestsPackages: RuntimeRequestPackage[];
+    governance: {
+        requests: Array<{
+            requestId: string;
+            evidence: RuntimeGovernanceEvidence;
+        }>;
+        approvalSummary: import("./runtime-requests.js").RuntimeApprovalSummary;
+        summary: string;
+    };
+    runtimeHealth?: RuntimeHealthSnapshot;
+};
+export type RuntimeInventoryContext = {
+    workspace: WorkspaceBundle;
+};

package/dist/contracts/runtime-evaluation.js

@@ -0,0 +1 @@
+export {};

package/dist/contracts/runtime-memory.d.ts

@@ -0,0 +1,162 @@
+export type MemoryCandidate = {
+    content: string;
+    summary?: string;
+    kind?: string;
+    scope?: string;
+    confidence?: number;
+    tags?: string[];
+    sourceType?: string;
+    sourceRef?: string;
+    observedAt?: string;
+    sensitivity?: string;
+    noStore?: boolean;
+    knowledgeMutation?: {
+        identity: string;
+        operation?: "create" | "update" | "delete";
+    };
+    operationalRule?: {
+        trigger: string;
+        action: string;
+        target: string;
+        effect?: "apply" | "invalidate";
+    };
+    provenance?: Record<string, unknown>;
+};
+export type MemoryKind = "semantic" | "episodic" | "procedural";
+export type MemoryScope = "session" | "agent" | "workspace" | "user" | "project";
+export type MemoryRecordStatus = "active" | "stale" | "conflicted" | "archived" | "pending_review";
+export type MemoryDecisionAction = "reject" | "store" | "merge" | "refresh" | "supersede" | "archive" | "review";
+export type KnowledgeMutationOperation = "create" | "update" | "delete";
+export type MemoryRecord = {
+    id: string;
+    canonicalKey: string;
+    kind: MemoryKind;
+    scope: MemoryScope;
+    content: string;
+    summary: string;
+    status: MemoryRecordStatus;
+    confidence: number;
+    createdAt: string;
+    observedAt: string;
+    lastConfirmedAt: string;
+    expiresAt?: string;
+    sourceType: string;
+    sourceRefs: string[];
+    tags: string[];
+    knowledgeIdentity?: string;
+    knowledgeOperation?: KnowledgeMutationOperation;
+    operationalRule?: {
+        trigger: string;
+        action: string;
+        target: string;
+        effect?: "apply" | "invalidate";
+    };
+    provenance: Record<string, unknown>;
+    revision: number;
+    supersedes: string[];
+    conflictsWith: string[];
+};
+export type MemoryDecision = {
+    action: MemoryDecisionAction;
+    reason: string;
+    recordId?: string;
+    kind?: MemoryRecord["kind"];
+    scope?: MemoryScope;
+    confidence?: number;
+    maintenance?: "none" | "dedupe" | "merge" | "review";
+    reviewRequired?: boolean;
+};
+export type MemorizeInputRecord = {
+    content: string;
+    summary?: string;
+    kind?: MemoryKind;
+    scope?: MemoryScope;
+    confidence?: number;
+    tags?: string[];
+    sourceType?: string;
+    sourceRef?: string;
+    observedAt?: string;
+    sensitivity?: string;
+    knowledgeMutation?: {
+        identity: string;
+        operation?: KnowledgeMutationOperation;
+    };
+    operationalRule?: {
+        trigger: string;
+        action: string;
+        target: string;
+        effect?: "apply" | "invalidate";
+    };
+    provenance?: Record<string, unknown>;
+    noStore?: boolean;
+};
+export type MemorizeInput = {
+    records: MemorizeInputRecord[];
+    sessionId?: string;
+    requestId?: string;
+    agentId?: string;
+    userId?: string;
+    projectId?: string;
+    recordedAt?: string;
+};
+export type KnowledgeRuntimeContext = {
+    sessionId?: string;
+    requestId?: string;
+    agentId?: string;
+    workspaceId: string;
+    userId?: string;
+    projectId?: string;
+    recordedAt?: string;
+};
+export type MemorizeResult = {
+    records: MemoryRecord[];
+    decisions: MemoryDecision[];
+};
+export type RecallInput = {
+    query: string;
+    scopes?: MemoryScope[];
+    kinds?: MemoryKind[];
+    topK?: number;
+    includeStale?: boolean;
+    sessionId?: string;
+    agentId?: string;
+    workspaceId?: string;
+    userId?: string;
+    projectId?: string;
+};
+export type RecallResult = {
+    items: MemoryRecord[];
+};
+export type ListMemoriesInput = {
+    scopes?: MemoryScope[];
+    kinds?: MemoryKind[];
+    status?: MemoryRecordStatus[];
+    sessionId?: string;
+    agentId?: string;
+    workspaceId?: string;
+    userId?: string;
+    projectId?: string;
+    limit?: number;
+};
+export type ListMemoriesResult = {
+    items: MemoryRecord[];
+};
+export type UpdateMemoryInput = {
+    memoryId: string;
+    content?: string;
+    summary?: string;
+    status?: MemoryRecordStatus;
+    confidence?: number;
+    expiresAt?: string | null;
+    sourceType?: string;
+    sourceRefs?: string[];
+    tags?: string[];
+    observedAt?: string;
+    lastConfirmedAt?: string;
+    knowledgeIdentity?: string;
+    knowledgeOperation?: KnowledgeMutationOperation;
+    provenance?: Record<string, unknown>;
+};
+export type RemoveMemoryInput = {
+    memoryId: string;
+};

package/dist/contracts/runtime-memory.js

@@ -0,0 +1 @@
+export {};