kiokuko-dsh 0.1.0

package/dist/gateway/agent-service.d.ts

@@ -0,0 +1,72 @@
+import type { SqliteDatabase } from '../db/adapter.js';
+import { type AppendAck, type RunStatus } from '../ledger/types.js';
+import type { AkinatorQuestion, AkinatorResult, TaskProfile } from '../akinator/types.js';
+import type { LedgerEventsPage, LedgerRunView, LedgerRunsPage } from '../ledger/query.js';
+declare const TERMINAL_STATUS_VALUES: readonly ["completed", "failed", "cancelled", "interrupted"];
+type TerminalStatus = (typeof TERMINAL_STATUS_VALUES)[number];
+type GatewayIntakeResponse = {
+    runId: string;
+    runStatus: RunStatus;
+    intakeSessionId: string;
+    intakeStatus: AkinatorResult['status'];
+    intake: {
+        status: AkinatorResult['status'];
+        sessionId: string;
+        question: AkinatorQuestion | null;
+    };
+    question: AkinatorQuestion | null;
+    currentQuestion: AkinatorQuestion | null;
+    missingFields: Array<keyof TaskProfile>;
+    recommendedTags: string[];
+    taskProfile: TaskProfile;
+    profileHash: string | null;
+    context: null;
+    untrusted: true;
+};
+type GatewayAppendResponse = AppendAck & {
+    runStatus: RunStatus;
+    untrusted: true;
+};
+type GatewayCloseResponse = AppendAck & {
+    status: TerminalStatus;
+    runStatus: TerminalStatus;
+    untrusted: true;
+};
+export interface AgentGatewayServiceOptions {
+    readonly now?: () => string;
+    readonly home?: string;
+    readonly runIdFactory?: () => string;
+    readonly sessionIdFactory?: () => string;
+    readonly eventIdFactory?: () => string;
+}
+interface AgentGatewayAnswerOptions {
+    readonly assertBeforeAnswer?: () => void;
+}
+export declare class AgentGatewayService {
+    private readonly database;
+    private readonly options;
+    constructor(database: SqliteDatabase, options?: AgentGatewayServiceOptions);
+    openRun(input: unknown): GatewayIntakeResponse;
+    answerIntake(input: unknown, options?: AgentGatewayAnswerOptions): GatewayIntakeResponse;
+    appendEvents(input: unknown): GatewayAppendResponse;
+    closeRun(input: unknown): GatewayCloseResponse;
+    listRuns(input: unknown): LedgerRunsPage & {
+        untrusted: true;
+    };
+    readRun(input: unknown): LedgerRunView;
+    readIntake(input: unknown): GatewayIntakeResponse;
+    listEvents(input: unknown): LedgerEventsPage & {
+        untrusted: true;
+    };
+    private intakeResponse;
+    private lifecycleEvent;
+    private ledgerStore;
+    private requireRun;
+    private scopedOperation;
+    private currentTime;
+    private nextRunId;
+    private nextSessionId;
+    private nextEventId;
+}
+export type { GatewayAppendResponse, GatewayCloseResponse, GatewayIntakeResponse, };
+//# sourceMappingURL=agent-service.d.ts.map

package/dist/gateway/agent-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-service.d.ts","sourceRoot":"","sources":["../../src/gateway/agent-service.ts"],"names":[],"mappings":"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"}

package/dist/gateway/agent-service.js

@@ -0,0 +1,594 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { withImmediateTransaction } from '../db/transaction.js';
+import { KiokukoError } from '../errors.js';
+import { executeIdempotentInTransaction } from '../server/idempotency.js';
+import { sanitizeAnswer, sanitizeEvent, sanitizeRunMetadata, sanitizeTask } from '../ledger/redaction.js';
+import { validateEventBatch, validateTimestamp } from '../ledger/validate.js';
+import { CAPTURE_PROFILES, COVERAGE_LEVELS, MAX_BATCH_EVENTS, MAX_ID_LENGTH, } from '../ledger/types.js';
+import { LedgerStore } from '../ledger/store.js';
+import { listLedgerEvents, listLedgerRuns, readLedgerRun } from '../ledger/query.js';
+import { AKINATOR_POLICY_VERSION, evaluateProfile, profileHash } from '../akinator/domain.js';
+import { answerAkinatorInTransaction, startAkinatorInTransaction, } from '../akinator/service.js';
+import { finalizeRunIntakeLink, insertRunIntakeLink, markRunIntakeProfileSource, readAkinatorSession, readRunIntakeLink, } from '../akinator/store.js';
+import { assertCapabilityCatalogBinding, bindCapabilityCatalog, capabilityCatalogDigest, } from '../akinator/capability-binding.js';
+const PROFILE_FIELDS = ['taskType', 'target', 'expected', 'constraints'];
+const INTAKE_EVENT_TYPES = new Set([
+    'intake.started', 'intake.answered', 'intake.ready', 'intake.exhausted',
+]);
+const TERMINAL_STATUS_VALUES = ['completed', 'failed', 'cancelled', 'interrupted'];
+const CONTROL_CHARACTERS = /\p{Cc}/u;
+function validation() {
+    throw new KiokukoError('VALIDATION_ERROR', 'Invalid gateway request');
+}
+function conflict(message = 'Gateway operation conflicts with the current run state') {
+    throw new KiokukoError('CONFLICT', message);
+}
+function notFound() {
+    throw new KiokukoError('NOT_FOUND', 'Ledger run not found');
+}
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    try {
+        const prototype = Object.getPrototypeOf(value);
+        return prototype === Object.prototype || prototype === null;
+    }
+    catch {
+        return false;
+    }
+}
+function isCanonicalArrayIndex(value) {
+    if (value === '0')
+        return true;
+    if (!/^[1-9]\d*$/u.test(value))
+        return false;
+    const index = Number(value);
+    return Number.isSafeInteger(index) && index < 4_294_967_295 && String(index) === value;
+}
+function assertJsonValue(value, ancestors = new WeakSet()) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            validation();
+        return;
+    }
+    if (typeof value !== 'object' || ancestors.has(value))
+        validation();
+    ancestors.add(value);
+    try {
+        let keys;
+        try {
+            keys = Reflect.ownKeys(value);
+        }
+        catch {
+            validation();
+        }
+        if (Array.isArray(value)) {
+            for (const key of keys) {
+                if (typeof key !== 'string' || (key !== 'length' && !isCanonicalArrayIndex(key)))
+                    validation();
+            }
+            for (const item of value)
+                assertJsonValue(item, ancestors);
+        }
+        else {
+            if (!isPlainObject(value))
+                validation();
+            for (const key of keys)
+                if (typeof key !== 'string')
+                    validation();
+            for (const key of Object.keys(value))
+                assertJsonValue(value[key], ancestors);
+        }
+    }
+    catch (error) {
+        if (error instanceof KiokukoError)
+            throw error;
+        validation();
+    }
+    finally {
+        ancestors.delete(value);
+    }
+}
+function object(value) {
+    if (!isPlainObject(value))
+        validation();
+    return value;
+}
+function jsonObject(value) {
+    assertJsonValue(value);
+    if (!isPlainObject(value))
+        validation();
+    return value;
+}
+function jsonResult(value) {
+    assertJsonValue(value);
+    return value;
+}
+function typedResult(value) {
+    return value;
+}
+function executeGateway(database, input, operation) {
+    return typedResult(executeIdempotentInTransaction(database, input, () => jsonResult(operation())));
+}
+function knownFields(value, allowed) {
+    const set = new Set(allowed);
+    if (Object.keys(value).some((field) => !set.has(field)))
+        validation();
+}
+function boundedString(value, max) {
+    if (typeof value !== 'string' || value.trim().length === 0 || value.length > max || CONTROL_CHARACTERS.test(value))
+        validation();
+    return value;
+}
+function enumValue(value, allowed) {
+    if (typeof value !== 'string' || !allowed.includes(value))
+        validation();
+    return value;
+}
+function nullableString(value, max) {
+    if (value === null)
+        return null;
+    return boundedString(value, max);
+}
+function optionalString(value, max) {
+    if (value === undefined)
+        return undefined;
+    return boundedString(value, max);
+}
+function profileHints(value) {
+    if (value === undefined)
+        return { taskType: null, target: null, expected: null, constraints: null };
+    const input = object(value);
+    knownFields(input, PROFILE_FIELDS);
+    const taskType = input.taskType === undefined || input.taskType === null
+        ? null
+        : enumValue(input.taskType, ['build', 'debug', 'research', 'review', 'devops', 'writing', 'analysis']);
+    const target = input.target === undefined ? null : nullableString(input.target, 16 * 1024);
+    const expected = input.expected === undefined ? null : nullableString(input.expected, 16 * 1024);
+    const constraints = input.constraints === undefined ? null : nullableString(input.constraints, 16 * 1024);
+    return { taskType, target, expected, constraints };
+}
+function normalizeOpenRequest(value) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['apiVersion', 'workspace', 'client', 'task', 'captureProfile', 'coverage', 'metadata', 'capabilities', 'parentRunId', 'startedAt']);
+    if (input.apiVersion !== '1')
+        validation();
+    const workspace = boundedString(input.workspace, 16 * 1024);
+    const clientInput = object(input.client);
+    knownFields(clientInput, ['kind', 'version', 'sessionId']);
+    const client = {
+        kind: boundedString(clientInput.kind, MAX_ID_LENGTH),
+        ...(clientInput.version === undefined ? {} : { version: boundedString(clientInput.version, MAX_ID_LENGTH) }),
+        ...(clientInput.sessionId === undefined ? {} : { sessionId: boundedString(clientInput.sessionId, MAX_ID_LENGTH) }),
+    };
+    const taskInput = object(input.task);
+    knownFields(taskInput, ['title', 'query', 'profileHints']);
+    const task = {
+        title: boundedString(taskInput.title, 16 * 1024),
+        query: boundedString(taskInput.query, 16 * 1024),
+        profileHints: profileHints(taskInput.profileHints),
+    };
+    const coverageInput = object(input.coverage);
+    const coverageFields = ['run', 'tool', 'command', 'file', 'approval'];
+    knownFields(coverageInput, coverageFields);
+    const coverage = {};
+    for (const field of coverageFields)
+        coverage[field] = enumValue(coverageInput[field], COVERAGE_LEVELS);
+    const metadataValue = input.metadata === undefined ? {} : object(input.metadata);
+    assertJsonValue(metadataValue);
+    const metadata = metadataValue;
+    const startedAt = optionalString(input.startedAt, 64);
+    if (startedAt !== undefined)
+        validateTimestamp(startedAt, 'startedAt');
+    return {
+        apiVersion: '1',
+        workspace,
+        client,
+        task,
+        captureProfile: enumValue(input.captureProfile, CAPTURE_PROFILES),
+        coverage,
+        metadata,
+        ...(input.capabilities === undefined ? {} : { capabilities: input.capabilities }),
+        ...(input.parentRunId === undefined ? {} : { parentRunId: boundedString(input.parentRunId, MAX_ID_LENGTH) }),
+        ...(startedAt === undefined ? {} : { startedAt }),
+    };
+}
+function operationEnvelope(value) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['idempotencyKey', 'request']);
+    return {
+        idempotencyKey: boundedString(input.idempotencyKey, 256),
+        request: input.request,
+    };
+}
+function runEnvelope(value) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['runId', 'idempotencyKey', 'request']);
+    return {
+        runId: boundedString(input.runId, MAX_ID_LENGTH),
+        idempotencyKey: boundedString(input.idempotencyKey, 256),
+        request: input.request,
+    };
+}
+function readRunInput(value) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['runId']);
+    return { runId: boundedString(input.runId, MAX_ID_LENGTH) };
+}
+function answerRequest(value, workspace) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['apiVersion', 'questionId', 'value', 'capabilities']);
+    if (input.apiVersion !== '1')
+        validation();
+    const questionId = boundedString(input.questionId, MAX_ID_LENGTH);
+    if (typeof input.value !== 'string')
+        validation();
+    const sanitized = sanitizeAnswer({ apiVersion: '1', questionId, value: input.value }, { workspace });
+    if (typeof sanitized.value.value !== 'string')
+        validation();
+    const normalized = sanitized.value;
+    const answer = { apiVersion: '1', questionId: normalized.questionId, value: normalized.value };
+    const capabilities = input.capabilities;
+    return {
+        value: answer,
+        ...(capabilities === undefined ? {} : { capabilities }),
+        hashRequest: jsonObject({
+            ...answer,
+            capabilityCatalogDigest: capabilityCatalogDigest(capabilities),
+        }),
+    };
+}
+function sanitizeEventArray(value, workspace) {
+    if (!Array.isArray(value))
+        validation();
+    if (value.length === 0 || value.length > MAX_BATCH_EVENTS)
+        validation();
+    const validated = validateEventBatch({ events: value });
+    return validated.map((event) => sanitizeEvent(event, { workspace }).value);
+}
+function eventsRequest(value, workspace) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['apiVersion', 'events']);
+    if (input.apiVersion !== '1')
+        validation();
+    const events = sanitizeEventArray(input.events, workspace);
+    return { events, hashRequest: jsonObject({ apiVersion: '1', events }) };
+}
+function closeRequest(value, workspace) {
+    assertJsonValue(value);
+    const input = object(value);
+    knownFields(input, ['apiVersion', 'status', 'events']);
+    if (input.apiVersion !== '1')
+        validation();
+    const status = enumValue(input.status, TERMINAL_STATUS_VALUES);
+    const events = input.events === undefined ? undefined : sanitizeEventArray(input.events, workspace);
+    return {
+        status,
+        ...(events === undefined ? {} : { events }),
+        hashRequest: jsonObject({
+            apiVersion: '1',
+            status,
+            ...(events === undefined ? {} : { events }),
+        }),
+    };
+}
+function sourceMap(request, profile) {
+    const sources = {};
+    const hints = request.task.profileHints;
+    for (const field of PROFILE_FIELDS) {
+        const supplied = hints[field];
+        if (supplied !== null && supplied !== undefined) {
+            sources[field] = 'client_supplied';
+        }
+        else if (field === 'taskType' && profile.taskType !== null) {
+            sources[field] = 'inferred';
+        }
+    }
+    return sources;
+}
+function appendResponse(ack, runStatus) {
+    return { ...ack, runStatus, untrusted: true };
+}
+export class AgentGatewayService {
+    database;
+    options;
+    constructor(database, options = {}) {
+        this.database = database;
+        this.options = options;
+    }
+    openRun(input) {
+        const envelope = operationEnvelope(input);
+        const request = normalizeOpenRequest(envelope.request);
+        const task = sanitizeTask(request.task, { workspace: request.workspace, ...(this.options.home === undefined ? {} : { home: this.options.home }) }).value;
+        const metadata = sanitizeRunMetadata(bindCapabilityCatalog(request.metadata, request.capabilities), { workspace: request.workspace, ...(this.options.home === undefined ? {} : { home: this.options.home }) }).value;
+        const client = request.client;
+        const hashRequest = jsonObject({
+            apiVersion: '1',
+            workspace: request.workspace,
+            client,
+            task,
+            captureProfile: request.captureProfile,
+            coverage: request.coverage,
+            metadata,
+            ...(request.parentRunId === undefined ? {} : { parentRunId: request.parentRunId }),
+            ...(request.startedAt === undefined ? {} : { startedAt: request.startedAt }),
+        });
+        const now = this.currentTime();
+        return withImmediateTransaction(this.database, () => executeGateway(this.database, { scope: 'agent.run.open', key: envelope.idempotencyKey, request: hashRequest, createdAt: now }, () => {
+            const runId = this.nextRunId();
+            const sessionId = this.nextSessionId();
+            const store = this.ledgerStore(request.workspace);
+            const run = store.createRunInTransaction({
+                runId,
+                workspace: request.workspace,
+                protocolVersion: '1',
+                client,
+                captureProfile: request.captureProfile,
+                coverage: request.coverage,
+                task,
+                metadata,
+                ...(request.parentRunId === undefined ? {} : { parentRunId: request.parentRunId }),
+                ...(request.startedAt === undefined ? {} : { startedAt: request.startedAt }),
+            }, now);
+            const result = startAkinatorInTransaction(this.database, {
+                workspace: request.workspace,
+                task: task.query,
+                profileHints: task.profileHints,
+                now,
+                idFactory: () => sessionId,
+            });
+            insertRunIntakeLink(this.database, {
+                runId,
+                sessionId,
+                workspace: request.workspace,
+                policyVersion: AKINATOR_POLICY_VERSION,
+                profileSchemaVersion: 1,
+                profileSources: sourceMap(request, result.session.profile),
+                initialProfileHash: null,
+                recommendedTags: result.recommendedTags,
+                linkedAt: now,
+                finalizedAt: null,
+            });
+            const lifecycle = [this.lifecycleEvent('intake.started', {
+                    intakeSessionId: sessionId,
+                    status: result.status,
+                    missingFields: result.missingFields,
+                }, now)];
+            let finalRun = run;
+            if (result.status === 'ready' || result.status === 'exhausted') {
+                lifecycle.push(this.lifecycleEvent(result.status === 'ready' ? 'intake.ready' : 'intake.exhausted', {
+                    profile: result.session.profile,
+                    profileHash: profileHash(result.session.profile),
+                    recommendedTags: result.recommendedTags,
+                    missingFields: result.missingFields,
+                }, now));
+                lifecycle.push(this.lifecycleEvent('run.started', {
+                    intakeStatus: result.status,
+                    profileHash: profileHash(result.session.profile),
+                    recommendedTags: result.recommendedTags,
+                }, now));
+            }
+            store.appendBatchInTransaction(runId, { events: lifecycle });
+            if (result.status === 'ready' || result.status === 'exhausted') {
+                finalizeRunIntakeLink(this.database, {
+                    workspace: request.workspace,
+                    runId,
+                    profileHash: profileHash(result.session.profile),
+                    recommendedTags: result.recommendedTags,
+                    finalizedAt: now,
+                });
+                finalRun = store.updateRunStatusInTransaction(runId, 'active', now);
+            }
+            return this.intakeResponse(runId, finalRun.status, result);
+        }));
+    }
+    answerIntake(input, options = {}) {
+        const envelope = runEnvelope(input);
+        const initialRun = this.requireRun(envelope.runId);
+        const request = answerRequest(envelope.request, initialRun.workspace);
+        assertCapabilityCatalogBinding(initialRun.metadata, request.capabilities);
+        const now = this.currentTime();
+        return withImmediateTransaction(this.database, () => {
+            options.assertBeforeAnswer?.();
+            return executeGateway(this.database, { scope: this.scopedOperation('answer', envelope.runId), key: envelope.idempotencyKey, request: request.hashRequest, createdAt: now }, () => {
+                const run = this.requireRun(envelope.runId);
+                const link = readRunIntakeLink(this.database, { workspace: run.workspace, runId: run.runId });
+                const mutation = answerAkinatorInTransaction(this.database, {
+                    workspace: run.workspace,
+                    sessionId: link.sessionId,
+                    questionId: request.value.questionId,
+                    value: request.value.value,
+                    now,
+                });
+                if (mutation.replayed) {
+                    const currentRun = this.requireRun(run.runId);
+                    return this.intakeResponse(run.runId, currentRun.status, mutation.result);
+                }
+                if (run.status !== 'intake')
+                    conflict('Run is not waiting for intake');
+                markRunIntakeProfileSource(this.database, {
+                    workspace: run.workspace,
+                    runId: run.runId,
+                    field: request.value.questionId,
+                });
+                const events = [this.lifecycleEvent('intake.answered', {
+                        questionId: request.value.questionId,
+                        value: request.value.value,
+                    }, now)];
+                if (mutation.result.status === 'ready' || mutation.result.status === 'exhausted') {
+                    events.push(this.lifecycleEvent(mutation.result.status === 'ready' ? 'intake.ready' : 'intake.exhausted', {
+                        profile: mutation.result.session.profile,
+                        profileHash: profileHash(mutation.result.session.profile),
+                        recommendedTags: mutation.result.recommendedTags,
+                        missingFields: mutation.result.missingFields,
+                    }, now));
+                    events.push(this.lifecycleEvent('run.started', {
+                        intakeStatus: mutation.result.status,
+                        profileHash: profileHash(mutation.result.session.profile),
+                        recommendedTags: mutation.result.recommendedTags,
+                    }, now));
+                }
+                this.ledgerStore(run.workspace).appendBatchInTransaction(run.runId, { events });
+                let finalRun = this.requireRun(run.runId);
+                if (mutation.result.status === 'ready' || mutation.result.status === 'exhausted') {
+                    finalizeRunIntakeLink(this.database, {
+                        workspace: run.workspace,
+                        runId: run.runId,
+                        profileHash: profileHash(mutation.result.session.profile),
+                        recommendedTags: mutation.result.recommendedTags,
+                        finalizedAt: now,
+                    });
+                    finalRun = this.ledgerStore(run.workspace).updateRunStatusInTransaction(run.runId, 'active', now);
+                }
+                return this.intakeResponse(run.runId, finalRun.status, mutation.result);
+            });
+        });
+    }
+    appendEvents(input) {
+        const envelope = runEnvelope(input);
+        const initialRun = this.requireRun(envelope.runId);
+        const request = eventsRequest(envelope.request, initialRun.workspace);
+        const now = this.currentTime();
+        return withImmediateTransaction(this.database, () => executeGateway(this.database, { scope: this.scopedOperation('events', envelope.runId), key: envelope.idempotencyKey, request: request.hashRequest, createdAt: now }, () => {
+            const run = this.requireRun(envelope.runId);
+            if (TERMINAL_STATUS_VALUES.includes(run.status)) {
+                conflict('Cannot append events to a terminal run');
+            }
+            if (run.status === 'intake' && request.events.some((event) => !INTAKE_EVENT_TYPES.has(event.eventType))) {
+                conflict('Work events are not allowed during intake');
+            }
+            const ack = this.ledgerStore(run.workspace).appendBatchInTransaction(run.runId, { events: request.events });
+            return appendResponse(ack, run.status);
+        }));
+    }
+    closeRun(input) {
+        const envelope = runEnvelope(input);
+        const initialRun = this.requireRun(envelope.runId);
+        const request = closeRequest(envelope.request, initialRun.workspace);
+        const now = this.currentTime();
+        return withImmediateTransaction(this.database, () => executeGateway(this.database, { scope: this.scopedOperation('close', envelope.runId), key: envelope.idempotencyKey, request: request.hashRequest, createdAt: now }, () => {
+            const run = this.requireRun(envelope.runId);
+            if (run.status !== 'active')
+                conflict('Only active runs can be closed');
+            const store = this.ledgerStore(run.workspace);
+            const ack = store.appendBatchInTransaction(run.runId, {
+                events: [
+                    ...(request.events ?? []),
+                    this.lifecycleEvent('run.closed', { status: request.status }, now),
+                ],
+            });
+            store.updateRunStatusInTransaction(run.runId, request.status, now);
+            return { ...ack, status: request.status, runStatus: request.status, untrusted: true };
+        }));
+    }
+    listRuns(input) {
+        assertJsonValue(input);
+        const page = listLedgerRuns(this.database, input);
+        return { ...page, untrusted: true };
+    }
+    readRun(input) {
+        const { runId } = readRunInput(input);
+        const run = this.requireRun(runId);
+        return readLedgerRun(this.database, { workspace: run.workspace, runId });
+    }
+    readIntake(input) {
+        const { runId } = readRunInput(input);
+        const run = this.requireRun(runId);
+        const link = readRunIntakeLink(this.database, { workspace: run.workspace, runId });
+        const session = readAkinatorSession(this.database, { workspace: run.workspace, sessionId: link.sessionId });
+        const evaluation = evaluateProfile(session.profile, session.questionCount);
+        const result = {
+            status: evaluation.status,
+            session,
+            question: evaluation.question,
+            missingFields: evaluation.missingFields,
+            recommendedTags: evaluation.recommendedTags,
+        };
+        return this.intakeResponse(runId, run.status, result, link.initialProfileHash);
+    }
+    listEvents(input) {
+        assertJsonValue(input);
+        const value = object(input);
+        knownFields(value, ['runId', 'after', 'type', 'limit']);
+        const runId = boundedString(value.runId, MAX_ID_LENGTH);
+        const run = this.requireRun(runId);
+        const page = listLedgerEvents(this.database, {
+            runId,
+            workspace: run.workspace,
+            ...(value.after === undefined ? {} : { after: value.after }),
+            ...(value.type === undefined ? {} : { type: value.type }),
+            ...(value.limit === undefined ? {} : { limit: value.limit }),
+        });
+        return { ...page, untrusted: true };
+    }
+    intakeResponse(runId, runStatus, result, finalizedHash) {
+        const finalized = finalizedHash !== undefined
+            ? finalizedHash !== null
+            : (runStatus === 'active' && (result.status === 'ready' || result.status === 'exhausted'));
+        const currentProfileHash = profileHash(result.session.profile);
+        const finalizedProfileHash = finalized ? (finalizedHash ?? currentProfileHash) : null;
+        const question = result.question;
+        return {
+            runId,
+            runStatus,
+            intakeSessionId: result.session.id,
+            intakeStatus: result.status,
+            intake: { status: result.status, sessionId: result.session.id, question },
+            question,
+            currentQuestion: question,
+            missingFields: [...result.missingFields],
+            recommendedTags: [...result.recommendedTags],
+            taskProfile: { ...result.session.profile },
+            profileHash: finalizedProfileHash,
+            context: null,
+            untrusted: true,
+        };
+    }
+    lifecycleEvent(eventType, payload, occurredAt) {
+        return {
+            eventId: this.nextEventId(),
+            eventType,
+            actor: 'kiokuko-gateway',
+            occurredAt,
+            payload: jsonResult(payload),
+        };
+    }
+    ledgerStore(workspace) {
+        return new LedgerStore(this.database, {
+            now: () => this.currentTime(),
+            workspace,
+            ...(this.options.home === undefined ? {} : { home: this.options.home }),
+        });
+    }
+    requireRun(runId) {
+        const run = new LedgerStore(this.database).readRun(runId);
+        if (!run)
+            return notFound();
+        return run;
+    }
+    scopedOperation(operation, runId) {
+        const digest = createHash('sha256').update(runId, 'utf8').digest('hex').slice(0, 32);
+        return `agent.${operation}.${digest}`;
+    }
+    currentTime() {
+        return this.options.now?.() ?? new Date().toISOString();
+    }
+    nextRunId() {
+        return this.options.runIdFactory?.() ?? randomUUID();
+    }
+    nextSessionId() {
+        return this.options.sessionIdFactory?.() ?? randomUUID();
+    }
+    nextEventId() {
+        return this.options.eventIdFactory?.() ?? randomUUID();
+    }
+}
+//# sourceMappingURL=agent-service.js.map