@botbotgo/agent-harness 0.0.298 → 0.0.299

package/dist/persistence/sqlite-store.js

@@ -5,7 +5,7 @@ import { fileExists, readJson, writeJson } from "../utils/fs.js";
 import { resolveRuntimeRoot, resolveRuntimeSqlitePath } from "../runtime/support/runtime-layout.js";
 import { SqliteRequestContextStore } from "./sqlite-request-context-store.js";
 import { SqliteRequestQueueStore } from "./sqlite-request-queue-store.js";
-const RUNTIME_SQLITE_SCHEMA_VERSION = 6;
+const RUNTIME_SQLITE_SCHEMA_VERSION = 7;
 const RUNTIME_SQLITE_SCHEMA_FAMILY = "agent-harness-runtime";
 const ACTIVE_REQUEST_STATES = new Set([
     "queued",
@@ -33,6 +33,8 @@ function parseJson(value) {
 function toSqliteUrl(filePath) {
     return `file:${filePath}`;
 }
+const SQLITE_BUSY_RETRY_ATTEMPTS = 30;
+const SQLITE_BUSY_RETRY_DELAY_MS = 100;
 function nowIso() {
     return new Date(Date.now()).toISOString();
 }
@@ -57,6 +59,24 @@ function throwWrappedRuntimeSqliteError(dbPath, sql, error) {
     wrapped.cause = error;
     throw wrapped;
 }
+function collectErrorMessages(error) {
+    const messages = [];
+    let current = error;
+    while (current instanceof Error) {
+        messages.push(current.message);
+        current = current.cause;
+    }
+    if (typeof current === "string" && current.length > 0) {
+        messages.push(current);
+    }
+    return messages;
+}
+function isSqliteBusyError(error) {
+    return collectErrorMessages(error).some((message) => /SQLITE_BUSY|database is locked/i.test(message));
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function buildWhereClause(filters) {
     const active = filters.filter(([, value]) => value !== undefined);
     if (active.length === 0) {
@@ -121,25 +141,36 @@ export class SqlitePersistence {
     }
     async rawExecute(sql, args) {
         const client = await this.getClient();
-        try {
-            if (args) {
-                await client.execute(sql, args);
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                if (args) {
+                    await client.execute(sql, args);
+                    return;
+                }
+                await client.execute(sql);
                 return;
             }
-            await client.execute(sql);
-        }
-        catch (error) {
-            throwWrappedRuntimeSqliteError(this.dbPath, sql, error);
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
+                    throwWrappedRuntimeSqliteError(this.dbPath, sql, error);
+                }
+                await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
+            }
         }
     }
     async rawSelectAll(sql, args) {
         const client = await this.getClient();
-        try {
-            const result = args ? await client.execute(sql, args) : await client.execute(sql);
-            return result.rows.map((row) => asRow(row));
-        }
-        catch (error) {
-            throwWrappedRuntimeSqliteError(this.dbPath, sql, error);
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                const result = args ? await client.execute(sql, args) : await client.execute(sql);
+                return result.rows.map((row) => asRow(row));
+            }
+            catch (error) {
+                if (!isSqliteBusyError(error) || attempt >= SQLITE_BUSY_RETRY_ATTEMPTS) {
+                    throwWrappedRuntimeSqliteError(this.dbPath, sql, error);
+                }
+                await sleep(Math.min(SQLITE_BUSY_RETRY_DELAY_MS * (attempt + 1), 1_000));
+            }
         }
     }
     async ensureInitialized() {
@@ -312,6 +343,18 @@ export class SqlitePersistence {
             await this.rawExecute("CREATE INDEX IF NOT EXISTS request_queue_available_idx ON request_queue(available_at, priority DESC, enqueued_at ASC)");
             await this.rawExecute("CREATE INDEX IF NOT EXISTS request_queue_claim_idx ON request_queue(claimed_by, lease_expires_at)");
             await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS request_plan_state (
+          request_id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          version INTEGER NOT NULL,
+          updated_at TEXT NOT NULL,
+          plan_json TEXT NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id),
+          FOREIGN KEY (request_id) REFERENCES requests(request_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS request_plan_state_thread_updated_idx ON request_plan_state(session_id, updated_at DESC)");
+            await this.rawExecute(`
         CREATE TABLE IF NOT EXISTS request_control (
           request_id TEXT PRIMARY KEY,
           cancel_requested INTEGER NOT NULL DEFAULT 0,
@@ -545,6 +588,22 @@ export class SqlitePersistence {
             await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
             return;
         }
+        if (version === "6") {
+            await this.rawExecute(`
+        CREATE TABLE IF NOT EXISTS request_plan_state (
+          request_id TEXT PRIMARY KEY,
+          session_id TEXT NOT NULL,
+          version INTEGER NOT NULL,
+          updated_at TEXT NOT NULL,
+          plan_json TEXT NOT NULL,
+          FOREIGN KEY (session_id) REFERENCES sessions(session_id),
+          FOREIGN KEY (request_id) REFERENCES requests(request_id)
+        )
+      `);
+            await this.rawExecute("CREATE INDEX IF NOT EXISTS request_plan_state_thread_updated_idx ON request_plan_state(session_id, updated_at DESC)");
+            await this.rawExecute("INSERT OR REPLACE INTO runtime_metadata (key, value) VALUES (?, ?)", ["schema_version", String(RUNTIME_SQLITE_SCHEMA_VERSION)]);
+            return;
+        }
         if (version !== String(RUNTIME_SQLITE_SCHEMA_VERSION)) {
             throw new Error(`Unsupported runtime sqlite schema version ${JSON.stringify(version)} in ${this.dbPath}. Expected ${RUNTIME_SQLITE_SCHEMA_VERSION}.`);
         }
@@ -964,6 +1023,7 @@ export class SqlitePersistence {
         if (!exists) {
             return false;
         }
+        await this.execute("DELETE FROM request_plan_state WHERE session_id = ?", [sessionId]);
         await this.execute("DELETE FROM artifacts WHERE session_id = ?", [sessionId]);
         await this.execute("DELETE FROM approvals WHERE session_id = ?", [sessionId]);
         await this.execute("DELETE FROM events WHERE session_id = ?", [sessionId]);
@@ -1022,6 +1082,20 @@ export class SqlitePersistence {
         await this.createApproval(updated);
         return updated;
     }
+    async saveRequestPlanState(sessionId, requestId, planState) {
+        await this.execute(`INSERT OR REPLACE INTO request_plan_state
+       (request_id, session_id, version, updated_at, plan_json)
+       VALUES (?, ?, ?, ?, ?)`, [requestId, sessionId, planState.version, planState.updatedAt, JSON.stringify(planState)]);
+    }
+    async getRequestPlanState(sessionId, requestId) {
+        const row = await this.selectOne(`SELECT plan_json
+       FROM request_plan_state
+       WHERE session_id = ? AND request_id = ?`, [sessionId, requestId]);
+        return row?.plan_json ? parseJson(row.plan_json) : null;
+    }
+    async clearRequestPlanState(sessionId, requestId) {
+        await this.execute("DELETE FROM request_plan_state WHERE session_id = ? AND request_id = ?", [sessionId, requestId]);
+    }
     async createRequestArtifact(sessionId, requestId, artifact, content) {
         const filePath = path.join(this.requestDir(sessionId, requestId), artifact.path);
         await mkdir(path.dirname(filePath), { recursive: true });

package/dist/persistence/types.d.ts

@@ -1,4 +1,4 @@
-import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, MessageContent, RequestSummary, RuntimeSnapshot, RequestState, SessionRequestRecord, SessionSummary, TranscriptMessage } from "../contracts/types.js";
+import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, MessageContent, RequestPlanState, RequestSummary, RuntimeSnapshot, RequestState, SessionRequestRecord, SessionSummary, TranscriptMessage } from "../contracts/types.js";
 export type PersistenceSessionMeta = {
     sessionId: string;
     workspaceId: string;
@@ -157,6 +157,9 @@ export interface RuntimePersistence {
     clearRequestInput(sessionId: string, requestId: string): Promise<void>;
     createApproval(record: InternalApprovalRecord): Promise<void>;
     resolveApproval(sessionId: string, requestId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
+    saveRequestPlanState(sessionId: string, requestId: string, planState: RequestPlanState): Promise<void>;
+    getRequestPlanState(sessionId: string, requestId: string): Promise<RequestPlanState | null>;
+    clearRequestPlanState(sessionId: string, requestId: string): Promise<void>;
     createRequestArtifact(sessionId: string, requestId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
     listRequestArtifacts(sessionId: string, requestId: string): Promise<ArtifactListing>;
     readRequestArtifact(sessionId: string, requestId: string, artifactPath: string): Promise<unknown>;

package/dist/procedural/config.d.ts

@@ -0,0 +1,63 @@
+export type ProceduralMemoryProviderConfig = {
+    kind: string;
+    options: Record<string, unknown> | null;
+};
+export type ProceduralMemoryBackgroundConfig = {
+    enabled: boolean;
+    scopeHints: string[];
+    maxMessagesPerRequest: number;
+    writeOnApprovalResolution: boolean;
+    writeOnRequestCompletion: boolean;
+    stateStorePath: string;
+};
+export type ProceduralMemoryFormationConfig = {
+    backgroundOnly: boolean;
+    background: ProceduralMemoryBackgroundConfig | null;
+};
+export type ProceduralMemoryRetrievalConfig = {
+    enabled: boolean;
+    defaultTopK: number;
+    maxPromptItems: number;
+};
+export type ProceduralMemoryMaintenanceScheduleConfig = {
+    enabled: boolean;
+    everyMinutes: number;
+};
+export type ProceduralMemoryMaintenanceIdleConfig = {
+    enabled: boolean;
+    minIdleMinutes: number;
+    maxRunsPerIdleWindow: number;
+};
+export type ProceduralMemoryMaintenanceConfig = {
+    enabled: boolean;
+    onWrite: {
+        dedupeNearby: boolean;
+        updateFrequency: boolean;
+    };
+    schedule: ProceduralMemoryMaintenanceScheduleConfig | null;
+    idle: ProceduralMemoryMaintenanceIdleConfig | null;
+    tasks: string[];
+    limits: {
+        maxRecordsPerRun: number;
+        maxClustersPerRun: number;
+    };
+    decay: {
+        enabled: boolean;
+        maxAgeDays?: number;
+    };
+    pruning: {
+        minScore?: number;
+        minFrequency?: number;
+    };
+};
+export type ProceduralMemoryRuntimeConfig = {
+    enabled: boolean;
+    provider: ProceduralMemoryProviderConfig | null;
+    store: Record<string, unknown> | null;
+    vectorStore: Record<string, unknown> | null;
+    embeddingModel: Record<string, unknown> | null;
+    formation: ProceduralMemoryFormationConfig | null;
+    retrieval: ProceduralMemoryRetrievalConfig | null;
+    maintenance: ProceduralMemoryMaintenanceConfig | null;
+};
+export declare function readProceduralMemoryRuntimeConfig(proceduralMemory: Record<string, unknown> | undefined): ProceduralMemoryRuntimeConfig;

package/dist/procedural/config.js

@@ -0,0 +1,125 @@
+function asObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : undefined;
+}
+function asString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const items = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    return items.length > 0 ? Array.from(new Set(items)) : undefined;
+}
+function asBoolean(value) {
+    return typeof value === "boolean" ? value : undefined;
+}
+function asPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+function asNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function readProceduralMemoryRuntimeSpec(source) {
+    const typed = asObject(source);
+    if (!typed) {
+        return undefined;
+    }
+    const kind = typeof typed.kind === "string" ? typed.kind : undefined;
+    const hasTypedEnvelope = typeof typed.apiVersion === "string" || !!asObject(typed.metadata);
+    if (kind === "ProceduralMemoryRuntime") {
+        return asObject(typed.spec);
+    }
+    if (hasTypedEnvelope && asObject(typed.spec)) {
+        return asObject(typed.spec);
+    }
+    return typed;
+}
+export function readProceduralMemoryRuntimeConfig(proceduralMemory) {
+    const spec = readProceduralMemoryRuntimeSpec(proceduralMemory);
+    const enabled = spec?.enabled === true;
+    const provider = asObject(spec?.provider);
+    const mode = asObject(spec?.mode);
+    const trigger = asObject(spec?.trigger);
+    const extraction = asObject(spec?.extraction);
+    const retrieval = asObject(spec?.retrieval);
+    const maintenance = asObject(spec?.maintenance);
+    const onWrite = asObject(maintenance?.onWrite);
+    const schedule = asObject(maintenance?.schedule);
+    const idle = asObject(maintenance?.idle);
+    const limits = asObject(maintenance?.limits);
+    const decay = asObject(maintenance?.decay);
+    const pruning = asObject(maintenance?.pruning);
+    return {
+        enabled,
+        provider: provider
+            ? {
+                kind: asString(provider.kind) ?? "reme",
+                options: Object.keys(provider).filter((key) => key !== "kind").length > 0
+                    ? Object.fromEntries(Object.entries(provider).filter(([key]) => key !== "kind"))
+                    : null,
+            }
+            : null,
+        store: asObject(spec?.store) ?? null,
+        vectorStore: asObject(spec?.vectorStore) ?? null,
+        embeddingModel: asObject(spec?.embeddingModel) ?? null,
+        formation: enabled
+            ? {
+                backgroundOnly: mode?.backgroundOnly !== false,
+                background: {
+                    enabled: true,
+                    scopeHints: asStringArray(extraction?.focus) ?? ["coding_patterns", "workflow_patterns", "debugging_lessons"],
+                    maxMessagesPerRequest: asPositiveInteger(extraction?.maxMessagesPerRequest) ?? 60,
+                    writeOnApprovalResolution: trigger?.onApprovalResolved === true,
+                    writeOnRequestCompletion: trigger?.onRequestCompleted !== false,
+                    stateStorePath: asString(asObject(spec?.state)?.cursorPath) ?? "knowledge/procedural-memory-state.json",
+                },
+            }
+            : null,
+        retrieval: enabled
+            ? {
+                enabled: retrieval?.enabled !== false,
+                defaultTopK: asPositiveInteger(retrieval?.defaultTopK) ?? 5,
+                maxPromptItems: asPositiveInteger(retrieval?.maxPromptItems) ?? 4,
+            }
+            : null,
+        maintenance: enabled
+            ? {
+                enabled: maintenance?.enabled !== false,
+                onWrite: {
+                    dedupeNearby: onWrite?.dedupeNearby !== false,
+                    updateFrequency: onWrite?.updateFrequency !== false,
+                },
+                schedule: schedule
+                    ? {
+                        enabled: schedule.enabled !== false,
+                        everyMinutes: asPositiveInteger(schedule.everyMinutes) ?? 60,
+                    }
+                    : null,
+                idle: idle
+                    ? {
+                        enabled: idle.enabled !== false,
+                        minIdleMinutes: asPositiveInteger(idle.minIdleMinutes) ?? 20,
+                        maxRunsPerIdleWindow: asPositiveInteger(idle.maxRunsPerIdleWindow) ?? 1,
+                    }
+                    : null,
+                tasks: asStringArray(maintenance?.tasks) ?? ["dedupe", "merge_similar", "decay_stale", "prune_low_value"],
+                limits: {
+                    maxRecordsPerRun: asPositiveInteger(limits?.maxRecordsPerRun) ?? 200,
+                    maxClustersPerRun: asPositiveInteger(limits?.maxClustersPerRun) ?? 50,
+                },
+                decay: {
+                    enabled: decay?.enabled !== false,
+                    ...(asPositiveInteger(decay?.maxAgeDays) ? { maxAgeDays: asPositiveInteger(decay?.maxAgeDays) } : {}),
+                },
+                pruning: {
+                    ...(asNumber(pruning?.minScore) !== undefined ? { minScore: asNumber(pruning?.minScore) } : {}),
+                    ...(asPositiveInteger(pruning?.minFrequency) ? { minFrequency: asPositiveInteger(pruning?.minFrequency) } : {}),
+                },
+            }
+            : null,
+    };
+}

package/dist/procedural/index.d.ts

@@ -0,0 +1,2 @@
+export { readProceduralMemoryRuntimeConfig } from "./config.js";
+export type { ProceduralMemoryBackgroundConfig, ProceduralMemoryFormationConfig, ProceduralMemoryMaintenanceConfig, ProceduralMemoryMaintenanceIdleConfig, ProceduralMemoryMaintenanceScheduleConfig, ProceduralMemoryProviderConfig, ProceduralMemoryRetrievalConfig, ProceduralMemoryRuntimeConfig, } from "./config.js";

package/dist/procedural/index.js

@@ -0,0 +1 @@
+export { readProceduralMemoryRuntimeConfig } from "./config.js";

package/dist/protocol/ag-ui/http.d.ts

@@ -42,6 +42,9 @@ export type AgUiEvent = (AgUiBaseEvent & {
 }) | (AgUiBaseEvent & {
     type: "THINKING_TEXT_MESSAGE_END";
     messageId: string;
+}) | (AgUiBaseEvent & {
+    type: "STATUS_UPDATE";
+    message: string;
 }) | (AgUiBaseEvent & {
     type: "TEXT_MESSAGE_START";
     messageId: string;

package/dist/protocol/ag-ui/http.js

@@ -213,6 +213,16 @@ export async function serveAgUiOverHttp(runtime, options = {}) {
                             });
                         }
                     },
+                    dataListener: async (event) => {
+                        if (event.type !== "progress.commentary") {
+                            return;
+                        }
+                        await writeSseEvent(response, {
+                            type: "STATUS_UPDATE",
+                            timestamp: createTimestamp(),
+                            message: event.text,
+                        });
+                    },
                     onUpstreamEvent: async (event) => {
                         const eventName = readUpstreamEventName(event);
                         const toolName = readUpstreamToolName(event);

package/dist/request-events.d.ts

@@ -0,0 +1,63 @@
+import type { HarnessEvent, RequestDataEvent, RequestEventSnapshot, RequestExecutionStep, RequestPlanState, RequestResult, RuntimeSurfaceItem, UpstreamRuntimeEvent } from "./contracts/types.js";
+type StreamEventItem = {
+    type: "event";
+    event: HarnessEvent;
+};
+type StreamContentItem = {
+    type: "content";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    content: string;
+};
+type StreamContentBlocksItem = {
+    type: "content-blocks";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    contentBlocks: unknown[];
+};
+type StreamToolResultItem = {
+    type: "tool-result";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    toolName: string;
+    output: unknown;
+    isError?: boolean;
+};
+type StreamPlanStateItem = {
+    type: "plan-state";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    planState: RequestPlanState;
+};
+type StreamUpstreamEventItem = {
+    type: "upstream-event";
+    sessionId: string;
+    requestId: string;
+    surfaceItem?: RuntimeSurfaceItem;
+    event: UpstreamRuntimeEvent;
+};
+type StreamProfileStepItem = {
+    type: "profile-step";
+    sessionId: string;
+    requestId: string;
+    step: RequestExecutionStep;
+};
+type StreamResultItem = {
+    type: "result";
+    result: RequestResult;
+};
+export type RequestSnapshotStreamItem = StreamEventItem | {
+    type: "commentary";
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    content: string;
+} | StreamContentItem | StreamContentBlocksItem | StreamToolResultItem | StreamPlanStateItem | StreamUpstreamEventItem | StreamProfileStepItem | StreamResultItem;
+export declare function createInitialRequestEventSnapshot(): RequestEventSnapshot;
+export declare function applyRequestStreamItemToSnapshot(snapshot: RequestEventSnapshot, item: RequestSnapshotStreamItem): RequestEventSnapshot;
+export declare function toRequestDataEvent(item: RequestSnapshotStreamItem): RequestDataEvent | null;
+export {};