@botbotgo/agent-harness 0.0.290 → 0.0.291

package/dist/runtime/maintenance/checkpoint-maintenance.js

@@ -55,8 +55,8 @@ function resolveSqliteCheckpointPath(binding) {
     if (kind !== "SqliteSaver") {
         return null;
     }
-    const configuredPath = typeof config.path === "string" ? String(config.path) : resolveRuntimeCheckpointerPath(binding.harnessRuntime.runRoot, "checkpoints.sqlite");
-    return path.isAbsolute(configuredPath) ? configuredPath : path.join(binding.harnessRuntime.runRoot, configuredPath);
+    const configuredPath = typeof config.path === "string" ? String(config.path) : resolveRuntimeCheckpointerPath(binding.harnessRuntime.runtimeRoot, "checkpoints.sqlite");
+    return path.isAbsolute(configuredPath) ? configuredPath : path.join(binding.harnessRuntime.runtimeRoot, configuredPath);
 }
 export function discoverCheckpointMaintenanceTargets(workspace) {
     const deduped = new Map();

package/dist/runtime/maintenance/file-checkpoint-saver.d.ts

@@ -15,6 +15,6 @@ export declare class FileCheckpointSaver extends MemorySaver {
     list(config: MemorySaverConfig, options?: MemorySaverListOptions): AsyncGenerator<import("@langchain/langgraph").CheckpointTuple, void, unknown>;
     put(config: MemorySaverConfig, checkpoint: MemorySaverPutCheckpoint, metadata: MemorySaverPutMetadata): MemorySaverPutResult;
     putWrites(config: MemorySaverConfig, writes: MemorySaverPutWrites, taskId: string): Promise<void>;
-    deleteThread(threadId: string): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
 }
 export { FileCheckpointSaver as FileCheckpointer };

package/dist/runtime/maintenance/file-checkpoint-saver.js

@@ -29,15 +29,15 @@ function decodeBinary(value) {
     }
     return value;
 }
-function pruneThreadEntries(record, threadId) {
+function pruneSessionEntries(record, sessionId) {
     for (const key of Object.keys(record)) {
-        if (key.includes(threadId)) {
+        if (key.includes(sessionId)) {
             delete record[key];
             continue;
         }
         const value = record[key];
         if (typeof value === "object" && value && !Array.isArray(value)) {
-            pruneThreadEntries(value, threadId);
+            pruneSessionEntries(value, sessionId);
             if (Object.keys(value).length === 0) {
                 delete record[key];
             }
@@ -96,10 +96,10 @@ export class FileCheckpointSaver extends MemorySaver {
         await this.persist();
         return result;
     }
-    async deleteThread(threadId) {
+    async deleteSession(sessionId) {
         await this.ensureLoaded();
-        pruneThreadEntries(this.storage, threadId);
-        pruneThreadEntries(this.writes, threadId);
+        pruneSessionEntries(this.storage, sessionId);
+        pruneSessionEntries(this.writes, sessionId);
         await this.persist();
     }
 }

package/dist/runtime/maintenance/runtime-record-maintenance.d.ts

@@ -26,7 +26,7 @@ export type RuntimeRecordMaintenanceLoopStatus = {
 export declare function readRuntimeRecordMaintenanceConfig(workspace: WorkspaceBundle): RuntimeRecordMaintenanceConfig | null;
 export declare function discoverRuntimeRecordMaintenanceTargets(workspace: WorkspaceBundle): RuntimeRecordMaintenanceTarget[];
 export declare function maintainSqliteRuntimeRecords(dbPath: string, config: RuntimeRecordMaintenanceConfig, nowMs?: number): Promise<{
-    deletedThreadCount: number;
+    deletedSessionCount: number;
 }>;
 export declare class RuntimeRecordMaintenanceLoop {
     private readonly targets;

package/dist/runtime/maintenance/runtime-record-maintenance.js

@@ -46,68 +46,68 @@ export function readRuntimeRecordMaintenanceConfig(workspace) {
     return config;
 }
 export function discoverRuntimeRecordMaintenanceTargets(workspace) {
-    const runRoots = new Set();
+    const runtimeRoots = new Set();
     for (const binding of workspace.bindings.values()) {
-        runRoots.add(binding.harnessRuntime.runRoot);
+        runtimeRoots.add(binding.harnessRuntime.runtimeRoot);
     }
-    return Array.from(runRoots.values()).map((runRoot) => ({
-        dbPath: resolveRuntimeSqlitePath(runRoot),
+    return Array.from(runtimeRoots.values()).map((runtimeRoot) => ({
+        dbPath: resolveRuntimeSqlitePath(runtimeRoot),
     }));
 }
 export async function maintainSqliteRuntimeRecords(dbPath, config, nowMs = Date.now()) {
     if (!(await fileExists(dbPath))) {
-        return { deletedThreadCount: 0 };
+        return { deletedSessionCount: 0 };
     }
     const client = createClient({ url: `file:${dbPath}` });
     const cutoffIso = new Date(nowMs - (config.policies.maxAgeSeconds ?? 0) * 1000).toISOString();
-    const runRoot = path.dirname(dbPath);
+    const runtimeRoot = path.dirname(dbPath);
     const result = await client.execute({
-        sql: `SELECT thread_id
-          FROM threads
+        sql: `SELECT session_id
+          FROM sessions
           WHERE status IN ('completed', 'failed')
             AND updated_at <= ?
-          ORDER BY updated_at ASC, thread_id ASC
+          ORDER BY updated_at ASC, session_id ASC
           LIMIT ?`,
         args: [cutoffIso, config.sqlite.sweepBatchSize],
     });
     const rows = result.rows.map((row) => row);
     if (rows.length === 0) {
-        return { deletedThreadCount: 0 };
+        return { deletedSessionCount: 0 };
     }
-    let deletedThreadCount = 0;
+    let deletedSessionCount = 0;
     for (const row of rows) {
-        const threadId = row.thread_id;
+        const sessionId = row.session_id;
         const artifacts = await client.execute({
-            sql: `SELECT run_id, path FROM artifacts WHERE thread_id = ?`,
-            args: [threadId],
+            sql: `SELECT request_id, path FROM artifacts WHERE session_id = ?`,
+            args: [sessionId],
         });
         for (const artifact of artifacts.rows) {
-            const runId = String(artifact.run_id ?? "");
+            const requestId = String(artifact.request_id ?? "");
             const artifactPath = String(artifact.path ?? "");
-            if (runId && artifactPath) {
-                await rm(path.join(runRoot, "threads", threadId, "runs", runId, artifactPath), { force: true });
+            if (requestId && artifactPath) {
+                await rm(path.join(runtimeRoot, "sessions", sessionId, "requests", requestId, artifactPath), { force: true });
             }
         }
         await client.batch([
-            "DELETE FROM artifacts WHERE thread_id = ?",
-            "DELETE FROM approvals WHERE thread_id = ?",
-            "DELETE FROM events WHERE thread_id = ?",
-            "DELETE FROM run_inspection WHERE thread_id = ?",
-            "DELETE FROM run_queue WHERE thread_id = ?",
-            "DELETE FROM run_requests WHERE thread_id = ?",
-            "DELETE FROM recovery_intents WHERE thread_id = ?",
-            "DELETE FROM thread_messages WHERE thread_id = ?",
-            "DELETE FROM run_control WHERE run_id IN (SELECT run_id FROM runs WHERE thread_id = ?)",
-            "DELETE FROM runs WHERE thread_id = ?",
-            "DELETE FROM threads WHERE thread_id = ?",
-        ].map((sql) => ({ sql, args: [threadId] })), "write");
-        await rm(path.join(runRoot, "threads", threadId), { recursive: true, force: true });
-        deletedThreadCount += 1;
+            "DELETE FROM artifacts WHERE session_id = ?",
+            "DELETE FROM approvals WHERE session_id = ?",
+            "DELETE FROM events WHERE session_id = ?",
+            "DELETE FROM request_inspection WHERE session_id = ?",
+            "DELETE FROM request_queue WHERE session_id = ?",
+            "DELETE FROM request_inputs WHERE session_id = ?",
+            "DELETE FROM recovery_intents WHERE session_id = ?",
+            "DELETE FROM session_messages WHERE session_id = ?",
+            "DELETE FROM request_control WHERE request_id IN (SELECT request_id FROM requests WHERE session_id = ?)",
+            "DELETE FROM requests WHERE session_id = ?",
+            "DELETE FROM sessions WHERE session_id = ?",
+        ].map((sql) => ({ sql, args: [sessionId] })), "write");
+        await rm(path.join(runtimeRoot, "sessions", sessionId), { recursive: true, force: true });
+        deletedSessionCount += 1;
     }
-    if (deletedThreadCount > 0 && config.sqlite.vacuum) {
+    if (deletedSessionCount > 0 && config.sqlite.vacuum) {
         await client.execute("VACUUM");
     }
-    return { deletedThreadCount };
+    return { deletedSessionCount };
 }
 export class RuntimeRecordMaintenanceLoop {
     targets;

package/dist/runtime/maintenance/sqlite-checkpoint-saver.d.ts

@@ -23,6 +23,6 @@ export declare class SqliteCheckpointSaver extends MemorySaver {
     list(config: MemorySaverConfig, options?: MemorySaverListOptions): AsyncGenerator<import("@langchain/langgraph").CheckpointTuple, void, unknown>;
     put(config: MemorySaverConfig, checkpoint: MemorySaverPutCheckpoint, metadata: MemorySaverPutMetadata): MemorySaverPutResult;
     putWrites(config: MemorySaverConfig, writes: MemorySaverPutWrites, taskId: string): Promise<void>;
-    deleteThread(threadId: string): Promise<void>;
+    deleteSession(sessionId: string): Promise<void>;
 }
 export { SqliteCheckpointSaver as SqliteSaver };

package/dist/runtime/maintenance/sqlite-checkpoint-saver.js

@@ -2,8 +2,28 @@ import { mkdirSync } from "node:fs";
 import path from "node:path";
 import { MemorySaver } from "@langchain/langgraph";
 import { createClient } from "@libsql/client";
+import { UPSTREAM_SESSION_CONFIG_KEY } from "../adapter/upstream-configurable-keys.js";
 const CHECKPOINT_TABLE = "checkpoint_state";
 const DEFAULT_STATE_KEY = "default";
+function normalizeCheckpointConfig(config) {
+    if (!config?.configurable) {
+        return config;
+    }
+    if (UPSTREAM_SESSION_CONFIG_KEY in config.configurable) {
+        return config;
+    }
+    const sessionId = config.configurable.session_id;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+        return config;
+    }
+    return {
+        ...config,
+        configurable: {
+            ...config.configurable,
+            [UPSTREAM_SESSION_CONFIG_KEY]: sessionId,
+        },
+    };
+}
 function encodeBinary(value) {
     if (value instanceof Uint8Array) {
         return {
@@ -32,15 +52,15 @@ function decodeBinary(value) {
     }
     return value;
 }
-function pruneThreadEntries(record, threadId) {
+function pruneSessionEntries(record, sessionId) {
     for (const key of Object.keys(record)) {
-        if (key.includes(threadId)) {
+        if (key.includes(sessionId)) {
             delete record[key];
             continue;
         }
         const value = record[key];
         if (typeof value === "object" && value && !Array.isArray(value)) {
-            pruneThreadEntries(value, threadId);
+            pruneSessionEntries(value, sessionId);
             if (Object.keys(value).length === 0) {
                 delete record[key];
             }
@@ -140,19 +160,19 @@ export class SqliteCheckpointSaver extends MemorySaver {
     async getTuple(config) {
         return this.runSerialized(async () => {
             await this.ensureLoaded();
-            return super.getTuple(config);
+            return super.getTuple(normalizeCheckpointConfig(config));
         });
     }
     async *list(config, options) {
         await this.ensureLoaded();
-        for await (const item of super.list(config, options)) {
+        for await (const item of super.list(normalizeCheckpointConfig(config), options)) {
             yield item;
         }
     }
     async put(config, checkpoint, metadata) {
         return this.runSerialized(async () => {
             await this.ensureLoaded();
-            const result = await super.put(config, checkpoint, metadata);
+            const result = await super.put(normalizeCheckpointConfig(config), checkpoint, metadata);
             await this.persist();
             return result;
         });
@@ -160,16 +180,16 @@ export class SqliteCheckpointSaver extends MemorySaver {
     async putWrites(config, writes, taskId) {
         return this.runSerialized(async () => {
             await this.ensureLoaded();
-            const result = await super.putWrites(config, writes, taskId);
+            const result = await super.putWrites(normalizeCheckpointConfig(config), writes, taskId);
             await this.persist();
             return result;
         });
     }
-    async deleteThread(threadId) {
+    async deleteSession(sessionId) {
         return this.runSerialized(async () => {
             await this.ensureLoaded();
-            pruneThreadEntries(this.storage, threadId);
-            pruneThreadEntries(this.writes, threadId);
+            pruneSessionEntries(this.storage, sessionId);
+            pruneSessionEntries(this.writes, sessionId);
             await this.persist();
         });
     }

package/dist/runtime/support/harness-support.d.ts

@@ -7,8 +7,8 @@ export declare function parseInterruptContent(content: string): {
     allowedDecisions?: Array<"approve" | "edit" | "reject">;
     inputPreview?: Record<string, unknown>;
 };
-export declare function createHarnessEvent(threadId: string, runId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
-export declare function createPendingApproval(threadId: string, runId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
+export declare function createHarnessEvent(sessionId: string, requestId: string, sequence: number, eventType: string, payload: Record<string, unknown>, source?: HarnessEvent["source"]): HarnessEvent;
+export declare function createPendingApproval(sessionId: string, requestId: string, checkpointRef: string, input: string, interruptContent?: string): InternalApprovalRecord;
 export declare function inferRoutingBindings(workspace: WorkspaceBundle): {
     primaryBinding: import("../../contracts/workspace.js").CompiledAgentBinding;
     runtimeEntryBindings: import("../../contracts/workspace.js").CompiledAgentBinding[];

package/dist/runtime/support/harness-support.js

@@ -54,28 +54,28 @@ export function parseInterruptContent(content) {
         return {};
     }
 }
-export function createHarnessEvent(threadId, runId, sequence, eventType, payload, source = "runtime") {
+export function createHarnessEvent(sessionId, requestId, sequence, eventType, payload, source = "runtime") {
     return {
         eventId: `evt-${String(sequence).padStart(6, "0")}`,
         eventType,
         timestamp: new Date().toISOString(),
-        sessionId: threadId,
-        requestId: runId,
+        sessionId,
+        requestId,
         sequence,
         source,
         payload,
     };
 }
-export function createPendingApproval(threadId, runId, checkpointRef, input, interruptContent) {
+export function createPendingApproval(sessionId, requestId, checkpointRef, input, interruptContent) {
     const requestedAt = new Date().toISOString();
     const interrupt = interruptContent ? parseInterruptContent(interruptContent) : {};
     const approvalId = `approval-${createPersistentId()}`;
     return {
         approvalId,
         pendingActionId: approvalId,
-        sessionId: threadId,
-        requestId: runId,
-        toolCallId: interrupt.toolId ?? `tool-${runId}`,
+        sessionId,
+        requestId,
+        toolCallId: interrupt.toolId ?? `tool-${requestId}`,
         toolName: interrupt.toolName ?? "write_file",
         status: "pending",
         requestedAt,

package/dist/runtime/support/runtime-adapter-options.d.ts

@@ -3,7 +3,7 @@ import type { StoreLike } from "../harness/system/store.js";
 export declare function createBindingStoreResolver(input: {
     stores: Map<string, StoreLike>;
     defaultStore: StoreLike;
-    getDefaultRunRoot: () => string;
+    getDefaultRuntimeRoot: () => string;
 }): (binding?: CompiledAgentBinding) => StoreLike;
 export declare function resolveRuntimeAdapterOptions(input: {
     workspace: WorkspaceBundle;
@@ -13,5 +13,5 @@ export declare function resolveRuntimeAdapterOptions(input: {
     defaultStore: StoreLike;
     embeddingModels: Map<string, unknown>;
     vectorStores: Map<string, unknown>;
-    getDefaultRunRoot: () => string;
+    getDefaultRuntimeRoot: () => string;
 }): RuntimeAdapterOptions;

package/dist/runtime/support/runtime-adapter-options.js

@@ -2,15 +2,15 @@ import { createResourceBackendResolver, createResourceToolResolver } from "../..
 import { resolveCheckpointer, resolveEmbeddingModel, resolveStore, resolveVectorStore, } from "../harness/run/resources.js";
 import { getBindingStoreConfig } from "./compiled-binding.js";
 export function createBindingStoreResolver(input) {
-    return (binding) => resolveStore(input.stores, input.defaultStore, input.getDefaultRunRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding);
+    return (binding) => resolveStore(input.stores, input.defaultStore, input.getDefaultRuntimeRoot(), (currentBinding) => currentBinding ? getBindingStoreConfig(currentBinding) : undefined, binding);
 }
 export function resolveRuntimeAdapterOptions(input) {
-    const { workspace, runtimeAdapterOptions, checkpointers, stores, defaultStore, embeddingModels, vectorStores, getDefaultRunRoot, } = input;
+    const { workspace, runtimeAdapterOptions, checkpointers, stores, defaultStore, embeddingModels, vectorStores, getDefaultRuntimeRoot, } = input;
     const storeResolver = runtimeAdapterOptions.storeResolver ??
         createBindingStoreResolver({
             stores,
             defaultStore,
-            getDefaultRunRoot,
+            getDefaultRuntimeRoot,
         });
     return {
         ...runtimeAdapterOptions,

package/dist/runtime/support/runtime-factories.d.ts

@@ -1,3 +1,3 @@
 import { type StoreLike } from "../harness/system/store.js";
-export declare function createStoreForConfig(storeConfig: Record<string, unknown>, runRoot: string): StoreLike;
-export declare function createCheckpointerForConfig(checkpointerConfig: Record<string, unknown> | boolean, runRoot: string): unknown;
+export declare function createStoreForConfig(storeConfig: Record<string, unknown>, runtimeRoot: string): StoreLike;
+export declare function createCheckpointerForConfig(checkpointerConfig: Record<string, unknown> | boolean, runtimeRoot: string): unknown;

package/dist/runtime/support/runtime-factories.js

@@ -4,16 +4,16 @@ import { FileCheckpointSaver } from "../maintenance/file-checkpoint-saver.js";
 import { SqliteCheckpointSaver } from "../maintenance/sqlite-checkpoint-saver.js";
 import { createInMemoryStore, FileBackedStore, SqliteBackedStore } from "../harness/system/store.js";
 import { resolveKnowledgeFileStorePath, resolveKnowledgeStorePath, resolveRuntimeCheckpointerPath, } from "./runtime-layout.js";
-export function createStoreForConfig(storeConfig, runRoot) {
+export function createStoreForConfig(storeConfig, runtimeRoot) {
     const kind = typeof storeConfig.kind === "string" ? storeConfig.kind : "FileStore";
     switch (kind) {
         case "FileStore": {
-            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : resolveKnowledgeFileStorePath(runRoot, "records.json");
-            return new FileBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : resolveKnowledgeFileStorePath(runtimeRoot, "records.json");
+            return new FileBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runtimeRoot, configuredPath));
         }
         case "SqliteStore": {
-            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : resolveKnowledgeStorePath(runRoot, "records.sqlite");
-            return new SqliteBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+            const configuredPath = typeof storeConfig.path === "string" ? storeConfig.path : resolveKnowledgeStorePath(runtimeRoot, "records.sqlite");
+            return new SqliteBackedStore(path.isAbsolute(configuredPath) ? configuredPath : path.join(runtimeRoot, configuredPath));
         }
         case "InMemoryStore":
             return createInMemoryStore();
@@ -25,7 +25,7 @@ export function createStoreForConfig(storeConfig, runRoot) {
             throw new Error(`Unsupported store kind ${String(kind)}`);
     }
 }
-export function createCheckpointerForConfig(checkpointerConfig, runRoot) {
+export function createCheckpointerForConfig(checkpointerConfig, runtimeRoot) {
     if (typeof checkpointerConfig === "boolean") {
         return checkpointerConfig;
     }
@@ -36,14 +36,14 @@ export function createCheckpointerForConfig(checkpointerConfig, runRoot) {
         case "SqliteSaver": {
             const configuredPath = typeof checkpointerConfig.path === "string"
                 ? String(checkpointerConfig.path)
-                : resolveRuntimeCheckpointerPath(runRoot, "checkpoints.sqlite");
-            return new SqliteCheckpointSaver(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+                : resolveRuntimeCheckpointerPath(runtimeRoot, "checkpoints.sqlite");
+            return new SqliteCheckpointSaver(path.isAbsolute(configuredPath) ? configuredPath : path.join(runtimeRoot, configuredPath));
         }
         case "FileCheckpointer": {
             const configuredPath = typeof checkpointerConfig.path === "string"
                 ? String(checkpointerConfig.path)
-                : resolveRuntimeCheckpointerPath(runRoot, "checkpoints.json");
-            return new FileCheckpointSaver(path.isAbsolute(configuredPath) ? configuredPath : path.join(runRoot, configuredPath));
+                : resolveRuntimeCheckpointerPath(runtimeRoot, "checkpoints.json");
+            return new FileCheckpointSaver(path.isAbsolute(configuredPath) ? configuredPath : path.join(runtimeRoot, configuredPath));
         }
         default:
             throw new Error(`Unsupported checkpointer kind ${String(kind)}`);

package/dist/workspace/agent-binding-compiler.js

@@ -361,8 +361,8 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
     const compiledFilesystemConfig = agent.executionMode === "langchain-v1"
         ? mergeConfigObjects(runtimeFilesystemDefaults, getAgentExecutionObject(agent, "filesystem", { executionMode: "langchain-v1" }))
         : undefined;
-    const runRoot = typeof agent.runRoot === "string" && agent.runRoot.trim().length > 0
-        ? (path.isAbsolute(agent.runRoot) ? agent.runRoot : path.resolve(runtimeStorage.dataRoot, agent.runRoot))
+    const runtimeRoot = typeof agent.runtimeRoot === "string" && agent.runtimeRoot.trim().length > 0
+        ? (path.isAbsolute(agent.runtimeRoot) ? agent.runtimeRoot : path.resolve(runtimeStorage.dataRoot, agent.runtimeRoot))
         : runtimeStorage.dataRoot;
     const base = {
         agent,
@@ -370,7 +370,7 @@ export function compileBinding(workspaceRoot, agent, agents, referencedSubagentI
             applicationRoot: runtimeStorage.applicationRoot,
             dataRoot: runtimeStorage.dataRoot,
             runtimeProfile: runtimeStorage.runtimeProfile,
-            runRoot,
+            runtimeRoot,
             workspaceRoot: runtimeStorage.applicationRoot,
             capabilities: inferAgentCapabilities(agent),
             resilience,

package/dist/workspace/object-loader.js

@@ -515,7 +515,7 @@ export function parseAgentItem(item, sourcePath) {
             : { delegation: true, memory: true }),
         description: String(normalizedItem.description ?? ""),
         modelRef: readExecutionValue(normalizedItem, "modelRef", readSingleRef) ?? "",
-        runRoot: typeof runtime?.runRoot === "string" ? runtime.runRoot : undefined,
+        runtimeRoot: typeof runtime?.runtimeRoot === "string" ? runtime.runtimeRoot : undefined,
         applicationRoot: typeof runtime?.applicationRoot === "string" ? runtime.applicationRoot : undefined,
         dataRoot: typeof runtime?.dataRoot === "string" ? runtime.dataRoot : undefined,
         runtimeProfile: typeof runtime?.profile === "string" ? runtime.profile : undefined,

package/dist/workspace/support/workspace-ref-utils.d.ts

@@ -9,12 +9,12 @@ export type RoutingRule = {
     maxLength?: number;
     minLines?: number;
     maxLines?: number;
-    hasThreadId?: boolean;
+    hasSessionId?: boolean;
     caseSensitive?: boolean;
 };
 export type RecoveryConfig = {
     enabled: boolean;
-    resumeResumingRunsOnStartup: boolean;
+    resumeResumingRequestsOnStartup: boolean;
     maxRecoveryAttempts: number;
 };
 export type ConcurrencyConfig = {
@@ -52,7 +52,8 @@ export declare function getResilienceConfig(refs: Map<string, WorkspaceObject |
 export declare function getRoutingDefaultAgentId(refs: Map<string, WorkspaceObject | ParsedAgentObject>): string | undefined;
 export declare function getRoutingRules(refs: Map<string, WorkspaceObject | ParsedAgentObject>): RoutingRule[];
 export declare function matchRoutingRule(input: string, rule: RoutingRule, options?: {
-    threadId?: string;
+    sessionId?: string;
+    legacySessionId?: string;
 }): boolean;
 export declare function resolvePromptValue(promptConfig: unknown): string | undefined;
 export declare function resolveRefId(ref: string): string;

package/dist/workspace/support/workspace-ref-utils.js

@@ -91,8 +91,8 @@ export function getRecoveryConfig(refs) {
         : 3;
     return {
         enabled: recovery.enabled !== false,
-        resumeResumingRunsOnStartup: typeof recovery.resumeResumingRunsOnStartup === "boolean"
-            ? recovery.resumeResumingRunsOnStartup
+        resumeResumingRequestsOnStartup: typeof recovery.resumeResumingRequestsOnStartup === "boolean"
+            ? recovery.resumeResumingRequestsOnStartup
             : true,
         maxRecoveryAttempts,
     };
@@ -223,7 +223,7 @@ export function getRoutingRules(refs) {
                 maxLength: toPositiveNumber(typed.maxLength),
                 minLines: toPositiveNumber(typed.minLines),
                 maxLines: toPositiveNumber(typed.maxLines),
-                hasThreadId: typeof typed.hasThreadId === "boolean" ? typed.hasThreadId : undefined,
+                hasSessionId: typeof typed.hasSessionId === "boolean" ? typed.hasSessionId : undefined,
                 caseSensitive: typed.caseSensitive === true,
             }];
     });
@@ -233,7 +233,8 @@ export function matchRoutingRule(input, rule, options = {}) {
     const source = rule.caseSensitive ? text : text.toLowerCase();
     const lineCount = text ? text.split(/\n+/).length : 0;
     const normalize = (value) => (rule.caseSensitive ? value : value.toLowerCase());
-    if (rule.hasThreadId !== undefined && rule.hasThreadId !== Boolean(options.threadId)) {
+    const sessionId = options.sessionId ?? options.legacySessionId;
+    if (rule.hasSessionId !== undefined && rule.hasSessionId !== Boolean(sessionId)) {
         return false;
     }
     if (rule.minLength !== undefined && text.length < rule.minLength) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.290",
+  "version": "0.0.291",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",

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

@@ -1,22 +0,0 @@
-import type { InValue } from "@libsql/client";
-import type { TranscriptMessage } from "../contracts/types.js";
-import type { PersistedRunRequest, RecoveryIntent } from "./types.js";
-type SqlRow = Record<string, unknown>;
-type SqliteRunContextStoreDb = {
-    execute(sql: string, args?: InValue[]): Promise<void>;
-    selectOne(sql: string, args?: InValue[]): Promise<SqlRow | null>;
-    selectAll(sql: string, args?: InValue[]): Promise<SqlRow[]>;
-};
-export declare class SqliteRunContextStore {
-    private readonly db;
-    constructor(db: SqliteRunContextStoreDb);
-    saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
-    getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;
-    clearRunRequest(threadId: string, runId: string): Promise<void>;
-    appendThreadMessage(threadId: string, message: TranscriptMessage): Promise<void>;
-    listThreadMessages(threadId: string, limit?: number): Promise<TranscriptMessage[]>;
-    saveRecoveryIntent(threadId: string, runId: string, intent: RecoveryIntent): Promise<void>;
-    getRecoveryIntent(threadId: string, runId: string): Promise<RecoveryIntent | null>;
-    clearRecoveryIntent(threadId: string, runId: string): Promise<void>;
-}
-export {};

package/dist/persistence/sqlite-run-context-store.js

@@ -1,64 +0,0 @@
-function asString(value) {
-    return typeof value === "string" ? value : String(value ?? "");
-}
-function parseJson(value) {
-    return JSON.parse(asString(value));
-}
-function nowIso() {
-    return new Date(Date.now()).toISOString();
-}
-export class SqliteRunContextStore {
-    db;
-    constructor(db) {
-        this.db = db;
-    }
-    async saveRunRequest(threadId, runId, request) {
-        await this.db.execute(`INSERT OR REPLACE INTO run_requests
-       (run_id, thread_id, request_json, saved_at)
-       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(request), request.savedAt]);
-    }
-    async getRunRequest(threadId, runId) {
-        const row = await this.db.selectOne("SELECT request_json FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-        return row ? parseJson(row.request_json) : null;
-    }
-    async clearRunRequest(threadId, runId) {
-        await this.db.execute("DELETE FROM run_requests WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-    }
-    async appendThreadMessage(threadId, message) {
-        await this.db.execute(`INSERT INTO thread_messages
-       (thread_id, role, content_json, run_id, created_at)
-       VALUES (?, ?, ?, ?, ?)`, [threadId, message.role, JSON.stringify(message.content), message.requestId ?? message.runId, message.createdAt]);
-    }
-    async listThreadMessages(threadId, limit = 12) {
-        const rows = await this.db.selectAll(`SELECT role, content_json, run_id, created_at
-       FROM (
-         SELECT role, content_json, run_id, created_at, id
-         FROM thread_messages
-         WHERE thread_id = ?
-         ORDER BY created_at DESC, id DESC
-         LIMIT ?
-       ) recent
-       ORDER BY created_at ASC, id ASC`, [threadId, limit]);
-        return rows.map((row) => ({
-            role: asString(row.role),
-            content: parseJson(row.content_json),
-            requestId: asString(row.run_id),
-            createdAt: asString(row.created_at),
-        }));
-    }
-    async saveRecoveryIntent(threadId, runId, intent) {
-        const savedAt = typeof intent.savedAt === "string"
-            ? (intent.savedAt)
-            : nowIso();
-        await this.db.execute(`INSERT OR REPLACE INTO recovery_intents
-       (run_id, thread_id, intent_json, saved_at)
-       VALUES (?, ?, ?, ?)`, [runId, threadId, JSON.stringify(intent), savedAt]);
-    }
-    async getRecoveryIntent(threadId, runId) {
-        const row = await this.db.selectOne("SELECT intent_json FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-        return row ? parseJson(row.intent_json) : null;
-    }
-    async clearRecoveryIntent(threadId, runId) {
-        await this.db.execute("DELETE FROM recovery_intents WHERE thread_id = ? AND run_id = ?", [threadId, runId]);
-    }
-}

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

@@ -1,41 +0,0 @@
-import type { InValue } from "@libsql/client";
-import type { PersistedRunControlRecord, PersistedRunQueueRecord } from "./types.js";
-type SqlRow = Record<string, unknown>;
-type SqliteRunQueueStoreDb = {
-    execute(sql: string, args?: InValue[]): Promise<void>;
-    selectOne(sql: string, args?: InValue[]): Promise<SqlRow | null>;
-    selectAll(sql: string, args?: InValue[]): Promise<SqlRow[]>;
-};
-export declare class SqliteRunQueueStore {
-    private readonly db;
-    constructor(db: SqliteRunQueueStoreDb);
-    private mapQueuedRun;
-    private mapRunControl;
-    enqueueRun(input: {
-        threadId: string;
-        runId: string;
-        priority?: number;
-        queueKey?: string | null;
-        availableAt?: string;
-    }): Promise<void>;
-    getQueuedRun(runId: string): Promise<PersistedRunQueueRecord | null>;
-    claimQueuedRun(input: {
-        threadId: string;
-        runId: string;
-        workerId: string;
-        claimedAt?: string;
-        leaseExpiresAt: string;
-    }): Promise<PersistedRunQueueRecord>;
-    renewRunLease(input: {
-        runId: string;
-        workerId: string;
-        heartbeatAt?: string;
-        leaseExpiresAt: string;
-    }): Promise<void>;
-    releaseRunClaim(runId: string): Promise<void>;
-    listExpiredClaimedRuns(cutoffIso: string): Promise<PersistedRunQueueRecord[]>;
-    getRunControl(runId: string): Promise<PersistedRunControlRecord | null>;
-    requestRunCancel(runId: string, reason?: string): Promise<PersistedRunControlRecord>;
-    clearRunCancel(runId: string): Promise<void>;
-}
-export {};