@botbotgo/agent-harness 0.0.85 → 0.0.87

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.84";
+export declare const AGENT_HARNESS_VERSION = "0.0.86";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.84";
+export const AGENT_HARNESS_VERSION = "0.0.86";

package/dist/persistence/sqlite-store.d.ts

@@ -15,6 +15,7 @@ export declare class SqlitePersistence implements RuntimePersistence {
     private threadDir;
     private runDir;
     private execute;
+    private executeTransaction;
     private selectOne;
     private selectAll;
     private mapThreadSummary;
@@ -29,6 +30,18 @@ export declare class SqlitePersistence implements RuntimePersistence {
         status: RunState;
         createdAt: string;
     }): Promise<void>;
+    bootstrapRun(input: {
+        threadId: string;
+        agentId: string;
+        runId: string;
+        status: RunState;
+        createdAt: string;
+        executionMode: string;
+        adapterKind?: string;
+        userMessage: TranscriptMessage;
+        runRequest: PersistedRunRequest;
+        createThread: boolean;
+    }): Promise<void>;
     createRun(input: {
         threadId: string;
         runId: string;

package/dist/persistence/sqlite-store.js

@@ -263,6 +263,31 @@ export class SqlitePersistence {
         }
         await client.execute(sql);
     }
+    async executeTransaction(steps) {
+        await this.ensureInitialized();
+        const client = await this.getClient();
+        await client.execute("BEGIN IMMEDIATE");
+        try {
+            for (const step of steps) {
+                if (step.args) {
+                    await client.execute(step.sql, step.args);
+                }
+                else {
+                    await client.execute(step.sql);
+                }
+            }
+            await client.execute("COMMIT");
+        }
+        catch (error) {
+            try {
+                await client.execute("ROLLBACK");
+            }
+            catch {
+                // Ignore rollback failures and preserve the original error.
+            }
+            throw error;
+        }
+    }
     async selectOne(sql, args) {
         await this.ensureInitialized();
         const client = await this.getClient();
@@ -347,6 +372,61 @@ export class SqlitePersistence {
        (thread_id, workspace_id, entry_agent_id, status, latest_run_id, created_at, updated_at)
        VALUES (?, ?, ?, ?, ?, ?, ?)`, [input.threadId, "default", input.agentId, input.status, input.runId, input.createdAt, input.createdAt]);
     }
+    async bootstrapRun(input) {
+        await mkdir(this.threadDir(input.threadId), { recursive: true });
+        await mkdir(path.join(this.runDir(input.threadId, input.runId), "events"), { recursive: true });
+        const steps = [];
+        if (input.createThread) {
+            steps.push({
+                sql: `INSERT OR REPLACE INTO threads
+       (thread_id, workspace_id, entry_agent_id, status, latest_run_id, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`,
+                args: [input.threadId, "default", input.agentId, input.status, input.runId, input.createdAt, input.createdAt],
+            });
+        }
+        steps.push({
+            sql: `INSERT OR REPLACE INTO runs
+       (run_id, thread_id, agent_id, execution_mode, adapter_kind, created_at, updated_at, state, previous_state, state_entered_at, last_transition_at, resumable, checkpoint_ref)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            args: [
+                input.runId,
+                input.threadId,
+                input.agentId,
+                input.executionMode,
+                input.adapterKind ?? input.executionMode ?? null,
+                input.createdAt,
+                input.createdAt,
+                "running",
+                null,
+                input.createdAt,
+                input.createdAt,
+                0,
+                null,
+            ],
+        }, {
+            sql: `INSERT OR REPLACE INTO run_control
+       (run_id, cancel_requested, cancel_reason, cancel_requested_at, heartbeat_at, worker_id, worker_started_at)
+       VALUES (?, 0, NULL, NULL, NULL, NULL, NULL)`,
+            args: [input.runId],
+        }, {
+            sql: `INSERT INTO thread_messages
+       (thread_id, role, content_json, run_id, created_at)
+       VALUES (?, ?, ?, ?, ?)`,
+            args: [
+                input.threadId,
+                input.userMessage.role,
+                JSON.stringify(input.userMessage.content),
+                input.userMessage.runId,
+                input.userMessage.createdAt,
+            ],
+        }, {
+            sql: `INSERT OR REPLACE INTO run_requests
+       (run_id, thread_id, request_json, saved_at)
+       VALUES (?, ?, ?, ?)`,
+            args: [input.runId, input.threadId, JSON.stringify(input.runRequest), input.runRequest.savedAt],
+        });
+        await this.executeTransaction(steps);
+    }
     async createRun(input) {
         await mkdir(path.join(this.runDir(input.threadId, input.runId), "events"), { recursive: true });
         await this.execute(`INSERT OR REPLACE INTO runs

package/dist/persistence/types.d.ts

@@ -75,6 +75,18 @@ export type ApprovalFilter = {
 };
 export interface RuntimePersistence {
     initialize(): Promise<void>;
+    bootstrapRun?(input: {
+        threadId: string;
+        agentId: string;
+        runId: string;
+        status: RunState;
+        createdAt: string;
+        executionMode: string;
+        adapterKind?: string;
+        userMessage: TranscriptMessage;
+        runRequest: PersistedRunRequest;
+        createThread: boolean;
+    }): Promise<void>;
     createThread(input: {
         threadId: string;
         agentId: string;

package/dist/runtime/harness.js

@@ -437,36 +437,54 @@ export class AgentHarnessRuntime {
             this.backgroundTasks.delete(task);
         });
     }
-    async ensureThreadStarted(selectedAgentId, binding, input, existingThreadId) {
+    async ensureThreadStarted(selectedAgentId, binding, input, runRequest, existingThreadId) {
         const threadId = existingThreadId ?? createPersistentId();
         const runId = createPersistentId();
         const createdAt = new Date().toISOString();
         const isNewThread = !existingThreadId;
-        if (isNewThread) {
-            await this.persistence.createThread({
+        const userMessage = {
+            role: "user",
+            content: normalizeMessageContent(input),
+            runId,
+            createdAt,
+        };
+        if (typeof this.persistence.bootstrapRun === "function") {
+            await this.persistence.bootstrapRun({
                 threadId,
-                agentId: selectedAgentId,
+                agentId: binding.agent.id,
                 runId,
                 status: "running",
                 createdAt,
-            });
-        }
-        await Promise.all([
-            this.persistence.appendThreadMessage(threadId, {
-                role: "user",
-                content: normalizeMessageContent(input),
-                runId,
-                createdAt,
-            }),
-            this.persistence.createRun({
-                threadId,
-                runId,
-                agentId: binding.agent.id,
                 executionMode: getBindingAdapterKind(binding),
                 adapterKind: getBindingAdapterKind(binding),
-                createdAt,
-            }),
-        ]);
+                userMessage,
+                runRequest,
+                createThread: isNewThread,
+            });
+        }
+        else {
+            if (isNewThread) {
+                await this.persistence.createThread({
+                    threadId,
+                    agentId: selectedAgentId,
+                    runId,
+                    status: "running",
+                    createdAt,
+                });
+            }
+            await Promise.all([
+                this.persistence.appendThreadMessage(threadId, userMessage),
+                this.persistence.createRun({
+                    threadId,
+                    runId,
+                    agentId: binding.agent.id,
+                    executionMode: getBindingAdapterKind(binding),
+                    adapterKind: getBindingAdapterKind(binding),
+                    createdAt,
+                }),
+                this.persistence.saveRunRequest(threadId, runId, runRequest),
+            ]);
+        }
         return { threadId, runId, createdAt, isNewThread };
     }
     async loadPriorHistory(threadId, runId) {
@@ -1046,9 +1064,9 @@ export class AgentHarnessRuntime {
         if (!policyDecision.allowed) {
             throw new Error(`Policy evaluation blocked agent ${selectedAgentId}: ${policyDecision.reasons.join(", ")}`);
         }
-        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
         const priority = this.normalizeRunPriority(options.priority);
-        const runRequestPromise = this.persistence.saveRunRequest(threadId, runId, this.buildPersistedRunRequest(options.input, invocation, priority));
+        const runRequest = this.buildPersistedRunRequest(options.input, invocation, priority);
+        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
         const runCreatedEventPromise = this.emitRunCreated(threadId, runId, {
             agentId: binding.agent.id,
             requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
@@ -1056,7 +1074,6 @@ export class AgentHarnessRuntime {
             executionMode: getBindingAdapterKind(binding),
         });
         const releaseRunSlotPromise = this.acquireRunSlot(threadId, runId, "running", priority);
-        await runRequestPromise;
         await runCreatedEventPromise;
         const releaseRunSlot = await releaseRunSlotPromise;
         try {
@@ -1093,10 +1110,10 @@ export class AgentHarnessRuntime {
         }
         let emitted = false;
         let streamActivityObserved = false;
-        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, options.threadId);
         const priority = this.normalizeRunPriority(options.priority);
+        const runRequest = this.buildPersistedRunRequest(options.input, invocation, priority);
+        const { threadId, runId, isNewThread } = await this.ensureThreadStarted(selectedAgentId, binding, options.input, runRequest, options.threadId);
         const priorHistoryPromise = Promise.resolve(isNewThread ? [] : undefined).then((historyHint) => historyHint ?? this.loadPriorHistory(threadId, runId));
-        const runRequestPromise = this.persistence.saveRunRequest(threadId, runId, this.buildPersistedRunRequest(options.input, invocation, priority));
         const runCreatedEventPromise = this.emitRunCreated(threadId, runId, {
             agentId: selectedAgentId,
             requestedAgentId: options.agentId ?? AUTO_AGENT_ID,
@@ -1112,7 +1129,6 @@ export class AgentHarnessRuntime {
                 const [priorHistory, acquiredReleaseRunSlot] = await Promise.all([
                     priorHistoryPromise,
                     releaseRunSlotPromise,
-                    runRequestPromise,
                 ]).then(([loadedPriorHistory, resolvedReleaseRunSlot]) => [loadedPriorHistory, resolvedReleaseRunSlot]);
                 releaseRunSlot = acquiredReleaseRunSlot;
                 let assistantOutput = "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.85",
+  "version": "0.0.87",
   "description": "Workspace runtime for multi-agent applications",
   "type": "module",
   "packageManager": "npm@10.9.2",