@botbotgo/agent-harness 0.0.75 → 0.0.76

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import type { ApprovalRecord, RunRecord, RunOptions, RunSummary, ResumeOptions, RuntimeAdapterOptions, ThreadSummary, ThreadRecord, WorkspaceLoadOptions } from "./contracts/types.js";
+import type { ApprovalRecord, RunRecord, RunOptions, RunSummary, ResumeOptions, RuntimeHealthSnapshot, RuntimeAdapterOptions, ThreadSummary, ThreadRecord, WorkspaceLoadOptions } from "./contracts/types.js";
 import { AgentHarnessRuntime } from "./runtime/harness.js";
 import type { InventoryAgentRecord, InventorySkillRecord } from "./runtime/inventory.js";
 import type { RequirementAssessmentOptions } from "./runtime/skill-requirements.js";
@@ -23,6 +23,7 @@ export declare function getRun(runtime: AgentHarnessRuntime, runId: string): Pro
 export declare function deleteThread(runtime: AgentHarnessRuntime, threadId: string): Promise<boolean>;
 export declare function listApprovals(runtime: AgentHarnessRuntime, filter?: Parameters<AgentHarnessRuntime["listApprovals"]>[0]): Promise<ApprovalRecord[]>;
 export declare function getApproval(runtime: AgentHarnessRuntime, approvalId: string): Promise<ApprovalRecord | null>;
+export declare function getHealth(runtime: AgentHarnessRuntime): Promise<RuntimeHealthSnapshot>;
 export declare function listAgentSkills(runtime: AgentHarnessRuntime, agentId: string, options?: RequirementAssessmentOptions): InventorySkillRecord[];
 export declare function describeInventory(runtime: AgentHarnessRuntime, options?: RequirementAssessmentOptions): {
     workspaceRoot: string;

package/dist/api.js

@@ -34,6 +34,9 @@ export async function listApprovals(runtime, filter) {
 export async function getApproval(runtime, approvalId) {
     return runtime.getApproval(approvalId);
 }
+export async function getHealth(runtime) {
+    return runtime.getHealth();
+}
 export function listAgentSkills(runtime, agentId, options) {
     return runtime.listAgentSkills(agentId, options);
 }

package/dist/benchmark/checkpoint-resume-cost-benchmark.d.ts

@@ -0,0 +1,33 @@
+export type CheckpointerMode = "memory" | "sqlite";
+export type ResumeCostRunSummary = {
+    model: string;
+    checkpointerKind: CheckpointerMode;
+    runNumber: number;
+    status: "completed" | "failed";
+    initialApprovalMs: number;
+    sameProcessResumeMs: number;
+    crossRestartResumeMs: number | null;
+    totalMeasuredMs: number;
+    approvalPassCount: number;
+    crossRestartSupported: boolean;
+    errorMessage?: string;
+};
+export type ResumeCostAggregateSummary = {
+    model: string;
+    checkpointerKind: CheckpointerMode;
+    repetitions: number;
+    successCount: number;
+    failureCount: number;
+    avgInitialApprovalMs: number | null;
+    avgSameProcessResumeMs: number | null;
+    avgCrossRestartResumeMs: number | null;
+    avgTotalMeasuredMs: number | null;
+    avgApprovalPassCount: number | null;
+    crossRestartSuccessCount: number;
+};
+export declare const DEFAULT_CHECKPOINT_RESUME_CHECKPOINTERS: readonly CheckpointerMode[];
+export declare const DEFAULT_RESUME_COST_INFRA_RETRIES = 2;
+export declare function resolveCheckpointResumeCheckpointers(rawValue?: string): readonly CheckpointerMode[];
+export declare function resolveResumeCostInfraRetries(rawValue?: string): number;
+export declare function isRetryableResumeCostError(message?: string): boolean;
+export declare function aggregateCheckpointResumeRuns(model: string, checkpointerKind: CheckpointerMode, runs: ResumeCostRunSummary[]): ResumeCostAggregateSummary;

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

@@ -0,0 +1,55 @@
+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,
+    };
+}

package/dist/benchmark/deepagent-local-model-benchmark.d.ts

@@ -0,0 +1,27 @@
+export declare const DEFAULT_SERIAL_BENCHMARK_MODELS: readonly string[];
+export type WarmupRequestPayload = {
+    model: string;
+    temperature: number;
+    max_tokens: number;
+    messages: Array<{
+        role: "user";
+        content: string;
+    }>;
+};
+export type WarmupResponsePayload = {
+    choices?: Array<{
+        message?: {
+            content?: string;
+            reasoning?: string;
+        };
+    }>;
+    usage?: {
+        completion_tokens?: number;
+    };
+};
+export declare function resolveSerialBenchmarkModels(rawValue?: string): readonly string[];
+export declare function buildWarmupRequestPayload(model: string, token: string): WarmupRequestPayload;
+export declare function extractWarmupOutput(payload: WarmupResponsePayload): {
+    output: string;
+    completionTokens: number;
+};

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

@@ -0,0 +1,35 @@
+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,
+    };
+}

package/dist/config/agents/direct.yaml

@@ -39,7 +39,7 @@ spec:
       # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
       # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
       checkpointer:
-        ref: checkpointer/default
+        ref: checkpointer/sqlite
       # Upstream execution feature: LangGraph store available to middleware and runtime context hooks.
       # The default direct host keeps this enabled so middleware can use the same durable store surface as other hosts.
       store:

package/dist/config/agents/orchestra.yaml

@@ -46,8 +46,7 @@ spec:
       # Available `kind` options in this harness: `FileCheckpointer`, `MemorySaver`, `SqliteSaver`.
       # `path` is only used by `FileCheckpointer` and `SqliteSaver`; omit it for `MemorySaver`.
       checkpointer:
-        # ref: checkpointer/sqlite
-        ref: checkpointer/default
+        ref: checkpointer/sqlite
       # Upstream execution feature: store config passed into the selected backend adapter.
       # In the default deepagent adapter this is the LangGraph store used by `StoreBackend` routes.
       # Built-in kinds in this harness today: `FileStore`, `InMemoryStore`.

package/dist/config/workspace.yaml

@@ -92,6 +92,7 @@ spec:
   #
   # Current support:
   # - checkpoint cleanup for `SqliteSaver` checkpointers only
+  # - terminal runtime-record cleanup for structured thread/run metadata in `runtime.sqlite`
   # - oldest-first deletion by time policy and/or size policy
   # - background scheduling inside the harness lifecycle
   #
@@ -106,6 +107,16 @@ spec:
       sqlite:
         sweepBatchSize: 200
         vacuum: false
+    records:
+      enabled: false
+      schedule:
+        intervalSeconds: 3600
+        runOnStartup: true
+      policies:
+        maxAgeSeconds: 2592000
+      sqlite:
+        sweepBatchSize: 100
+        vacuum: false
 
   # agent-harness feature: runtime-managed recovery policy for interrupted runs.
   # This keeps checkpoint resume as an internal lifecycle concern instead of a primary user-facing API concept.
@@ -119,3 +130,23 @@ spec:
     enabled: true
     resumeResumingRunsOnStartup: true
     maxRecoveryAttempts: 3
+
+  # agent-harness feature: runtime-managed resilience policy for transient provider failures.
+  # This applies to provider/model invocation boundaries, not to benchmark-only loops.
+  #
+  # Current support:
+  # - bounded retries for transient provider invocation failures
+  # - simple fixed backoff between attempts
+  # - message-pattern classification for retryable infrastructure errors
+  #
+  resilience:
+    providerRetries:
+      maxAttempts: 2
+      backoffMs: 1000
+      retryableMessages:
+        - connection error
+        - network error
+        - fetch failed
+        - socket hang up
+        - econnreset
+        - timed out

package/dist/contracts/types.d.ts

@@ -202,6 +202,7 @@ export type CompiledAgentBinding = {
         workspaceRoot?: string;
         hostFacing: boolean;
         capabilities?: RuntimeCapabilities;
+        resilience?: Record<string, unknown>;
         checkpointer?: Record<string, unknown> | boolean;
         store?: Record<string, unknown>;
         runtimeMemory?: Record<string, unknown>;
@@ -238,7 +239,7 @@ export type ThreadSummary = {
     status: RunState;
 };
 export type SessionRecord = ThreadSummary;
-export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.synthetic_fallback";
+export type KnownHarnessEventType = "run.created" | "run.queued" | "run.dequeued" | "run.state.changed" | "run.resumed" | "approval.requested" | "approval.resolved" | "artifact.created" | "output.delta" | "reasoning.delta" | "runtime.health.changed" | "runtime.synthetic_fallback";
 export type HarnessEventType = KnownHarnessEventType | (string & {});
 export type HarnessEvent = {
     eventId: string;
@@ -261,6 +262,42 @@ export type RuntimeEventSink = {
     subscribe: (listener: HarnessEventListener) => () => void;
     registerProjection: (projection: HarnessEventProjection) => () => void;
 };
+export type HealthStatus = "healthy" | "degraded" | "unhealthy";
+export type RuntimeHealthCheck = {
+    status: HealthStatus;
+    updatedAt: string;
+    reason?: string;
+};
+export type RuntimeHealthSymptom = {
+    code: string;
+    severity: "info" | "warn" | "error";
+    message: string;
+    firstSeenAt: string;
+    lastSeenAt: string;
+};
+export type RuntimeHealthSnapshot = {
+    status: HealthStatus;
+    updatedAt: string;
+    checks: {
+        runtime: RuntimeHealthCheck;
+        llm: RuntimeHealthCheck;
+        persistence: RuntimeHealthCheck;
+        capacity: RuntimeHealthCheck;
+        workload: RuntimeHealthCheck;
+    };
+    symptoms: RuntimeHealthSymptom[];
+    stats: {
+        activeRunSlots: number;
+        pendingRunSlots: number;
+        pendingApprovals: number;
+        stuckRuns: number;
+        checkpointBytes?: number;
+        runtimeDbBytes?: number;
+        artifactBytes?: number;
+        llmSuccessRate1m?: number;
+        llmP95LatencyMs1m?: number;
+    };
+};
 export type RunResult = {
     threadId: string;
     runId: string;

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export type { ToolMcpServerOptions } from "./mcp.js";
 export { tool } from "./tools.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
+export { AgentHarnessRuntime, createAgentHarness, createToolMcpServer, deleteThread, describeInventory, getApproval, getHealth, getRun, getThread, listAgentSkills, listApprovals, listRuns, listThreads, resolveApproval, run, serveToolsOverStdio, subscribe, stop, } from "./api.js";
 export { tool } from "./tools.js";

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.74";
+export declare const AGENT_HARNESS_VERSION = "0.0.75";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.74";
+export const AGENT_HARNESS_VERSION = "0.0.75";

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

@@ -1,30 +1,5 @@
-import type { ArtifactListing, ArtifactRecord, DelegationRecord, HarnessEvent, InternalApprovalRecord, InvocationEnvelope, MessageContent, RunSummary, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
-type ThreadMeta = {
-    threadId: string;
-    workspaceId: string;
-    entryAgentId: string;
-    createdAt: string;
-    updatedAt: string;
-    status: RunState;
-    latestRunId: string;
-};
-type RunMeta = {
-    runId: string;
-    threadId: string;
-    agentId: string;
-    executionMode: string;
-    adapterKind?: string;
-    createdAt: string;
-    updatedAt: string;
-};
-type Lifecycle = {
-    state: RunState;
-    previousState: RunState | null;
-    stateEnteredAt: string;
-    lastTransitionAt: string;
-    resumable: boolean;
-    checkpointRef: string | null;
-};
+import type { ArtifactListing, ArtifactRecord, DelegationRecord, HarnessEvent, InternalApprovalRecord, RunSummary, RunState, ThreadSummary, ThreadRunRecord, TranscriptMessage } from "../contracts/types.js";
+import type { PersistedRunRequest, PersistenceLifecycle as Lifecycle, RuntimePersistence, RecoveryIntent, PersistenceRunMeta as RunMeta, PersistenceThreadMeta as ThreadMeta } from "./types.js";
 type RunIndexRecord = {
     runId: string;
     threadId: string;
@@ -32,19 +7,7 @@ type RunIndexRecord = {
     resumable: boolean;
     updatedAt: string;
 };
-type RecoveryIntent = {
-    kind: "approval-decision";
-    savedAt: string;
-    checkpointRef: string | null;
-    resumePayload: unknown;
-    attempts: number;
-};
-type PersistedRunRequest = {
-    input: MessageContent;
-    invocation?: InvocationEnvelope;
-    savedAt: string;
-};
-export declare class FilePersistence {
+export declare class FilePersistence implements RuntimePersistence {
     private readonly runRoot;
     constructor(runRoot: string);
     private threadIndexPath;

package/dist/persistence/file-store.js

@@ -2,6 +2,9 @@ import path from "node:path";
 import { rm } from "node:fs/promises";
 import { readdir } from "node:fs/promises";
 import { ensureDir, fileExists, readJson, writeJson } from "../utils/fs.js";
+function nowIso() {
+    return new Date(Date.now()).toISOString();
+}
 export class FilePersistence {
     runRoot;
     constructor(runRoot) {
@@ -113,7 +116,7 @@ export class FilePersistence {
             readJson(lifecyclePath),
             readJson(runMetaPath),
         ]);
-        const now = new Date().toISOString();
+        const now = nowIso();
         const next = {
             state,
             previousState: lifecycle.state,
@@ -355,7 +358,7 @@ export class FilePersistence {
         const updated = {
             ...current,
             status,
-            resolvedAt: new Date().toISOString(),
+            resolvedAt: nowIso(),
         };
         await Promise.all([
             writeJson(approvalPath, updated),

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

@@ -0,0 +1,68 @@
+import type { ArtifactListing, ArtifactRecord, HarnessEvent, InternalApprovalRecord, RunState, RunSummary, ThreadRunRecord, ThreadSummary, TranscriptMessage } from "../contracts/types.js";
+import type { PersistedRunRequest, PersistenceLifecycle, PersistenceRunMeta, PersistenceThreadMeta, RecoveryIntent, RuntimePersistence } from "./types.js";
+export declare function listProtectedCheckpointThreadIds(dbPath: string): Promise<Set<string>>;
+export declare class SqlitePersistence implements RuntimePersistence {
+    private readonly runRoot;
+    private readonly dbPath;
+    private client;
+    private initialized;
+    private initialization;
+    constructor(runRoot: string, dbFile?: string);
+    private getClient;
+    private rawExecute;
+    private rawSelectAll;
+    private ensureInitialized;
+    private threadDir;
+    private runDir;
+    private execute;
+    private selectOne;
+    private selectAll;
+    private mapThreadSummary;
+    private mapRunSummary;
+    private mapApproval;
+    initialize(): Promise<void>;
+    private ensureSchemaMetadata;
+    createThread(input: {
+        threadId: string;
+        agentId: string;
+        runId: string;
+        status: RunState;
+        createdAt: string;
+    }): Promise<void>;
+    createRun(input: {
+        threadId: string;
+        runId: string;
+        agentId: string;
+        executionMode: string;
+        adapterKind?: string;
+        createdAt: string;
+    }): Promise<void>;
+    setRunState(threadId: string, runId: string, state: RunState, checkpointRef?: string | null): Promise<void>;
+    appendEvent(event: HarnessEvent): Promise<void>;
+    listSessions(): Promise<ThreadSummary[]>;
+    listRuns(): Promise<RunSummary[]>;
+    getRun(runId: string): Promise<RunSummary | null>;
+    getSession(threadId: string): Promise<ThreadSummary | null>;
+    getThreadMeta(threadId: string): Promise<PersistenceThreadMeta | null>;
+    listThreadRuns(threadId: string): Promise<ThreadRunRecord[]>;
+    listRunEvents(threadId: string, runId: string): Promise<HarnessEvent[]>;
+    listApprovals(): Promise<InternalApprovalRecord[]>;
+    getApproval(approvalId: string): Promise<InternalApprovalRecord | null>;
+    getRunApprovals(threadId: string, runId: string): Promise<InternalApprovalRecord[]>;
+    getRunMeta(threadId: string, runId: string): Promise<PersistenceRunMeta>;
+    getRunLifecycle(threadId: string, runId: string): Promise<PersistenceLifecycle>;
+    deleteThread(threadId: string): Promise<boolean>;
+    saveRunRequest(threadId: string, runId: string, request: PersistedRunRequest): Promise<void>;
+    getRunRequest(threadId: string, runId: string): Promise<PersistedRunRequest | null>;
+    clearRunRequest(threadId: string, runId: string): Promise<void>;
+    createApproval(record: InternalApprovalRecord): Promise<void>;
+    resolveApproval(threadId: string, runId: string, approvalId: string, status: InternalApprovalRecord["status"]): Promise<InternalApprovalRecord>;
+    createArtifact(threadId: string, runId: string, artifact: ArtifactRecord, content: unknown): Promise<ArtifactRecord>;
+    listArtifacts(threadId: string, runId: string): Promise<ArtifactListing>;
+    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>;
+    readArtifact(threadId: string, runId: string, artifactPath: string): Promise<unknown>;
+}