@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/model-runs/tool-trace-store.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendToolTrace = appendToolTrace;
+exports.listToolTracesForRun = listToolTracesForRun;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const db_manager_js_1 = require("../db-manager.js");
+function traceId() {
+    return `tr_${node_crypto_1.default.randomUUID().replace(/-/g, '')}`;
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new Error(`tool_traces.${field} must be a non-empty string: ${formatInvalidValue(value)}`);
+    }
+    return value;
+}
+function formatInvalidValue(value) {
+    return typeof value === 'string' ? JSON.stringify(value) : String(value);
+}
+function nullableString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function normalizeTimestamp(value) {
+    if (value === undefined || value === null) {
+        return Date.now();
+    }
+    return requiredInteger(value, 'created_at');
+}
+function normalizeDuration(value) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    return requiredNonNegativeInteger(value, 'duration_ms');
+}
+function requiredInteger(value, field) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new Error(`tool_traces.${field} must be a finite number: ${formatInvalidValue(value)}`);
+    }
+    return Math.floor(value);
+}
+function requiredNonNegativeInteger(value, field) {
+    const normalized = requiredInteger(value, field);
+    if (normalized < 0) {
+        throw new Error(`tool_traces.${field} must be non-negative: ${formatInvalidValue(value)}`);
+    }
+    return normalized;
+}
+function mapToolTraceRow(row) {
+    return {
+        trace_id: requiredString(row.trace_id, 'trace_id'),
+        model_run_id: requiredString(row.model_run_id, 'model_run_id'),
+        gateway_call_id: nullableString(row.gateway_call_id),
+        tool_name: requiredString(row.tool_name, 'tool_name'),
+        input_summary: nullableString(row.input_summary),
+        output_summary: nullableString(row.output_summary),
+        execution_status: nullableString(row.execution_status),
+        duration_ms: requiredNonNegativeInteger(row.duration_ms, 'duration_ms'),
+        envelope_hash: nullableString(row.envelope_hash),
+        created_at: requiredInteger(row.created_at, 'created_at'),
+    };
+}
+async function initializedAdapter() {
+    await (0, db_manager_js_1.initDB)();
+    return (0, db_manager_js_1.getAdapter)();
+}
+function selectToolTrace(adapter, id) {
+    const row = adapter
+        .prepare(`
+        SELECT
+          trace_id, model_run_id, gateway_call_id, tool_name, input_summary,
+          output_summary, execution_status, duration_ms, envelope_hash, created_at
+        FROM tool_traces
+        WHERE trace_id = ?
+      `)
+        .get(id);
+    if (!row) {
+        throw new Error(`Tool trace not found: ${id}`);
+    }
+    return mapToolTraceRow(row);
+}
+async function appendToolTrace(input) {
+    const adapter = await initializedAdapter();
+    const id = nullableString(input.trace_id) ?? traceId();
+    const modelRunId = requiredString(input.model_run_id, 'model_run_id');
+    const toolName = requiredString(input.tool_name, 'tool_name');
+    adapter
+        .prepare(`
+        INSERT INTO tool_traces (
+          trace_id, model_run_id, gateway_call_id, tool_name, input_summary,
+          output_summary, execution_status, duration_ms, envelope_hash, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `)
+        .run(id, modelRunId, nullableString(input.gateway_call_id), toolName, nullableString(input.input_summary), nullableString(input.output_summary), nullableString(input.execution_status), normalizeDuration(input.duration_ms), nullableString(input.envelope_hash), normalizeTimestamp(input.created_at));
+    return selectToolTrace(adapter, id);
+}
+async function listToolTracesForRun(modelRunId) {
+    const adapter = await initializedAdapter();
+    const id = requiredString(modelRunId, 'model_run_id');
+    const rows = adapter
+        .prepare(`
+        SELECT
+          trace_id, model_run_id, gateway_call_id, tool_name, input_summary,
+          output_summary, execution_status, duration_ms, envelope_hash, created_at
+        FROM tool_traces
+        WHERE model_run_id = ?
+        ORDER BY created_at DESC, rowid DESC
+      `)
+        .all(id);
+    return rows.map(mapToolTraceRow);
+}
+//# sourceMappingURL=tool-trace-store.js.map

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

@@ -0,0 +1,69 @@
+export declare const MODEL_RUN_STATUSES: readonly ["running", "committed", "failed", "legacy"];
+export type ModelRunStatus = (typeof MODEL_RUN_STATUSES)[number];
+export interface BeginModelRunInput {
+    model_run_id?: string;
+    model_id?: string | null;
+    model_provider?: string | null;
+    prompt_version?: string | null;
+    tool_manifest_version?: string | null;
+    output_schema_version?: string | null;
+    agent_id?: string | null;
+    instance_id?: string | null;
+    envelope_hash?: string | null;
+    parent_model_run_id?: string | null;
+    input_snapshot_ref?: string | null;
+    input_refs?: Record<string, unknown> | null;
+    input_refs_json?: string | null;
+    status?: ModelRunStatus;
+    error_summary?: string | null;
+    token_count?: number | null;
+    cost_estimate?: number | null;
+    created_at?: number;
+}
+export interface ModelRunRecord {
+    model_run_id: string;
+    model_id: string | null;
+    model_provider: string | null;
+    prompt_version: string | null;
+    tool_manifest_version: string | null;
+    output_schema_version: string | null;
+    agent_id: string | null;
+    instance_id: string | null;
+    envelope_hash: string | null;
+    parent_model_run_id: string | null;
+    input_snapshot_ref: string | null;
+    input_refs_json: string | null;
+    input_refs: Record<string, unknown> | null;
+    completion_summary: string | null;
+    status: ModelRunStatus;
+    error_summary: string | null;
+    token_count: number;
+    cost_estimate: number | null;
+    created_at: number;
+    completed_at: number | null;
+}
+export interface AppendToolTraceInput {
+    trace_id?: string;
+    model_run_id: string;
+    gateway_call_id?: string | null;
+    tool_name: string;
+    input_summary?: string | null;
+    output_summary?: string | null;
+    execution_status?: string | null;
+    duration_ms?: number | null;
+    envelope_hash?: string | null;
+    created_at?: number;
+}
+export interface ToolTraceRecord {
+    trace_id: string;
+    model_run_id: string;
+    gateway_call_id: string | null;
+    tool_name: string;
+    input_summary: string | null;
+    output_summary: string | null;
+    execution_status: string | null;
+    duration_ms: number;
+    envelope_hash: string | null;
+    created_at: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/model-runs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_RUN_STATUSES = void 0;
+exports.MODEL_RUN_STATUSES = ['running', 'committed', 'failed', 'legacy'];
+//# sourceMappingURL=types.js.map

package/dist/runtime/trusted-provenance.d.ts

@@ -0,0 +1,3 @@
+export { createTrustedProvenanceCapability } from '../memory/provenance.js';
+export type { TrustedMemoryWriteOptions, TrustedProvenanceCapability, } from '../memory/provenance.js';
+//# sourceMappingURL=trusted-provenance.d.ts.map

package/dist/runtime/trusted-provenance.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTrustedProvenanceCapability = void 0;
+var provenance_js_1 = require("../memory/provenance.js");
+Object.defineProperty(exports, "createTrustedProvenanceCapability", { enumerable: true, get: function () { return provenance_js_1.createTrustedProvenanceCapability; } });
+//# sourceMappingURL=trusted-provenance.js.map

package/dist/search/feedback-store.d.ts

@@ -0,0 +1,59 @@
+import type { RunResult } from '../db-adapter/statement.js';
+import { type QuestionType } from './question-type.js';
+export type SearchFeedbackKind = 'shown' | 'accept' | 'reject' | 'hide' | 'click';
+export type SearchFeedbackSourceType = 'decision' | 'checkpoint' | 'wiki_page' | 'case' | 'connector_event';
+export interface SearchFeedbackInput {
+    result_id: string;
+    session_id?: string | null;
+    query: string;
+    result_source_type: SearchFeedbackSourceType;
+    result_source_id: string;
+    feedback_kind: SearchFeedbackKind;
+    question_type?: QuestionType | null;
+    shown_index: number;
+    result_case_id?: string | null;
+    clicked_result_rank?: number | null;
+    created_at?: string;
+}
+export interface ListSearchFeedbackOptions {
+    since?: string;
+    until?: string;
+    limit?: number;
+}
+export interface SearchFeedbackRow {
+    feedback_id: string;
+    query: string;
+    query_hash_hex: string;
+    question_type: QuestionType;
+    result_source_type: SearchFeedbackSourceType;
+    result_source_id: string;
+    case_id: string | null;
+    feedback_kind: SearchFeedbackKind;
+    rank_position: number;
+    score_before: number | null;
+    score_after: number | null;
+    session_id: string | null;
+    actor: string;
+    metadata_json: string | null;
+    created_at: string;
+    updated_at: string | null;
+}
+export interface RecordSearchFeedbackResult {
+    feedback_id: string;
+    query_hash: string;
+    deduped: boolean;
+}
+export interface FeedbackStoreAdapter {
+    prepare(sql: string): {
+        run(...params: unknown[]): RunResult;
+        get(...params: unknown[]): unknown;
+        all(...params: unknown[]): unknown[];
+    };
+    transaction?<T>(fn: () => T): T | (() => T);
+}
+export declare function hashQuery(query: string): string;
+export declare function getFeedbackRetentionDays(adapter: FeedbackStoreAdapter): number;
+export declare function compactShownSearchFeedback(adapter: FeedbackStoreAdapter, retentionDays?: number): number;
+export declare function recordSearchFeedback(adapter: FeedbackStoreAdapter, input: SearchFeedbackInput): RecordSearchFeedbackResult;
+export declare function listSearchFeedback(adapter: FeedbackStoreAdapter, options?: ListSearchFeedbackOptions): SearchFeedbackRow[];
+//# sourceMappingURL=feedback-store.d.ts.map

package/dist/search/feedback-store.js

@@ -0,0 +1,211 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashQuery = hashQuery;
+exports.getFeedbackRetentionDays = getFeedbackRetentionDays;
+exports.compactShownSearchFeedback = compactShownSearchFeedback;
+exports.recordSearchFeedback = recordSearchFeedback;
+exports.listSearchFeedback = listSearchFeedback;
+const node_crypto_1 = require("node:crypto");
+const question_type_js_1 = require("./question-type.js");
+const DEFAULT_RETENTION_DAYS = 180;
+const MS_PER_DAY = 24 * 60 * 60 * 1000;
+function normalizedQuery(query) {
+    return query.trim().toLowerCase();
+}
+function fullQueryHashHex(query) {
+    return (0, node_crypto_1.createHash)('sha256').update(normalizedQuery(query)).digest('hex');
+}
+function fullQueryHashBuffer(query) {
+    return Buffer.from(fullQueryHashHex(query), 'hex');
+}
+function hashQuery(query) {
+    return fullQueryHashHex(query).slice(0, 16);
+}
+function assertNonEmpty(value, field) {
+    if (!value || value.trim().length === 0) {
+        throw new Error(`${field} is required`);
+    }
+}
+function assertRank(value, field) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`${field} must be a non-negative integer`);
+    }
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function cutoffIso(retentionDays, now = new Date()) {
+    return new Date(now.getTime() - retentionDays * MS_PER_DAY).toISOString();
+}
+function stableObject(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => stableObject(item));
+    }
+    if (typeof value !== 'object' || value === null) {
+        return value;
+    }
+    const input = value;
+    const output = {};
+    for (const key of Object.keys(input).sort((left, right) => left.localeCompare(right))) {
+        const item = input[key];
+        if (item !== undefined) {
+            output[key] = stableObject(item);
+        }
+    }
+    return output;
+}
+function canonicalJson(value) {
+    return JSON.stringify(stableObject(value));
+}
+function runTransaction(adapter, fn) {
+    if (!adapter.transaction) {
+        throw new Error('recordSearchFeedback requires adapter.transaction for atomic writes.');
+    }
+    const result = adapter.transaction(fn);
+    if (typeof result === 'function') {
+        return result();
+    }
+    return result;
+}
+function parseRetentionValue(value) {
+    const parsed = JSON.parse(value);
+    const numeric = typeof parsed === 'number' ? parsed : Number(parsed);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        throw new Error(`Invalid search_feedback_retention_days value: ${value}`);
+    }
+    return Math.floor(numeric);
+}
+function getFeedbackRetentionDays(adapter) {
+    const row = adapter
+        .prepare(`
+        SELECT value_json
+        FROM search_ranker_settings
+        WHERE key = 'search_feedback_retention_days'
+      `)
+        .get();
+    if (!row?.value_json) {
+        return DEFAULT_RETENTION_DAYS;
+    }
+    return parseRetentionValue(row.value_json);
+}
+function compactShownSearchFeedback(adapter, retentionDays = getFeedbackRetentionDays(adapter)) {
+    const result = adapter
+        .prepare(`
+        DELETE FROM search_feedback
+        WHERE feedback_kind = 'shown'
+          AND created_at < ?
+      `)
+        .run(cutoffIso(retentionDays));
+    return result.changes;
+}
+function sessionForInput(input, queryHash) {
+    if (input.session_id && input.session_id.trim().length > 0) {
+        return input.session_id;
+    }
+    if (input.feedback_kind === 'shown') {
+        return `anonymous:${queryHash}`;
+    }
+    return input.session_id ?? null;
+}
+function rankPositionForInput(input) {
+    if (input.feedback_kind === 'click' && input.clicked_result_rank !== undefined) {
+        const rank = input.clicked_result_rank ?? input.shown_index;
+        assertRank(rank, 'clicked_result_rank');
+        return rank;
+    }
+    assertRank(input.shown_index, 'shown_index');
+    return input.shown_index;
+}
+function questionTypeForInput(input) {
+    if (input.question_type && (0, question_type_js_1.isQuestionType)(input.question_type)) {
+        return input.question_type;
+    }
+    return (0, question_type_js_1.classifyQuestionType)(input.query);
+}
+function recordSearchFeedback(adapter, input) {
+    assertNonEmpty(input.result_id, 'result_id');
+    assertNonEmpty(input.query, 'query');
+    assertNonEmpty(input.result_source_type, 'result_source_type');
+    assertNonEmpty(input.result_source_id, 'result_source_id');
+    const queryHashHex = fullQueryHashHex(input.query);
+    const queryHash = fullQueryHashBuffer(input.query);
+    const queryHashShort = queryHashHex.slice(0, 16);
+    const sessionId = sessionForInput(input, queryHashShort);
+    const questionType = questionTypeForInput(input);
+    const rankPosition = rankPositionForInput(input);
+    const createdAt = input.created_at ?? nowIso();
+    const feedbackId = `search_feedback_${(0, node_crypto_1.randomUUID)()}`;
+    const metadataJson = canonicalJson({
+        clicked_result_rank: input.clicked_result_rank ?? null,
+        input_result_id: input.result_id,
+    });
+    return runTransaction(adapter, () => {
+        let deduped = false;
+        if (input.feedback_kind === 'shown') {
+            compactShownSearchFeedback(adapter);
+            if (sessionId) {
+                const deleted = adapter
+                    .prepare(`
+              DELETE FROM search_feedback
+              WHERE feedback_kind = 'shown'
+                AND session_id = ?
+                AND query_hash = ?
+                AND result_source_type = ?
+                AND result_source_id = ?
+            `)
+                    .run(sessionId, queryHash, input.result_source_type, input.result_source_id);
+                deduped = deleted.changes > 0;
+            }
+        }
+        adapter
+            .prepare(`
+          INSERT INTO search_feedback (
+            feedback_id, query, query_hash, question_type, result_source_type, result_source_id,
+            case_id, feedback_kind, rank_position, score_before, score_after, session_id,
+            actor, metadata_json, created_at, updated_at
+          )
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, 'system:search-feedback', ?, ?, NULL)
+        `)
+            .run(feedbackId, input.query, queryHash, questionType, input.result_source_type, input.result_source_id, input.result_case_id ?? null, input.feedback_kind, rankPosition, sessionId, metadataJson, createdAt);
+        return {
+            feedback_id: feedbackId,
+            query_hash: queryHashShort,
+            deduped,
+        };
+    });
+}
+function listSearchFeedback(adapter, options = {}) {
+    const retentionDays = getFeedbackRetentionDays(adapter);
+    const until = options.until ?? nowIso();
+    const since = options.since ?? cutoffIso(retentionDays, new Date(until));
+    const limit = options.limit ?? 10_000;
+    assertRank(limit, 'limit');
+    const rows = adapter
+        .prepare(`
+        SELECT
+          feedback_id,
+          query,
+          lower(hex(query_hash)) AS query_hash_hex,
+          question_type,
+          result_source_type,
+          result_source_id,
+          case_id,
+          feedback_kind,
+          rank_position,
+          score_before,
+          score_after,
+          session_id,
+          actor,
+          metadata_json,
+          created_at,
+          updated_at
+        FROM search_feedback
+        WHERE created_at >= ?
+          AND created_at <= ?
+        ORDER BY created_at ASC, feedback_id ASC
+        LIMIT ?
+      `)
+        .all(since, until, limit);
+    return rows;
+}
+//# sourceMappingURL=feedback-store.js.map

package/dist/search/question-type.d.ts

@@ -0,0 +1,5 @@
+export type QuestionType = 'correction' | 'artifact' | 'timeline' | 'status' | 'decision_reason' | 'how_to' | 'unknown';
+export declare const QUESTION_TYPES: readonly QuestionType[];
+export declare function classifyQuestionType(query: string): QuestionType;
+export declare function isQuestionType(value: string): value is QuestionType;
+//# sourceMappingURL=question-type.d.ts.map

package/dist/search/question-type.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUESTION_TYPES = void 0;
+exports.classifyQuestionType = classifyQuestionType;
+exports.isQuestionType = isQuestionType;
+exports.QUESTION_TYPES = [
+    'correction',
+    'artifact',
+    'timeline',
+    'status',
+    'decision_reason',
+    'how_to',
+    'unknown',
+];
+// Korean: patterns for classifyQuestionType() multilingual query routing.
+const CORRECTION_PATTERN = /\b(fix|revert|correct|correction|supersede|superseded|revise|revision|수정|되돌|정정|교정)\b/i; // Korean: keywords
+const ARTIFACT_PATTERN = /\b(file|doc|docs|document|image|video|pdf|drive|obsidian|attachment|artifact|파일|문서|이미지|영상|첨부|드라이브|옵시디언)\b/i; // Korean: keywords
+const TIMELINE_PATTERN = /\b(when|history|before|after|around|timeline|chronology|언제|이력|히스토리|전|후|즈음)\b|\bon\s+\d{4}(?:-\d{1,2})?(?:-\d{1,2})?\b|\b\d{4}-\d{1,2}-\d{1,2}\b/i; // Korean: keywords
+const STATUS_PATTERN = /\b(status|state|current|currently|now|latest|progress|blocked|done|상태|현재|최신|진행|진척)\b/i; // Korean: keywords
+const DECISION_REASON_PATTERN = /\b(why|reason|because|rationale|근거|이유|왜|때문)\b/i; // Korean: keywords
+const HOW_TO_PATTERN = /\b(how\s+to|how\s+do|setup|set\s+up|configure|configuration|install|설정|구성|어떻게)\b/i; // Korean: keywords
+function classifyQuestionType(query) {
+    const normalized = query.trim();
+    if (CORRECTION_PATTERN.test(normalized))
+        return 'correction';
+    if (ARTIFACT_PATTERN.test(normalized))
+        return 'artifact';
+    if (TIMELINE_PATTERN.test(normalized))
+        return 'timeline';
+    if (STATUS_PATTERN.test(normalized))
+        return 'status';
+    if (DECISION_REASON_PATTERN.test(normalized))
+        return 'decision_reason';
+    if (HOW_TO_PATTERN.test(normalized))
+        return 'how_to';
+    return 'unknown';
+}
+function isQuestionType(value) {
+    return exports.QUESTION_TYPES.includes(value);
+}
+//# sourceMappingURL=question-type.js.map

package/dist/search/ranker-features.d.ts

@@ -0,0 +1,23 @@
+import { type QuestionType } from './question-type.js';
+export declare const SEARCH_RANKER_FEATURE_SET_VERSION = "v1.0.0";
+export type RankerSourceType = 'decision' | 'event' | 'observation' | 'artifact' | 'connector_event';
+export declare const RANKER_SOURCE_TYPES: readonly RankerSourceType[];
+export interface RankerFeatureVector {
+    bm25_score: number;
+    vector_score: number;
+    case_rollup_score: number;
+    recency_score: number;
+    same_case_boost: number;
+    source_type_onehot: Record<RankerSourceType, number>;
+    question_type_onehot: Record<QuestionType, number>;
+}
+export interface RankerQueryMeta {
+    question_type?: QuestionType;
+    case_id?: string | null;
+}
+type FeatureRow = Record<string, unknown>;
+export declare function extractFeatures(row: FeatureRow, query: string, queryMeta?: RankerQueryMeta): RankerFeatureVector;
+export declare function serializeFeatures(vec: RankerFeatureVector): number[];
+export declare function featureSetVersion(): string;
+export {};
+//# sourceMappingURL=ranker-features.d.ts.map

package/dist/search/ranker-features.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RANKER_SOURCE_TYPES = exports.SEARCH_RANKER_FEATURE_SET_VERSION = void 0;
+exports.extractFeatures = extractFeatures;
+exports.serializeFeatures = serializeFeatures;
+exports.featureSetVersion = featureSetVersion;
+const question_type_js_1 = require("./question-type.js");
+exports.SEARCH_RANKER_FEATURE_SET_VERSION = 'v1.0.0';
+exports.RANKER_SOURCE_TYPES = [
+    'decision',
+    'event',
+    'observation',
+    'artifact',
+    'connector_event',
+];
+function numberValue(value, fallback = 0) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return value;
+}
+function stringValue(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    return String(value);
+}
+function sourceTypeKey(row) {
+    const sourceType = stringValue(row.source_type ?? row.result_source_type ?? row.kind ?? row.page_type);
+    switch (sourceType) {
+        case 'decision':
+            return 'decision';
+        case 'event':
+        case 'checkpoint':
+            return 'event';
+        case 'observation':
+        case 'case':
+            return 'observation';
+        case 'artifact':
+        case 'wiki_page':
+            return 'artifact';
+        case 'connector_event':
+        case 'standalone_connector_hit':
+            return 'connector_event';
+        default:
+            return null;
+    }
+}
+function zeroSourceOnehot() {
+    return {
+        decision: 0,
+        event: 0,
+        observation: 0,
+        artifact: 0,
+        connector_event: 0,
+    };
+}
+function zeroQuestionOnehot() {
+    return {
+        correction: 0,
+        artifact: 0,
+        timeline: 0,
+        status: 0,
+        decision_reason: 0,
+        how_to: 0,
+        unknown: 0,
+    };
+}
+function extractFeatures(row, query, queryMeta = {}) {
+    const sourceOnehot = zeroSourceOnehot();
+    const sourceType = sourceTypeKey(row);
+    if (sourceType) {
+        sourceOnehot[sourceType] = 1;
+    }
+    const questionType = queryMeta.question_type ?? (0, question_type_js_1.classifyQuestionType)(query);
+    const questionOnehot = zeroQuestionOnehot();
+    questionOnehot[questionType] = 1;
+    const rowCaseId = stringValue(row.case_id ?? row.result_case_id);
+    const queryCaseId = queryMeta.case_id ?? null;
+    return {
+        bm25_score: numberValue(row.bm25_score ?? row.bm25 ?? row.fts_score),
+        vector_score: numberValue(row.vector_score ?? row.similarity),
+        case_rollup_score: numberValue(row.case_rollup_score ?? row.retrieval_score ?? row.final_score ?? row.score),
+        recency_score: numberValue(row.recency_score),
+        same_case_boost: queryCaseId && rowCaseId && queryCaseId === rowCaseId ? 1 : 0,
+        source_type_onehot: sourceOnehot,
+        question_type_onehot: questionOnehot,
+    };
+}
+function serializeFeatures(vec) {
+    return [
+        vec.bm25_score,
+        vec.vector_score,
+        vec.case_rollup_score,
+        vec.recency_score,
+        vec.same_case_boost,
+        ...exports.RANKER_SOURCE_TYPES.map((sourceType) => vec.source_type_onehot[sourceType]),
+        ...question_type_js_1.QUESTION_TYPES.map((questionType) => vec.question_type_onehot[questionType]),
+    ];
+}
+function featureSetVersion() {
+    return exports.SEARCH_RANKER_FEATURE_SET_VERSION;
+}
+//# sourceMappingURL=ranker-features.js.map

package/dist/search/ranker-rescore.d.ts

@@ -0,0 +1,31 @@
+import type { RunResult } from '../db-adapter/statement.js';
+import { type SearchRankerModel } from './ranker-trainer.js';
+export type SearchRankerSkippedReason = 'feature_disabled' | 'no_active_model' | 'feature_set_mismatch' | 'quality_gate_failed' | 'insufficient_result_count' | 'llm_reranking_requested';
+export interface RankerRescoreAdapter {
+    prepare(sql: string): {
+        run(...params: unknown[]): RunResult;
+        get(...params: unknown[]): unknown;
+        all(...params: unknown[]): unknown[];
+    };
+}
+export interface RankerScoredFields {
+    ranker_score?: number;
+    score_before_ranker?: number;
+    final_score?: number;
+}
+export interface RescoreSearchResultsOptions<T> {
+    query: string;
+    results: T[];
+    featureEnabled?: boolean;
+    useReranking?: boolean;
+}
+export interface RescoreSearchResultsResult<T> {
+    results: Array<T & RankerScoredFields>;
+    model_id: string | null;
+    skipped_reason?: SearchRankerSkippedReason;
+}
+export declare function loadActiveSearchRankerModel(adapter: RankerRescoreAdapter): SearchRankerModel | null;
+export declare function isSearchRankerEnabled(adapter: RankerRescoreAdapter): boolean;
+export declare function rescoreSearchResults<T extends Record<string, unknown>>(adapter: RankerRescoreAdapter, options: RescoreSearchResultsOptions<T>): RescoreSearchResultsResult<T>;
+export declare function logisticScoreForRow(model: SearchRankerModel, row: Record<string, unknown>, query: string): number;
+//# sourceMappingURL=ranker-rescore.d.ts.map