@pikku/kysely 0.13.13 → 0.13.16

package/CHANGELOG.md

@@ -1,3 +1,131 @@
+## 0.13.16
+
+### Patch Changes
+
+- 7406bfe: Rename the agent runtime from `AI*` to `Agent*` (#596)
+
+  `AI` described the model provider, not the thing being named. Every symbol that
+  belongs to the agent runtime now says `Agent`; the symbols that genuinely wrap a
+  model provider — `AIEmbeddingService`, `AIProviderOptions`, `AIEmbedParams`,
+  `AITranscriptionParams`, `AIGenerateImageParams` and their siblings, and the
+  `@pikku/ai-vercel` / `@pikku/ai-deepinfra` / `@pikku/ai-voice` packages — keep
+  their names.
+
+  **Wiring**
+  - `pikkuAIAgent` → `pikkuAgent`, `pikkuAIScorer` → `pikkuAgentScorer`,
+    `pikkuAIJudge` → `pikkuAgentJudge`
+  - `CoreAIAgent` → `CoreAgent`, `AIAgentInput` → `AgentInput`, `AIAgentStep` →
+    `AgentStep`, `AIMessage` → `AgentMessage`, and the rest of the agent types
+  - `AIAgentRunnerService` → `AgentRunnerService`, `AIStorageService` →
+    `AgentStorageService`, `AIRunStateService` → `AgentRunStateService`
+
+  **Entry points**
+
+  `@pikku/core/agent` → `@pikku/core/agent`, `@pikku/core/agent-scorer` →
+  `@pikku/core/agent-scorer`.
+
+  **Queues**
+
+  The scorer queues are now `agent-score-fast` and `agent-score-slow`. Drain the
+  old `ai-score-fast` / `ai-score-slow` queues before deploying — jobs still
+  sitting on them when the new workers start will never be picked up.
+
+  **Scaffolds**
+
+  The agent scaffold pikku wrote for your project — `<scaffold>/agent/agent.gen.ts`
+  and its schemas file — imports `@pikku/core/ai-agent`, which no longer exists. A
+  scaffold is normally written once and then left alone, so `pikku all` would find
+  it present and leave the broken import in place. It now deletes an agent scaffold
+  importing either removed entry point and regenerates it in the same run. Anything
+  you added to that file goes with it, so move local edits out first.
+
+  **Database**
+
+  The agent tables are renamed: `ai_threads`, `ai_message`, `ai_tool_call`,
+  `ai_working_memory`, `ai_run` and `ai_run_score` become `agent_threads`,
+  `agent_message`, `agent_tool_call`, `agent_working_memory`, `agent_run` and
+  `agent_run_score`, along with their indexes and the `ai_working_memory_pk`
+  constraint. The same rename applies to the MongoDB collections.
+
+  `ensurePikkuSchema` creates tables it cannot find, so an existing database will
+  get empty `agent_*` tables and leave the old data stranded in `ai_*`. Rename
+  them before the first boot on the new version:
+
+  ```sql
+  ALTER TABLE ai_threads        RENAME TO agent_threads;
+  ALTER TABLE ai_message        RENAME TO agent_message;
+  ALTER TABLE ai_tool_call      RENAME TO agent_tool_call;
+  ALTER TABLE ai_working_memory RENAME TO agent_working_memory;
+  ALTER TABLE ai_run            RENAME TO agent_run;
+  ALTER TABLE ai_run_score      RENAME TO agent_run_score;
+  ```
+
+- 6794681: Publish the ecosystem surface as per-area sub-barrels under `@pikku/core/ecosystem/*`, and point generated code, the CLI, the inspector and the runtime adapters at them.
+
+  348 names that only generated code, the toolchain or a runtime adapter ever imports now have a second home on `@pikku/core/ecosystem/<area>` — one sub-barrel per area, matching how core already publishes its entrypoints, so no single barrel grows without bound and a consumer only pulls in the area it uses.
+
+  This step is additive: every name is still exported from the entrypoint it was published from before, so nothing downstream breaks. Removing them from the app-facing barrels is a later change, and needs a release carrying `./ecosystem/*` first.
+
+- a7fcd2e: Declare dependencies that were imported but missing from `package.json`
+
+  `@pikku/openapi-parser` and `@pikku/better-auth` imported `zod`, `@pikku/next`
+  imported `path-to-regexp`, `@pikku/cli` imported `kysely`, and
+  `@pikku/assistant-ui` imported `rxjs`, none of which were declared. Each
+  resolved through Yarn hoisting inside the monorepo and would fail for anyone
+  installing the package on its own.
+
+  `rxjs`, `kysely` and `path-to-regexp` reach consumers through public
+  signatures — `Observable<BaseEvent>` is the return type of a published method,
+  and `createCoercionPlugin` returns a `KyselyPlugin` — so they are runtime
+  dependencies rather than build-only ones.
+
+  `@pikku/assistant-ui` pins `rxjs` to the exact `7.8.1` that `@ag-ui/client`
+  pins, rather than a caret range. The two packages exchange `Observable`s, so a
+  range that floats to a second copy gives them two incompatible `Observable`
+  types.
+
+  `@pikku/kysely` also drops `SqliteSerializePlugin`, an alias of
+  `SerializePlugin` that has been marked `@deprecated` in favour of it. Use
+  `SerializePlugin`.
+
+- Updated dependencies [7406bfe]
+- Updated dependencies [6794681]
+  - @pikku/core@0.12.84
+
+## 0.13.15
+
+### Patch Changes
+
+- fd9d834: Stop publishing internals that only their own package or file used. The declarations stay; only the entrypoint re-export is removed, so nothing that imported a name from where it is declared is affected.
+- Updated dependencies [063f43a]
+- Updated dependencies [ce66bf8]
+- Updated dependencies [d0307a8]
+- Updated dependencies [ce66bf8]
+- Updated dependencies [3ad2131]
+- Updated dependencies [b930dca]
+- Updated dependencies [b95e77d]
+- Updated dependencies [fd9d834]
+- Updated dependencies [8978fbd]
+  - @pikku/core@0.12.82
+
+## 0.13.14
+
+### Patch Changes
+
+- e110c55: Add runtime scoring for AI agents: `pikkuAIScorer` for heuristic grades and
+  `pikkuAIJudge` for LLM-judged ones, graded off the request path on two queue
+  lanes so a slow judge cannot starve the cheap checks. Grades are sampled
+  deterministically per `(run, scorer)` and persisted to `ai_run_score`.
+- Updated dependencies [e110c55]
+- Updated dependencies [e110c55]
+- Updated dependencies [e110c55]
+- Updated dependencies [acc8077]
+- Updated dependencies [905f737]
+- Updated dependencies [3cc6428]
+- Updated dependencies [c524adf]
+- Updated dependencies [e110c55]
+  - @pikku/core@0.12.81
+
 ## 0.13.13
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -4,23 +4,20 @@ export { KyselyWorkflowService } from './kysely-workflow-service.js';
 export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 export { KyselyWorkflowMirror } from './kysely-workflow-mirror.js';
 export { KyselyDeploymentService } from './kysely-deployment-service.js';
-export { KyselyAIStorageService } from './kysely-ai-storage-service.js';
-export { KyselyAgentRunService } from './kysely-ai-agent-run-service.js';
-export { KyselyAIRunStateService } from './kysely-ai-run-state-service.js';
+export { KyselyAgentStorageService } from './kysely-agent-storage-service.js';
+export { KyselyAgentRunService } from './kysely-agent-run-service.js';
+export { KyselyAgentRunStateService } from './kysely-agent-run-state-service.js';
 export { KyselySecretService } from './kysely-secret-service.js';
-export type { KyselySecretServiceConfig } from './kysely-secret-service.js';
 export { KyselyCredentialService } from './kysely-credential-service.js';
-export type { KyselyCredentialServiceConfig } from './kysely-credential-service.js';
 export { KyselySessionStore } from './kysely-session-store.js';
 export { KyselyScopeService } from './kysely-scope-service.js';
 export { KyselyWebhookService } from './kysely-webhook-service.js';
 export { createAuditedKysely, type CreateAuditedKyselyOptions, } from './create-audited-kysely.js';
 export { KyselyAuditService } from './kysely-audit-service.js';
 export { KyselyVirtualUserRunStore } from './kysely-virtual-user-run-store.js';
-export { SerializePlugin, SqliteSerializePlugin, BaseSerializePlugin, defaultSerializer, defaultDeserializer, maybeJson, skipTransform, dateRegex, type Serializer, type Deserializer, type SerializePluginOptions, } from './serialize-plugin.js';
-export { virtualUserSchema } from './schema/virtual-user.schema.js';
-export { auditSchema, pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, type EnsureOutcome, resolveRequirements, unsatisfiedRequirements, rawStatement, requiredType, type PikkuSchema, type RequiredTypes, type SchemaRequirement, type UnmetRequirement, type SchemaStatement, type SchemaStatementFactory, } from './schema/index.js';
+export { SerializePlugin, BaseSerializePlugin, type Serializer, type Deserializer, } from './serialize-plugin.js';
+export { auditSchema, pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, type EnsureOutcome, resolveRequirements, type PikkuSchema, type RequiredTypes, type UnmetRequirement, type SchemaStatementFactory, } from './schema/index.js';
 export type { KyselyPikkuDB } from './kysely-tables.js';
-export type { WorkflowRunService } from '@pikku/core/workflow';
-export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent';
-export type { VirtualUserRunStore, VirtualUserRunRecord, } from '@pikku/core/virtual-user';
+export type { WorkflowRunService } from '@pikku/core/ecosystem/workflow';
+export type { AgentRunService, AgentRunRow, } from '@pikku/core/ecosystem/agent';
+export type { VirtualUserRunStore, VirtualUserRunRecord, } from '@pikku/core/ecosystem/virtual-user';

package/dist/src/index.js

@@ -4,9 +4,9 @@ export { KyselyWorkflowService } from './kysely-workflow-service.js';
 export { KyselyWorkflowRunService } from './kysely-workflow-run-service.js';
 export { KyselyWorkflowMirror } from './kysely-workflow-mirror.js';
 export { KyselyDeploymentService } from './kysely-deployment-service.js';
-export { KyselyAIStorageService } from './kysely-ai-storage-service.js';
-export { KyselyAgentRunService } from './kysely-ai-agent-run-service.js';
-export { KyselyAIRunStateService } from './kysely-ai-run-state-service.js';
+export { KyselyAgentStorageService } from './kysely-agent-storage-service.js';
+export { KyselyAgentRunService } from './kysely-agent-run-service.js';
+export { KyselyAgentRunStateService } from './kysely-agent-run-state-service.js';
 export { KyselySecretService } from './kysely-secret-service.js';
 export { KyselyCredentialService } from './kysely-credential-service.js';
 export { KyselySessionStore } from './kysely-session-store.js';
@@ -15,6 +15,5 @@ export { KyselyWebhookService } from './kysely-webhook-service.js';
 export { createAuditedKysely, } from './create-audited-kysely.js';
 export { KyselyAuditService } from './kysely-audit-service.js';
 export { KyselyVirtualUserRunStore } from './kysely-virtual-user-run-store.js';
-export { SerializePlugin, SqliteSerializePlugin, BaseSerializePlugin, defaultSerializer, defaultDeserializer, maybeJson, skipTransform, dateRegex, } from './serialize-plugin.js';
-export { virtualUserSchema } from './schema/virtual-user.schema.js';
-export { auditSchema, pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, resolveRequirements, unsatisfiedRequirements, rawStatement, requiredType, } from './schema/index.js';
+export { SerializePlugin, BaseSerializePlugin, } from './serialize-plugin.js';
+export { auditSchema, pikkuSchemas, applyPikkuSchemas, compilePikkuSchemas, ensurePikkuSchema, resolveRequirements, } from './schema/index.js';

package/dist/src/kysely-agent-run-scores.d.ts

@@ -0,0 +1,10 @@
+import type { Kysely } from 'kysely';
+import type { KyselyPikkuDB } from './kysely-tables.js';
+import type { SaveScoreInput } from '@pikku/core/services';
+import type { AgentRunScore } from '@pikku/core/agent-scorer';
+/**
+ * Shared by the two Kysely services that implement `AgentRunStateService` — they
+ * differ in how they store approvals, not in how they store grades.
+ */
+export declare const saveRunScore: (db: Kysely<KyselyPikkuDB>, score: SaveScoreInput) => Promise<void>;
+export declare const getRunScores: (db: Kysely<KyselyPikkuDB>, runId: string) => Promise<AgentRunScore[]>;

package/dist/src/kysely-agent-run-scores.js

@@ -0,0 +1,34 @@
+import { parseJson } from './kysely-json.js';
+/**
+ * Shared by the two Kysely services that implement `AgentRunStateService` — they
+ * differ in how they store approvals, not in how they store grades.
+ */
+export const saveRunScore = async (db, score) => {
+    await db
+        .insertInto('agentRunScore')
+        .values({
+        id: crypto.randomUUID(),
+        runId: score.runId,
+        scorerName: score.scorerName,
+        score: score.score,
+        reason: score.reason ?? null,
+        metadata: score.metadata ? JSON.stringify(score.metadata) : null,
+    })
+        .execute();
+};
+export const getRunScores = async (db, runId) => {
+    const rows = await db
+        .selectFrom('agentRunScore')
+        .selectAll()
+        .where('runId', '=', runId)
+        .orderBy('createdAt', 'asc')
+        .execute();
+    return rows.map((row) => ({
+        runId: row.runId,
+        scorerName: row.scorerName,
+        score: Number(row.score),
+        reason: row.reason ?? undefined,
+        metadata: parseJson(row.metadata),
+        createdAt: new Date(row.createdAt),
+    }));
+};

package/dist/src/kysely-agent-run-service.d.ts

@@ -0,0 +1,22 @@
+import type { AgentThread, AgentMessage } from '@pikku/core/agent';
+import type { AgentRunRow, AgentRunService } from '@pikku/core/ecosystem/agent';
+import type { Kysely } from 'kysely';
+import type { KyselyPikkuDB } from './kysely-tables.js';
+export declare class KyselyAgentRunService implements AgentRunService {
+    private db;
+    constructor(db: Kysely<KyselyPikkuDB>);
+    listThreads(options?: {
+        agentName?: string;
+        resourceId?: string;
+        owners?: string[];
+        limit?: number;
+        offset?: number;
+    }): Promise<AgentThread[]>;
+    getThread(threadId: string): Promise<AgentThread | null>;
+    getThreadMessages(threadId: string): Promise<AgentMessage[]>;
+    getThreadRuns(threadId: string): Promise<AgentRunRow[]>;
+    deleteThread(threadId: string): Promise<boolean>;
+    getDistinctAgentNames(): Promise<string[]>;
+    private mapThreadRow;
+    private mapRunRow;
+}

package/dist/src/kysely-agent-run-service.js

@@ -0,0 +1,190 @@
+import { sql } from 'kysely';
+import { parseJson } from './kysely-json.js';
+// Owner ids routinely contain `_` (e.g. `user_123`), which LIKE treats as a
+// single-character wildcard — so a raw prefix would match a foreign owner.
+const escapeLikePattern = (value) => value.replace(/[\\%_]/g, (char) => `\\${char}`);
+export class KyselyAgentRunService {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listThreads(options) {
+        const { agentName, resourceId, owners, limit = 50, offset = 0, } = options ?? {};
+        // An owners constraint is an authorization boundary, so an empty list must
+        // match nothing rather than degrade to "no filter".
+        if (owners && owners.length === 0)
+            return [];
+        let query = this.db
+            .selectFrom('agentThreads as t')
+            .select([
+            't.id',
+            't.resourceId',
+            't.title',
+            't.metadata',
+            't.createdAt',
+            't.updatedAt',
+        ]);
+        if (agentName) {
+            query = query.where('t.id', 'in', this.db
+                .selectFrom('agentRun')
+                .select('threadId')
+                .where('agentName', '=', agentName)
+                .distinct());
+        }
+        if (resourceId) {
+            query = query.where('t.resourceId', '=', resourceId);
+        }
+        if (owners) {
+            query = query.where((eb) => eb.or(owners.flatMap((owner) => [
+                eb('t.resourceId', '=', owner),
+                eb('t.resourceId', 'like', sql `${`${escapeLikePattern(owner)}:%`} escape '\\'`),
+            ])));
+        }
+        const result = await query
+            .orderBy('t.updatedAt', 'desc')
+            .limit(limit)
+            .offset(offset)
+            .execute();
+        return result.map((row) => this.mapThreadRow(row));
+    }
+    async getThread(threadId) {
+        const row = await this.db
+            .selectFrom('agentThreads')
+            .select([
+            'id',
+            'resourceId',
+            'title',
+            'metadata',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('id', '=', threadId)
+            .executeTakeFirst();
+        if (!row)
+            return null;
+        return this.mapThreadRow(row);
+    }
+    async getThreadMessages(threadId) {
+        const [msgResult, tcResult] = await Promise.all([
+            this.db
+                .selectFrom('agentMessage')
+                .select(['id', 'role', 'content', 'createdAt'])
+                .where('threadId', '=', threadId)
+                .orderBy('createdAt', 'asc')
+                .execute(),
+            this.db
+                .selectFrom('agentToolCall')
+                .select(['id', 'messageId', 'toolName', 'args', 'result'])
+                .where('threadId', '=', threadId)
+                .orderBy('createdAt', 'asc')
+                .execute(),
+        ]);
+        const tcByMessage = new Map();
+        for (const tc of tcResult) {
+            const msgId = tc.messageId;
+            if (!tcByMessage.has(msgId))
+                tcByMessage.set(msgId, []);
+            tcByMessage.get(msgId).push(tc);
+        }
+        const messages = [];
+        for (const row of msgResult) {
+            const msg = {
+                id: row.id,
+                role: row.role,
+                content: row.content ?? undefined,
+                createdAt: new Date(row.createdAt),
+            };
+            const tcs = tcByMessage.get(msg.id);
+            if (tcs?.length) {
+                msg.toolCalls = tcs.map((tc) => ({
+                    id: tc.id,
+                    name: tc.toolName,
+                    args: parseJson(tc.args),
+                }));
+                const completed = tcs.filter((tc) => tc.result != null);
+                if (completed.length) {
+                    messages.push(msg);
+                    messages.push({
+                        id: `tool-results-${msg.id}`,
+                        role: 'tool',
+                        toolResults: completed.map((tc) => ({
+                            id: tc.id,
+                            name: tc.toolName,
+                            result: tc.result,
+                        })),
+                        createdAt: msg.createdAt,
+                    });
+                    continue;
+                }
+            }
+            messages.push(msg);
+        }
+        return messages;
+    }
+    async getThreadRuns(threadId) {
+        const result = await this.db
+            .selectFrom('agentRun')
+            .select([
+            'runId',
+            'agentName',
+            'threadId',
+            'resourceId',
+            'status',
+            'errorMessage',
+            'suspendReason',
+            'missingRpcs',
+            'usageInputTokens',
+            'usageOutputTokens',
+            'usageModel',
+            'createdAt',
+            'updatedAt',
+        ])
+            .where('threadId', '=', threadId)
+            .orderBy('createdAt', 'desc')
+            .execute();
+        return result.map((row) => this.mapRunRow(row));
+    }
+    async deleteThread(threadId) {
+        const result = await this.db
+            .deleteFrom('agentThreads')
+            .where('id', '=', threadId)
+            .executeTakeFirst();
+        return BigInt(result.numDeletedRows) > 0n;
+    }
+    async getDistinctAgentNames() {
+        const result = await this.db
+            .selectFrom('agentRun')
+            .select('agentName')
+            .distinct()
+            .orderBy('agentName')
+            .execute();
+        return result.map((row) => row.agentName);
+    }
+    mapThreadRow(row) {
+        return {
+            id: row.id,
+            resourceId: row.resourceId,
+            title: row.title ?? undefined,
+            metadata: parseJson(row.metadata),
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+    mapRunRow(row) {
+        return {
+            runId: row.runId,
+            agentName: row.agentName,
+            threadId: row.threadId,
+            resourceId: row.resourceId,
+            status: row.status,
+            errorMessage: row.errorMessage ?? undefined,
+            suspendReason: row.suspendReason ?? undefined,
+            missingRpcs: parseJson(row.missingRpcs),
+            usageInputTokens: Number(row.usageInputTokens),
+            usageOutputTokens: Number(row.usageOutputTokens),
+            usageModel: row.usageModel,
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+}

package/dist/src/kysely-agent-run-state-service.d.ts

@@ -0,0 +1,24 @@
+import type { Kysely } from 'kysely';
+import type { KyselyPikkuDB } from './kysely-tables.js';
+import type { AgentRunStateService, CreateRunInput, SaveScoreInput } from '@pikku/core/services';
+import type { AgentRunState } from '@pikku/core/agent';
+import type { PendingApproval } from '@pikku/core/ecosystem/agent';
+import type { AgentRunScore } from '@pikku/core/agent-scorer';
+export declare class KyselyAgentRunStateService implements AgentRunStateService {
+    private db;
+    private initialized;
+    constructor(db: Kysely<KyselyPikkuDB>);
+    init(): Promise<void>;
+    createRun(run: CreateRunInput): Promise<string>;
+    updateRun(runId: string, updates: Partial<AgentRunState>): Promise<void>;
+    getRun(runId: string): Promise<AgentRunState | null>;
+    getRunsByThread(threadId: string): Promise<AgentRunState[]>;
+    resolveApproval(toolCallId: string, status: 'approved' | 'denied'): Promise<boolean>;
+    findRunByToolCallId(toolCallId: string): Promise<{
+        run: AgentRunState;
+        approval: PendingApproval;
+    } | null>;
+    saveScore(score: SaveScoreInput): Promise<void>;
+    getScores(runId: string): Promise<AgentRunScore[]>;
+    private toRunState;
+}

package/dist/src/kysely-agent-run-state-service.js

@@ -0,0 +1,169 @@
+import { sql } from 'kysely';
+import { ensurePikkuSchema } from './schema/index.js';
+import { agentSchema } from './schema/agent.schema.js';
+import { getRunScores, saveRunScore } from './kysely-agent-run-scores.js';
+export class KyselyAgentRunStateService {
+    db;
+    initialized = false;
+    constructor(db) {
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        await ensurePikkuSchema(this.db, agentSchema);
+        this.initialized = true;
+    }
+    async createRun(run) {
+        const runId = `run-${crypto.randomUUID()}`;
+        await this.db
+            .insertInto('agentRun')
+            .values({
+            runId,
+            agentName: run.agentName,
+            threadId: run.threadId,
+            resourceId: run.resourceId,
+            status: run.status ?? 'running',
+            errorMessage: run.errorMessage ?? null,
+            suspendReason: run.suspendReason ?? null,
+            missingRpcs: run.missingRpcs ? JSON.stringify(run.missingRpcs) : null,
+            usageInputTokens: run.usage?.inputTokens ?? 0,
+            usageOutputTokens: run.usage?.outputTokens ?? 0,
+            usageModel: run.usage?.model ?? '',
+        })
+            .execute();
+        return runId;
+    }
+    async updateRun(runId, updates) {
+        const values = {
+            updatedAt: sql `CURRENT_TIMESTAMP`,
+        };
+        if (updates.status !== undefined)
+            values.status = updates.status;
+        if (updates.errorMessage !== undefined)
+            values.errorMessage = updates.errorMessage;
+        if (updates.suspendReason !== undefined)
+            values.suspendReason = updates.suspendReason;
+        if (updates.missingRpcs !== undefined)
+            values.missingRpcs = JSON.stringify(updates.missingRpcs);
+        if (updates.pendingApprovals !== undefined)
+            values.pendingApprovals = JSON.stringify(updates.pendingApprovals);
+        if (updates.usage) {
+            values.usageInputTokens = updates.usage.inputTokens;
+            values.usageOutputTokens = updates.usage.outputTokens;
+            values.usageModel = updates.usage.model;
+        }
+        await this.db
+            .updateTable('agentRun')
+            .set(values)
+            .where('runId', '=', runId)
+            .execute();
+    }
+    async getRun(runId) {
+        const row = await this.db
+            .selectFrom('agentRun')
+            .selectAll()
+            .where('runId', '=', runId)
+            .executeTakeFirst();
+        return row ? this.toRunState(row) : null;
+    }
+    async getRunsByThread(threadId) {
+        const rows = await this.db
+            .selectFrom('agentRun')
+            .selectAll()
+            .where('threadId', '=', threadId)
+            .orderBy('createdAt', 'desc')
+            .execute();
+        return rows.map((r) => this.toRunState(r));
+    }
+    async resolveApproval(toolCallId, status) {
+        const rows = await this.db
+            .selectFrom('agentRun')
+            .select(['runId', 'pendingApprovals'])
+            .where('status', '=', 'suspended')
+            .execute();
+        for (const row of rows) {
+            let approvals = [];
+            if (row.pendingApprovals) {
+                try {
+                    approvals = JSON.parse(row.pendingApprovals);
+                }
+                catch {
+                    console.warn(`Failed to parse pendingApprovals for run ${row.runId}, treating as empty`);
+                }
+            }
+            const filtered = approvals.filter((a) => a.toolCallId !== toolCallId);
+            if (filtered.length !== approvals.length) {
+                const updates = {
+                    pendingApprovals: filtered.length > 0 ? JSON.stringify(filtered) : null,
+                    updatedAt: sql `CURRENT_TIMESTAMP`,
+                };
+                if (filtered.length === 0) {
+                    updates.status = status;
+                }
+                // Compare-and-swap on the list we read: a concurrent approver that got
+                // there first has already rewritten it, and this update matches no row.
+                const result = await this.db
+                    .updateTable('agentRun')
+                    .set(updates)
+                    .where('runId', '=', row.runId)
+                    .where('status', '=', 'suspended')
+                    .where('pendingApprovals', '=', row.pendingApprovals)
+                    .executeTakeFirst();
+                return Number(result?.numUpdatedRows ?? 0) > 0;
+            }
+        }
+        return false;
+    }
+    async findRunByToolCallId(toolCallId) {
+        const rows = await this.db
+            .selectFrom('agentRun')
+            .selectAll()
+            .where('status', '=', 'suspended')
+            .execute();
+        for (const row of rows) {
+            let approvals = [];
+            if (row.pendingApprovals) {
+                try {
+                    approvals = JSON.parse(row.pendingApprovals);
+                }
+                catch {
+                    console.warn(`Failed to parse pendingApprovals for run ${row.runId}, treating as empty`);
+                }
+            }
+            const approval = approvals.find((a) => a.toolCallId === toolCallId);
+            if (approval) {
+                return { run: this.toRunState(row), approval };
+            }
+        }
+        return null;
+    }
+    async saveScore(score) {
+        await saveRunScore(this.db, score);
+    }
+    async getScores(runId) {
+        return getRunScores(this.db, runId);
+    }
+    toRunState(row) {
+        return {
+            runId: row.runId,
+            agentName: row.agentName,
+            threadId: row.threadId,
+            resourceId: row.resourceId,
+            status: row.status,
+            errorMessage: row.errorMessage ?? undefined,
+            suspendReason: row.suspendReason ?? undefined,
+            missingRpcs: row.missingRpcs ? JSON.parse(row.missingRpcs) : undefined,
+            pendingApprovals: row.pendingApprovals
+                ? JSON.parse(row.pendingApprovals)
+                : undefined,
+            usage: {
+                inputTokens: row.usageInputTokens ?? 0,
+                outputTokens: row.usageOutputTokens ?? 0,
+                model: row.usageModel ?? '',
+            },
+            createdAt: new Date(row.createdAt),
+            updatedAt: new Date(row.updatedAt),
+        };
+    }
+}