@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/memory/types.d.ts

@@ -1,3 +1,6 @@
+import type { ConnectorEventSearchHit } from '../connectors/types.js';
+import type { ReadIdentity } from '../entities/read-identity.js';
+import type { SearchHitDiagnostics, SearchQualityOptions, SearchStrictness } from '../search/search-quality.js';
 export declare const MEMORY_SCOPE_KINDS: readonly ["global", "user", "channel", "project"];
 export type MemoryScopeKind = (typeof MEMORY_SCOPE_KINDS)[number];
 export declare const MEMORY_KINDS: readonly ["decision", "preference", "constraint", "lesson", "fact", "task", "schedule", "compiled"];
@@ -18,6 +21,13 @@ export interface MemoryScopeRef {
     kind: MemoryScopeKind;
     id: string;
 }
+export interface MemorySourceRef {
+    package: 'mama-core' | 'mcp-server' | 'standalone' | 'claude-code-plugin';
+    source_type: string;
+    user_id?: string;
+    channel_id?: string;
+    project_id?: string;
+}
 export interface MemoryRecord {
     id: string;
     topic: string;
@@ -27,17 +37,34 @@ export interface MemoryRecord {
     confidence: number;
     status: MemoryStatus;
     scopes: MemoryScopeRef[];
-    source: {
-        package: 'mama-core' | 'mcp-server' | 'standalone' | 'claude-code-plugin';
-        source_type: string;
-        user_id?: string;
-        channel_id?: string;
-        project_id?: string;
-    };
+    source: MemorySourceRef;
     created_at: number | string;
     updated_at: number | string;
     /** ISO 8601 date when the event actually occurred (e.g. "2023-01-15"). Null if not set. */
     event_date?: string | null;
+    /** Source event timestamp in milliseconds when known. Null if not set. */
+    event_datetime?: number | null;
+    read_identity?: ReadIdentity;
+    retrieval_diagnostics?: SearchHitDiagnostics;
+}
+export type RecallMemoryOptions = SearchQualityOptions & {
+    scopes?: MemoryScopeRef[];
+    includeProfile?: boolean;
+    includeHistory?: boolean;
+    skipGraphExpansion?: boolean;
+    limit?: number;
+};
+export interface RecallSearchDiagnostics {
+    candidate_counts: {
+        vector: number;
+        lexical: number;
+        entity: number;
+        graph_expanded: number;
+        vector_only: number;
+        rejected_by_strictness: number;
+    };
+    threshold: number;
+    strictness: SearchStrictness;
 }
 export interface MemoryEdge {
     from_id: string;
@@ -57,6 +84,8 @@ export interface ProfileSnapshot {
 export interface RecallBundle {
     profile: ProfileSnapshot;
     memories: MemoryRecord[];
+    /** Phase 3: cross-connector event hits, populated when searchWithConnectorEvents=true */
+    connector_event_hits?: ConnectorEventSearchHit[];
     graph_context: {
         primary: MemoryRecord[];
         expanded: MemoryRecord[];
@@ -66,12 +95,15 @@ export interface RecallBundle {
         query: string;
         scope_order: MemoryScopeKind[];
         retrieval_sources: string[];
+        diagnostics?: RecallSearchDiagnostics;
     };
 }
+/** Phase 3: unified search result type — memory-authored or connector-enriched. */
+export type MemorySearchResultHit = MemoryRecord | ConnectorEventSearchHit;
 export interface MemoryEventRecord {
     event_id: string;
-    event_type: 'observed_conversation' | 'save' | 'supersede' | 'contradict' | 'mark_stale' | 'quarantine' | 'no_op' | 'audit_failed' | 'notice_sent';
-    actor: 'memory_agent' | 'main_agent' | 'user' | 'system';
+    event_type: 'observed_conversation' | 'save' | 'supersede' | 'contradict' | 'mark_stale' | 'quarantine' | 'no_op' | 'audit_failed' | 'notice_sent' | 'provenance.empty_batch' | 'provenance.link_write_failed' | 'connector_event_index.retention_swept' | 'case.link_created' | 'case.link_revoked' | 'case.membership_pinned' | 'case.membership_unpinned' | 'case.source_promoted' | 'case.freshness_drifted' | 'automation.job.started' | 'automation.job.succeeded' | 'automation.job.failed' | 'automation.job.skipped_concurrent' | 'review.bulk.approved' | 'review.bulk.rejected' | 'review.bulk.deferred' | 'canary.drift.false_merge_rate' | 'canary.drift.projection_fragmentation_rate' | 'canary.drift.replay_stale' | 'auth.role_denied' | 'ontology.proposal' | 'ontology.approval' | 'repair.approval' | 'case.fast_write_applied' | 'case.fast_write_lock_skipped' | 'case.correction_applied' | 'case.correction_reverted' | 'case.correction_superseded' | 'case.membership_tombstoned' | 'case.merged' | 'case.split' | 'case.membership_matched' | 'case.membership_candidate';
+    actor: 'memory_agent' | 'main_agent' | 'user' | 'system' | `user:${string}` | `user_uuid:${string}` | `local:${string}` | `actor:${string}` | 'token:bearer';
     source_turn_id?: string;
     memory_id?: string;
     topic?: string;
@@ -80,6 +112,61 @@ export interface MemoryEventRecord {
     reason?: string;
     created_at: number;
 }
+export interface MemoryWriteProvenance {
+    actor?: MemoryEventRecord['actor'];
+    agent_id?: string;
+    model_run_id?: string;
+    envelope_hash?: string;
+    tool_name?: string;
+    gateway_call_id?: string;
+    source_turn_id?: string;
+    source_message_ref?: string;
+    source_refs?: string[];
+}
+export interface MemoryProvenanceRecord {
+    memory_id: string;
+    agent_id: string | null;
+    model_run_id: string | null;
+    envelope_hash: string | null;
+    gateway_call_id: string | null;
+    source_refs: string[];
+    provenance: Record<string, unknown>;
+    latest_event?: MemoryEventRecord;
+}
+export interface PublicSaveMemoryInput {
+    topic: string;
+    kind: MemoryKind;
+    summary: string;
+    details: string;
+    confidence?: number;
+    status?: MemoryStatus;
+    scopes: MemoryScopeRef[];
+    source: MemorySourceRef;
+    excludeIds?: string[];
+    eventDate?: string;
+    eventDateTime?: number;
+    entityObservationIds?: string[];
+    timelineEvent?: {
+        id?: string;
+        entity_id?: string;
+        event_type: string;
+        role?: string | null;
+        valid_from?: number | null;
+        valid_to?: number | null;
+        observed_at?: number | null;
+        source_ref?: string | null;
+        summary: string;
+        details?: string | null;
+    };
+}
+export interface PublicIngestMemoryInput {
+    content: string;
+    scopes?: MemoryScopeRef[];
+    source: MemorySourceRef;
+    eventDate?: string;
+    eventDateTime?: number;
+}
+export type PublicIngestConversationInput = IngestConversationInput;
 export interface AuditFindingRecord {
     finding_id: string;
     kind: 'wrong_direction' | 'memory_conflict' | 'stale_memory' | 'unsupported_claim';
@@ -227,13 +314,7 @@ export interface ConversationMessage {
 export interface IngestConversationInput {
     messages: ConversationMessage[];
     scopes: MemoryScopeRef[];
-    source: {
-        package: 'mama-core' | 'mcp-server' | 'standalone' | 'claude-code-plugin';
-        source_type: string;
-        user_id?: string;
-        channel_id?: string;
-        project_id?: string;
-    };
+    source: MemorySourceRef;
     extract?: {
         enabled: boolean;
         model?: string;

package/dist/model-runs/store.d.ts

@@ -0,0 +1,13 @@
+import type { DatabaseAdapter } from '../db-manager.js';
+import type { BeginModelRunInput, ModelRunRecord } from './types.js';
+type ModelRunAdapter = Pick<DatabaseAdapter, 'prepare'>;
+export declare function beginModelRunInAdapter(adapter: ModelRunAdapter, input: BeginModelRunInput): ModelRunRecord;
+export declare function commitModelRunInAdapter(adapter: ModelRunAdapter, modelRunId: string, summary?: string): ModelRunRecord;
+export declare function failModelRunInAdapter(adapter: ModelRunAdapter, modelRunId: string, errorSummary: string): ModelRunRecord;
+export declare function getModelRunInAdapter(adapter: ModelRunAdapter, modelRunId: string): ModelRunRecord | null;
+export declare function beginModelRun(input: BeginModelRunInput): Promise<ModelRunRecord>;
+export declare function commitModelRun(modelRunId: string, summary?: string): Promise<ModelRunRecord>;
+export declare function failModelRun(modelRunId: string, errorSummary: string): Promise<ModelRunRecord>;
+export declare function getModelRun(modelRunId: string): Promise<ModelRunRecord | null>;
+export {};
+//# sourceMappingURL=store.d.ts.map

package/dist/model-runs/store.js

@@ -0,0 +1,457 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beginModelRunInAdapter = beginModelRunInAdapter;
+exports.commitModelRunInAdapter = commitModelRunInAdapter;
+exports.failModelRunInAdapter = failModelRunInAdapter;
+exports.getModelRunInAdapter = getModelRunInAdapter;
+exports.beginModelRun = beginModelRun;
+exports.commitModelRun = commitModelRun;
+exports.failModelRun = failModelRun;
+exports.getModelRun = getModelRun;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const db_manager_js_1 = require("../db-manager.js");
+const types_js_1 = require("./types.js");
+const BEGIN_REPLAY_FIELDS = [
+    'model_id',
+    'model_provider',
+    'prompt_version',
+    'tool_manifest_version',
+    'output_schema_version',
+    'agent_id',
+    'instance_id',
+    'envelope_hash',
+    'parent_model_run_id',
+    'input_snapshot_ref',
+    'input_refs_json',
+    'token_count',
+    'cost_estimate',
+];
+const STABLE_INPUT_REF_KEYS = new Set([
+    'request_idempotency_key',
+    'gateway_call_id',
+    'source_turn_id',
+    'turn_id',
+    'message_id',
+    'event_id',
+    'raw_event_id',
+    'trace_id',
+    'cache_key',
+]);
+function modelRunId() {
+    return `mr_${node_crypto_1.default.randomUUID().replace(/-/g, '')}`;
+}
+function nullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function formatInvalidValue(value) {
+    return typeof value === 'string' ? JSON.stringify(value) : String(value);
+}
+function requireString(value, field) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`model_runs.${field} must be a non-empty string: ${formatInvalidValue(value)}`);
+    }
+    return value;
+}
+function normalizeTimestamp(value) {
+    if (value === undefined) {
+        return Date.now();
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return Math.floor(value);
+    }
+    throw new Error(`model_runs.created_at must be a finite number: ${formatInvalidValue(value)}`);
+}
+function requireTimestamp(value, field, modelRunId) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`Invalid model_runs.${field} for ${modelRunId}: ${formatInvalidValue(value)}`);
+    }
+    return Math.floor(value);
+}
+function normalizeNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.floor(value) : fallback;
+}
+function normalizeCost(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function requireInputRefsObject(value, field) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    throw new Error(`model_runs.${field} must be a JSON object`);
+}
+function normalizeInputRefsJson(input) {
+    if (typeof input.input_refs_json === 'string') {
+        try {
+            requireInputRefsObject(JSON.parse(input.input_refs_json), 'input_refs_json');
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Invalid model_runs.input_refs_json: ${message}`);
+        }
+        return input.input_refs_json;
+    }
+    if (input.input_refs === null || input.input_refs === undefined) {
+        return null;
+    }
+    const inputRefs = requireInputRefsObject(input.input_refs, 'input_refs');
+    try {
+        return JSON.stringify(inputRefs);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid model_runs.input_refs: ${message}`);
+    }
+}
+function parseInputRefs(row) {
+    const inputRefsJson = nullableString(row.input_refs_json);
+    if (!inputRefsJson) {
+        return { input_refs_json: null, input_refs: null };
+    }
+    try {
+        const parsed = JSON.parse(inputRefsJson);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            return {
+                input_refs_json: inputRefsJson,
+                input_refs: parsed,
+            };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Invalid model_runs.input_refs_json for ${row.model_run_id}: ${message}`);
+    }
+    throw new Error(`Invalid model_runs.input_refs_json for ${row.model_run_id}: expected object`);
+}
+const MODEL_RUN_STATUS_SET = new Set(types_js_1.MODEL_RUN_STATUSES);
+function requireModelRunStatus(value, modelRunId) {
+    if (typeof value === 'string' && MODEL_RUN_STATUS_SET.has(value)) {
+        return value;
+    }
+    throw new Error(`Invalid model_runs.status for ${modelRunId}: ${formatInvalidValue(value)}`);
+}
+function normalizeBeginStatus(value, modelRunId) {
+    const status = requireModelRunStatus(value ?? 'running', modelRunId);
+    if (status !== 'running') {
+        throw new Error(`model_runs.status must begin in running status for ${modelRunId}: ${status}`);
+    }
+    return status;
+}
+function mapModelRunRow(row) {
+    const model_run_id = requireString(row.model_run_id, 'model_run_id');
+    const inputRefs = parseInputRefs({ model_run_id, input_refs_json: row.input_refs_json });
+    return {
+        model_run_id,
+        model_id: nullableString(row.model_id),
+        model_provider: nullableString(row.model_provider),
+        prompt_version: nullableString(row.prompt_version),
+        tool_manifest_version: nullableString(row.tool_manifest_version),
+        output_schema_version: nullableString(row.output_schema_version),
+        agent_id: nullableString(row.agent_id),
+        instance_id: nullableString(row.instance_id),
+        envelope_hash: nullableString(row.envelope_hash),
+        parent_model_run_id: nullableString(row.parent_model_run_id),
+        input_snapshot_ref: nullableString(row.input_snapshot_ref),
+        input_refs_json: inputRefs.input_refs_json,
+        input_refs: inputRefs.input_refs,
+        completion_summary: nullableString(row.completion_summary),
+        status: requireModelRunStatus(row.status, model_run_id),
+        error_summary: nullableString(row.error_summary),
+        token_count: normalizeNumber(row.token_count, 0),
+        cost_estimate: normalizeCost(row.cost_estimate),
+        created_at: requireTimestamp(row.created_at, 'created_at', model_run_id),
+        completed_at: typeof row.completed_at === 'number' && Number.isFinite(row.completed_at)
+            ? Math.floor(row.completed_at)
+            : null,
+    };
+}
+async function initializedAdapter() {
+    await (0, db_manager_js_1.initDB)();
+    return (0, db_manager_js_1.getAdapter)();
+}
+function selectModelRun(adapter, id) {
+    const row = adapter
+        .prepare(`
+        SELECT
+          model_run_id, model_id, model_provider, prompt_version, tool_manifest_version,
+          output_schema_version, agent_id, instance_id, envelope_hash, parent_model_run_id,
+          input_snapshot_ref, input_refs_json, completion_summary, status, error_summary,
+          token_count, cost_estimate, created_at, completed_at
+        FROM model_runs
+        WHERE model_run_id = ?
+      `)
+        .get(id);
+    return row ? mapModelRunRow(row) : null;
+}
+function requireModelRun(adapter, id) {
+    const run = selectModelRun(adapter, id);
+    if (!run) {
+        throw new Error(`Model run not found: ${id}`);
+    }
+    return run;
+}
+function normalizeBeginModelRunInput(id, input, createdAt, status, inputRefsJson) {
+    return {
+        model_run_id: id,
+        model_id: nullableString(input.model_id),
+        model_provider: nullableString(input.model_provider),
+        prompt_version: nullableString(input.prompt_version),
+        tool_manifest_version: nullableString(input.tool_manifest_version),
+        output_schema_version: nullableString(input.output_schema_version),
+        agent_id: nullableString(input.agent_id),
+        instance_id: nullableString(input.instance_id),
+        envelope_hash: nullableString(input.envelope_hash),
+        parent_model_run_id: nullableString(input.parent_model_run_id),
+        input_snapshot_ref: nullableString(input.input_snapshot_ref),
+        input_refs_json: inputRefsJson,
+        status,
+        error_summary: nullableString(input.error_summary),
+        token_count: normalizeNumber(input.token_count, 0),
+        cost_estimate: normalizeCost(input.cost_estimate),
+        created_at: createdAt,
+    };
+}
+function assertReplayHasIdempotencyDiscriminator(expected) {
+    if (expected.envelope_hash || hasStableInputRefs(expected.input_refs_json)) {
+        return;
+    }
+    throw new Error(`Model run already exists and replay is missing an idempotency discriminator: ${expected.model_run_id}`);
+}
+function hasStableInputRefs(inputRefsJson) {
+    if (!inputRefsJson) {
+        return false;
+    }
+    const inputRefs = JSON.parse(inputRefsJson);
+    return hasStableInputRef(inputRefs);
+}
+function hasStableInputRef(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    for (const [key, item] of Object.entries(value)) {
+        if (STABLE_INPUT_REF_KEYS.has(key) && isNonEmptyStableInputRefValue(item)) {
+            return true;
+        }
+        if (hasStableInputRef(item)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNonEmptyStableInputRefValue(value) {
+    if (typeof value === 'string') {
+        return value.trim().length > 0;
+    }
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function pushReplayField(fields, field) {
+    if (!fields.includes(field)) {
+        fields.push(field);
+    }
+}
+function replayFieldsForInput(input) {
+    const fields = [];
+    for (const field of BEGIN_REPLAY_FIELDS) {
+        if (field === 'input_refs_json') {
+            if (input.input_refs !== undefined || input.input_refs_json !== undefined) {
+                pushReplayField(fields, field);
+            }
+        }
+        else if (input[field] !== undefined) {
+            pushReplayField(fields, field);
+        }
+    }
+    if (input.created_at !== undefined) {
+        pushReplayField(fields, 'created_at');
+    }
+    if (input.status !== undefined && input.status !== 'running') {
+        pushReplayField(fields, 'status');
+    }
+    if (input.error_summary !== undefined) {
+        pushReplayField(fields, 'error_summary');
+    }
+    return fields;
+}
+function canonicalJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => canonicalJson(item));
+    }
+    if (value && typeof value === 'object') {
+        const object = value;
+        const sorted = Object.create(null);
+        for (const key of Object.keys(object).sort()) {
+            Object.defineProperty(sorted, key, {
+                value: canonicalJson(object[key]),
+                enumerable: true,
+                configurable: true,
+                writable: true,
+            });
+        }
+        return sorted;
+    }
+    return value;
+}
+function canonicalJsonString(value) {
+    return JSON.stringify(canonicalJson(JSON.parse(value)));
+}
+function replayFieldMatches(existing, expected, field) {
+    if (field === 'input_refs_json') {
+        if (existing.input_refs_json === expected.input_refs_json) {
+            return true;
+        }
+        if (!existing.input_refs_json || !expected.input_refs_json) {
+            return existing.input_refs_json === expected.input_refs_json;
+        }
+        return (canonicalJsonString(existing.input_refs_json) ===
+            canonicalJsonString(expected.input_refs_json));
+    }
+    return existing[field] === expected[field];
+}
+function assertExistingModelRunMatchesInput(existing, expected, replayFields) {
+    assertReplayHasIdempotencyDiscriminator(expected);
+    for (const field of replayFields) {
+        if (!replayFieldMatches(existing, expected, field)) {
+            throw new Error(`Model run already exists with different ${field}: ${existing.model_run_id}`);
+        }
+    }
+}
+function isDuplicateModelRunError(error) {
+    if (error && typeof error === 'object' && 'code' in error) {
+        const code = error.code;
+        if (code === 'SQLITE_CONSTRAINT' ||
+            code === 'SQLITE_CONSTRAINT_PRIMARYKEY' ||
+            code === 'SQLITE_CONSTRAINT_UNIQUE') {
+            return true;
+        }
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return /UNIQUE constraint failed: model_runs\.model_run_id|PRIMARY KEY constraint failed/i.test(message);
+}
+function resolveExistingCommittedRun(existing, summary) {
+    if (existing.status === 'committed') {
+        if (existing.completion_summary === summary) {
+            return existing;
+        }
+        throw new Error(`Model run already committed with different completion_summary: ${existing.model_run_id}`);
+    }
+    if (existing.status === 'failed') {
+        throw new Error(`Model run already failed: ${existing.model_run_id}`);
+    }
+    throw new Error(`Cannot commit model run in ${existing.status} status: ${existing.model_run_id}`);
+}
+function resolveExistingFailedRun(existing, errorSummary) {
+    if (existing.status === 'failed') {
+        if (existing.error_summary === errorSummary) {
+            return existing;
+        }
+        throw new Error(`Model run already failed with different error_summary: ${existing.model_run_id}`);
+    }
+    if (existing.status === 'committed') {
+        throw new Error(`Model run already committed: ${existing.model_run_id}`);
+    }
+    throw new Error(`Cannot fail model run in ${existing.status} status: ${existing.model_run_id}`);
+}
+function beginModelRunInAdapter(adapter, input) {
+    const id = nullableString(input.model_run_id) ?? modelRunId();
+    const createdAt = normalizeTimestamp(input.created_at);
+    const status = normalizeBeginStatus(input.status, id);
+    const inputRefsJson = normalizeInputRefsJson(input);
+    const expected = normalizeBeginModelRunInput(id, input, createdAt, status, inputRefsJson);
+    const replayFields = replayFieldsForInput(input);
+    const existing = selectModelRun(adapter, id);
+    if (existing) {
+        assertExistingModelRunMatchesInput(existing, expected, replayFields);
+        return existing;
+    }
+    try {
+        adapter
+            .prepare(`
+          INSERT INTO model_runs (
+            model_run_id, model_id, model_provider, prompt_version, tool_manifest_version,
+            output_schema_version, agent_id, instance_id, envelope_hash, parent_model_run_id,
+            input_snapshot_ref, input_refs_json, completion_summary, status, error_summary,
+            token_count, cost_estimate, created_at, completed_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `)
+            .run(id, nullableString(input.model_id), nullableString(input.model_provider), nullableString(input.prompt_version), nullableString(input.tool_manifest_version), nullableString(input.output_schema_version), nullableString(input.agent_id), nullableString(input.instance_id), nullableString(input.envelope_hash), nullableString(input.parent_model_run_id), nullableString(input.input_snapshot_ref), inputRefsJson, null, status, nullableString(input.error_summary), normalizeNumber(input.token_count, 0), normalizeCost(input.cost_estimate), createdAt, null);
+    }
+    catch (error) {
+        if (!isDuplicateModelRunError(error)) {
+            throw error;
+        }
+        const duplicate = selectModelRun(adapter, id);
+        if (duplicate) {
+            assertExistingModelRunMatchesInput(duplicate, expected, replayFields);
+            return duplicate;
+        }
+        throw error;
+    }
+    return requireModelRun(adapter, id);
+}
+function commitModelRunInAdapter(adapter, modelRunId, summary) {
+    const summaryValue = nullableString(summary);
+    const existing = requireModelRun(adapter, modelRunId);
+    if (existing.status !== 'running') {
+        return resolveExistingCommittedRun(existing, summaryValue);
+    }
+    const completedAt = Date.now();
+    const result = adapter
+        .prepare(`
+        UPDATE model_runs
+        SET status = 'committed',
+            completion_summary = ?,
+            error_summary = NULL,
+            completed_at = ?
+        WHERE model_run_id = ? AND status = 'running'
+      `)
+        .run(summaryValue, completedAt, modelRunId);
+    if (result.changes === 0) {
+        return resolveExistingCommittedRun(requireModelRun(adapter, modelRunId), summaryValue);
+    }
+    return requireModelRun(adapter, modelRunId);
+}
+function failModelRunInAdapter(adapter, modelRunId, errorSummary) {
+    const errorSummaryValue = nullableString(errorSummary);
+    const existing = requireModelRun(adapter, modelRunId);
+    if (existing.status !== 'running') {
+        return resolveExistingFailedRun(existing, errorSummaryValue);
+    }
+    const completedAt = Date.now();
+    const result = adapter
+        .prepare(`
+        UPDATE model_runs
+        SET status = 'failed',
+            completion_summary = NULL,
+            error_summary = ?,
+            completed_at = ?
+        WHERE model_run_id = ? AND status = 'running'
+      `)
+        .run(errorSummaryValue, completedAt, modelRunId);
+    if (result.changes === 0) {
+        return resolveExistingFailedRun(requireModelRun(adapter, modelRunId), errorSummaryValue);
+    }
+    return requireModelRun(adapter, modelRunId);
+}
+function getModelRunInAdapter(adapter, modelRunId) {
+    return selectModelRun(adapter, modelRunId);
+}
+async function beginModelRun(input) {
+    const adapter = await initializedAdapter();
+    return beginModelRunInAdapter(adapter, input);
+}
+async function commitModelRun(modelRunId, summary) {
+    const adapter = await initializedAdapter();
+    return commitModelRunInAdapter(adapter, modelRunId, summary);
+}
+async function failModelRun(modelRunId, errorSummary) {
+    const adapter = await initializedAdapter();
+    return failModelRunInAdapter(adapter, modelRunId, errorSummary);
+}
+async function getModelRun(modelRunId) {
+    const adapter = await initializedAdapter();
+    return getModelRunInAdapter(adapter, modelRunId);
+}
+//# sourceMappingURL=store.js.map

package/dist/model-runs/tool-trace-store.d.ts

@@ -0,0 +1,4 @@
+import type { AppendToolTraceInput, ToolTraceRecord } from './types.js';
+export declare function appendToolTrace(input: AppendToolTraceInput): Promise<ToolTraceRecord>;
+export declare function listToolTracesForRun(modelRunId: string): Promise<ToolTraceRecord[]>;
+//# sourceMappingURL=tool-trace-store.d.ts.map