@minionry/minion 0.7.36

package/dist/server/services/sdk/agents.js

@@ -0,0 +1,557 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { randomBytes } from 'node:crypto';
+import { ModelProfileStore } from '../../engines/credentials/model-profiles.js';
+import { ENGINE_EFFORT_LEVELS, engineForModel, parseProfileModelValue } from '../../engines/EngineEvent.js';
+import { hermesAvailability, MINIMUM_HERMES_APP_RUN_VERSION } from '../../engines/hermes/hermes-provision.js';
+import { getQualityEffortLevel, getQualityEngine, getQualityFastMode, getQualityModel } from '../settings.js';
+import { resolveAppOwnedModel } from './app-endpoints.js';
+import { logAppAudit } from './audit.js';
+import { deregisterLiveRun, findLiveRunByTab, listLiveSubscriptions, registerLiveRun } from './live-registry.js';
+import { SdkMethodError } from './registry.js';
+import { dropSubscription } from './revoke.js';
+import { deriveRunProfile } from './run-profile.js';
+import { recordSdkStreamEvent } from './streams.js';
+export const MAX_SYSTEM_PROMPT_CHARS = 32_000;
+export const MAX_RUN_TURNS = 50;
+export const MAX_RUN_SECONDS = 1_800;
+export const DEFAULT_RUN_TURNS = 20;
+export const DEFAULT_RUN_SECONDS = 900;
+export const AGENT_RUN_MODEL_SELECTIONS = ['quality'];
+let agentHost = null;
+export function setSdkAgentHost(host) {
+    agentHost = host;
+}
+export function resetSdkAgentHost() {
+    agentHost = null;
+}
+const runsById = new Map();
+const MAX_TERMINAL_RECORDS = 200;
+function pruneTerminalRecords() {
+    let excess = runsById.size - MAX_TERMINAL_RECORDS;
+    if (excess <= 0)
+        return;
+    for (const [runId, record] of runsById) {
+        if (excess <= 0)
+            break;
+        if (record.outcome) {
+            runsById.delete(runId);
+            excess -= 1;
+        }
+    }
+}
+const sessionsByTab = new Map();
+export function resetSdkAgentRuns() {
+    runsById.clear();
+    sessionsByTab.clear();
+}
+function runStreamIdentity(record) {
+    return {
+        requestId: record.requestId,
+        appId: record.appId,
+        spaceKey: record.spaceKey,
+        kind: 'agents.run',
+    };
+}
+function emitRunEvent(record, event, payload) {
+    const seq = recordSdkStreamEvent(runStreamIdentity(record), event, payload);
+    const data = { requestId: record.requestId, event, payload, seq };
+    record.broadcast({ type: 'sdkEvent', tabId: record.bridgeTabId, data });
+}
+function settleRun(record, outcome) {
+    if (record.outcome)
+        return;
+    const final = record.cancelledBy
+        ? { status: 'cancelled', text: outcome.text }
+        : outcome;
+    record.outcome = final;
+    deregisterLiveRun(record.runId);
+    emitRunEvent(record, 'status', { status: final.status });
+    const waiters = record.waiters.splice(0);
+    for (const waiter of waiters)
+        waiter(final);
+    logAppAudit({
+        appId: record.appId,
+        origin: record.origin,
+        method: 'agents.run.end',
+        decision: 'allow',
+        requestId: record.requestId,
+        spaceKey: record.spaceKey,
+        reason: `run ${record.runId} ${final.status}${record.cancelledBy ? ` (${record.cancelledBy})` : ''}${runAuditSuffix(record)}`,
+    });
+}
+function runAuditSuffix(record) {
+    return `${record.modelValue ? ` target=${record.modelValue}` : ''}${record.turn > 1 ? ` turn=${record.turn}` : ''}`;
+}
+function cancelRunRecord(record, cause) {
+    if (record.outcome)
+        return;
+    if (!record.cancelledBy)
+        record.cancelledBy = cause;
+    record.cancelRun();
+}
+const RUN_PARAMS_SHAPE = '{ prompt, title?, model?, modelSelection?, systemPrompt?, budget?: { maxTurns?, maxSeconds? }, sessionId? }';
+const RUN_PARAM_KEYS = new Set([
+    'prompt',
+    'title',
+    'model',
+    'modelSelection',
+    'systemPrompt',
+    'budget',
+    'sessionId',
+]);
+const BUDGET_KEYS = new Set(['maxTurns', 'maxSeconds']);
+function badRequest(message) {
+    return new SdkMethodError('BAD_REQUEST', message);
+}
+function displayValue(value) {
+    const cleaned = value.replace(/[\u0000-\u001f\u007f]/g, ' ');
+    return cleaned.length > 120 ? `${cleaned.slice(0, 119)}…` : cleaned;
+}
+function refuseUnknownKeys(raw, allowed, what, shape) {
+    const unknown = Object.keys(raw).filter((key) => !allowed.has(key));
+    if (unknown.length === 0)
+        return;
+    const named = unknown.slice(0, 5).map((key) => `'${displayValue(key)}'`).join(', ');
+    throw badRequest(`${what}: unknown param${unknown.length > 1 ? 's' : ''} ${named}${unknown.length > 5 ? ', …' : ''} — expected ${shape}`);
+}
+function parseCeiling(raw, field, max, fallback) {
+    if (raw === undefined)
+        return fallback;
+    if (typeof raw !== 'number' || !Number.isSafeInteger(raw) || raw <= 0) {
+        throw badRequest(`agents.run budget.${field} must be a positive integer when present`);
+    }
+    return Math.min(raw, max);
+}
+function parseBudget(raw) {
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        throw badRequest('agents.run budget must be an object { maxTurns?, maxSeconds? }');
+    }
+    const budget = raw;
+    refuseUnknownKeys(budget, BUDGET_KEYS, 'agents.run budget', '{ maxTurns?, maxSeconds? }');
+    return {
+        maxTurns: parseCeiling(budget.maxTurns, 'maxTurns', MAX_RUN_TURNS, DEFAULT_RUN_TURNS),
+        maxSeconds: parseCeiling(budget.maxSeconds, 'maxSeconds', MAX_RUN_SECONDS, DEFAULT_RUN_SECONDS),
+    };
+}
+function optionalString(raw, field, nonEmpty) {
+    const value = raw[field];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || (nonEmpty && value === '')) {
+        throw badRequest(`agents.run ${field} must be a ${nonEmpty ? 'non-empty ' : ''}string when present`);
+    }
+    return value;
+}
+function parseSystemPrompt(raw) {
+    if (raw === undefined)
+        return undefined;
+    if (typeof raw !== 'string' || raw.length > MAX_SYSTEM_PROMPT_CHARS) {
+        throw badRequest(`agents.run systemPrompt must be a string of at most ${MAX_SYSTEM_PROMPT_CHARS} characters`);
+    }
+    return raw;
+}
+function parseModelSelection(raw) {
+    if (raw === undefined)
+        return undefined;
+    const name = AGENT_RUN_MODEL_SELECTIONS.find((known) => known === raw);
+    if (!name) {
+        const known = AGENT_RUN_MODEL_SELECTIONS.map((value) => `'${value}'`).join(', ');
+        throw badRequest(`agents.run modelSelection must be one of ${known} when present`);
+    }
+    return name;
+}
+function assertRunFieldsCombine({ model, modelSelection, systemPrompt, budget, sessionId }) {
+    const choosesModel = model !== undefined || modelSelection !== undefined;
+    if (sessionId !== undefined && (choosesModel || systemPrompt !== undefined || budget !== undefined)) {
+        throw badRequest('agents.run with sessionId continues that session on its own model, systemPrompt and budget — omit model, modelSelection, systemPrompt and budget');
+    }
+    if (model !== undefined && modelSelection !== undefined) {
+        throw badRequest('agents.run takes model or modelSelection, not both');
+    }
+    if (model === undefined && (systemPrompt !== undefined || budget !== undefined)) {
+        throw badRequest('agents.run systemPrompt and budget apply only to a run on an app-registered model — pass model');
+    }
+}
+function parseRunParams(params) {
+    if (typeof params !== 'object' || params === null || Array.isArray(params)) {
+        throw badRequest(`agents.run requires params ${RUN_PARAMS_SHAPE}`);
+    }
+    const raw = params;
+    refuseUnknownKeys(raw, RUN_PARAM_KEYS, 'agents.run', RUN_PARAMS_SHAPE);
+    if (typeof raw.prompt !== 'string' || raw.prompt.trim() === '') {
+        throw badRequest('agents.run requires a non-empty string prompt');
+    }
+    const title = optionalString(raw, 'title', false);
+    const model = optionalString(raw, 'model', true);
+    const modelSelection = parseModelSelection(raw.modelSelection);
+    const sessionId = optionalString(raw, 'sessionId', true);
+    const systemPrompt = parseSystemPrompt(raw.systemPrompt);
+    const budget = raw.budget === undefined ? undefined : parseBudget(raw.budget);
+    assertRunFieldsCombine({ model, modelSelection, systemPrompt, budget, sessionId });
+    return {
+        prompt: raw.prompt,
+        ...(title !== undefined ? { title } : {}),
+        ...(model !== undefined ? { model } : {}),
+        ...(modelSelection !== undefined ? { modelSelection } : {}),
+        ...(systemPrompt !== undefined ? { systemPrompt } : {}),
+        ...(budget !== undefined ? { budget } : {}),
+        ...(sessionId !== undefined ? { sessionId } : {}),
+    };
+}
+async function admitAppOwnedModel(modelValue, args) {
+    const profile = resolveAppOwnedModel(modelValue, { appId: args.appId, spaceKey: args.spaceKey }, Date.now());
+    if (!profile) {
+        throw new SdkMethodError('MODEL_NOT_ALLOWED', `agents.run: model '${displayValue(modelValue)}' is not a live endpoint this app registered in this Space — register one with endpoints.register and pass its modelValue`);
+    }
+    if (profile.engine !== 'hermes') {
+        throw new SdkMethodError('ENGINE_UNAVAILABLE', `agents.run: the ${profile.engine} engine cannot run an app session`);
+    }
+    let availability;
+    try {
+        availability = await hermesAvailability();
+    }
+    catch {
+        throw new SdkMethodError('ENGINE_UNAVAILABLE', 'agents.run: could not verify the hermes engine on this machine');
+    }
+    if (!availability.available) {
+        const why = availability.state === 'missing'
+            ? 'is not installed on this machine'
+            : availability.state === 'too-old'
+                ? `is older than ${MINIMUM_HERMES_APP_RUN_VERSION}, the minimum for app runs`
+                : 'cannot be confined for an app run on this machine';
+        throw new SdkMethodError('ENGINE_UNAVAILABLE', `agents.run: the hermes engine ${why}`);
+    }
+    return profile.engine;
+}
+export function resolveAgentsRunScopes(params) {
+    const raw = typeof params === 'object' && params !== null && !Array.isArray(params) ? params : {};
+    return raw.modelSelection === undefined ? ['agents:run'] : ['agents:run', 'quality:read'];
+}
+function assertUserClaudeProfile(model) {
+    const parsed = parseProfileModelValue(model);
+    if (!parsed)
+        return;
+    const profile = new ModelProfileStore().get(parsed.profileId);
+    if (!profile || profile.owner || profile.engine !== 'claude-code' || parsed.engine !== 'claude-code') {
+        throw new SdkMethodError('MODEL_NOT_ALLOWED', `agents.run: the Quality model '${displayValue(model)}' is not a Claude Code model added on this machine — choose another model for Quality`);
+    }
+}
+function admitModelSelection(name, args) {
+    const granted = args.grant?.scopes ?? [];
+    if (!granted.includes('quality:read')) {
+        throw new SdkMethodError('SCOPE_DENIED', `agents.run: modelSelection '${name}' needs the quality:read scope`);
+    }
+    const engine = getQualityEngine();
+    if (engine !== 'claude-code') {
+        throw new SdkMethodError('ENGINE_UNAVAILABLE', `agents.run: the Quality model runs on ${engine}, and only Claude Code can run an app session with tools — choose a Claude Code model for Quality`);
+    }
+    const stored = getQualityModel();
+    const model = stored !== 'default' && engineForModel(stored) === engine ? stored : undefined;
+    if (model)
+        assertUserClaudeProfile(model);
+    const effortLevel = getQualityEffortLevel();
+    return {
+        name,
+        engine,
+        ...(model ? { model } : {}),
+        effortLevel: ENGINE_EFFORT_LEVELS[engine].includes(effortLevel) ? effortLevel : 'auto',
+        fastMode: getQualityFastMode(),
+    };
+}
+function findAppRunSession(args, sessionId) {
+    const session = sessionsByTab.get(sessionId);
+    if (!session || session.appId !== args.appId || session.spaceKey !== args.spaceKey) {
+        throw badRequest(`unknown sessionId '${displayValue(sessionId)}' — agents.run continues only an open session this app started with agents.run in this Space`);
+    }
+    const granted = args.grant?.scopes ?? [];
+    if (session.profile.scopes.some((scope) => !granted.includes(scope))) {
+        throw badRequest(`session '${session.tabId}' started under scopes this app's grant no longer holds — start a new run`);
+    }
+    return session;
+}
+function assertSessionIdle(session) {
+    const inFlight = [...runsById.values()].some((record) => record.tabId === session.tabId && !record.outcome);
+    if (inFlight || session.claimed || session.isExecuting?.()) {
+        throw badRequest(`session_busy: session '${session.tabId}' is still running a turn — wait for its result() before continuing it`);
+    }
+}
+export async function admitAgentRun(args, claim = false) {
+    const request = parseRunParams(args.params);
+    if (request.sessionId !== undefined) {
+        let session = findAppRunSession(args, request.sessionId);
+        let engine;
+        if (session.modelValue) {
+            engine = await admitAppOwnedModel(session.modelValue, args);
+            session = findAppRunSession(args, request.sessionId);
+        }
+        assertSessionIdle(session);
+        if (claim)
+            session.claimed = true;
+        return {
+            kind: 'continue',
+            request,
+            session,
+            turn: session.turns + 1,
+            ...(engine && session.modelValue ? { model: { engine, value: session.modelValue } } : {}),
+        };
+    }
+    if (request.modelSelection !== undefined) {
+        return { kind: 'start', request, selection: admitModelSelection(request.modelSelection, args) };
+    }
+    if (request.model === undefined)
+        return { kind: 'start', request };
+    const engine = await admitAppOwnedModel(request.model, args);
+    const budget = request.budget ?? { maxTurns: DEFAULT_RUN_TURNS, maxSeconds: DEFAULT_RUN_SECONDS };
+    return {
+        kind: 'start',
+        request,
+        model: {
+            value: request.model,
+            engine,
+            ...(request.systemPrompt !== undefined ? { systemPrompt: request.systemPrompt } : {}),
+            maxTurns: budget.maxTurns,
+            maxSeconds: budget.maxSeconds,
+        },
+    };
+}
+export async function agentsRunAdmit(args) {
+    await admitAgentRun(args);
+}
+export function agentsRunBouncerInput(params) {
+    if (typeof params !== 'object' || params === null || Array.isArray(params)) {
+        return params === undefined ? {} : { params };
+    }
+    const raw = params;
+    if (!('systemPrompt' in raw))
+        return raw;
+    const { systemPrompt, ...rest } = raw;
+    return { ...rest, systemPrompt: typeof systemPrompt === 'string' ? `[${systemPrompt.length} characters]` : 'invalid' };
+}
+const MAX_RUN_TITLE_LENGTH = 60;
+export function sanitizeRunTitle(title, appId) {
+    const cleaned = (title ?? '').replace(/[\u0000-\u001f\u007f]/g, ' ').replace(/\s+/g, ' ').trim();
+    const base = cleaned || `${appId.replace(/-[a-f0-9]{12}$/, '')} run`;
+    return base.length > MAX_RUN_TITLE_LENGTH ? `${base.slice(0, MAX_RUN_TITLE_LENGTH - 1)}…` : base;
+}
+export async function agentsRunHandler(args) {
+    const host = agentHost;
+    if (!host) {
+        throw new SdkMethodError('INTERNAL', 'agents.run host is not wired — the WebSocket handler installs it at startup');
+    }
+    const admission = await admitAgentRun(args, true);
+    try {
+        return await startAdmittedRun(host, args, admission);
+    }
+    finally {
+        if (admission.kind === 'continue')
+            admission.session.claimed = false;
+    }
+}
+async function startAdmittedRun(host, args, admission) {
+    const { prompt, title } = admission.request;
+    const runId = `run-${Date.now()}-${randomBytes(4).toString('hex')}`;
+    const grantScopes = args.grant ? [...args.grant.scopes] : [];
+    const profile = deriveRunProfile({
+        appId: args.appId,
+        origin: args.origin,
+        grantScopes,
+        workingDir: args.workingDir,
+    });
+    const continued = admission.kind === 'continue' ? admission : undefined;
+    const model = admission.kind === 'start' ? admission.model : undefined;
+    const selection = admission.kind === 'start' ? admission.selection : undefined;
+    const turn = continued ? continued.turn : 1;
+    const handle = await host({
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        workingDir: args.workingDir,
+        runId,
+        tabName: sanitizeRunTitle(title, args.appId),
+        prompt,
+        grantScopes,
+        profile,
+        ...(model ? { model } : {}),
+        ...(selection ? { selection } : {}),
+        ...(continued ? { continuation: continuationOf(continued) } : {}),
+    });
+    const modelValue = handle.modelValue ?? model?.value ?? continued?.session.modelValue;
+    const record = {
+        runId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        requestId: args.requestId,
+        bridgeTabId: args.tabId,
+        tabId: handle.tabId,
+        broadcast: handle.broadcast,
+        cancelRun: handle.cancel,
+        ...(modelValue ? { modelValue } : {}),
+        turn,
+        waiters: [],
+    };
+    runsById.set(runId, record);
+    pruneTerminalRecords();
+    if (continued) {
+        continued.session.turns = turn;
+    }
+    else {
+        rememberAppRunSession(args, handle, profile, modelValue);
+    }
+    registerLiveRun({
+        runId,
+        appId: args.appId,
+        origin: args.origin,
+        spaceKey: args.spaceKey,
+        requestId: args.requestId,
+        tabId: handle.tabId,
+        sessionId: handle.sessionId,
+        cancel: () => cancelRunRecord(record, 'grant revoked'),
+    });
+    logAppAudit({
+        appId: args.appId,
+        origin: args.origin,
+        method: 'agents.run.start',
+        decision: 'allow',
+        requestId: args.requestId,
+        spaceKey: args.spaceKey,
+        reason: `${runStartReason(record, continued ? continued.session.profile : profile, continued !== undefined, model)}${selectionAuditSuffix(selection)}`,
+    });
+    void handle.start().then((outcome) => settleRun(record, outcome));
+    return { runId, sessionId: handle.tabId };
+}
+function continuationOf(continued) {
+    return {
+        tabId: continued.session.tabId,
+        turn: continued.turn,
+        ...(continued.model ? { model: continued.model } : {}),
+    };
+}
+function rememberAppRunSession(args, handle, profile, modelValue) {
+    sessionsByTab.set(handle.tabId, {
+        tabId: handle.tabId,
+        appId: args.appId,
+        spaceKey: args.spaceKey,
+        profile,
+        ...(modelValue ? { modelValue } : {}),
+        turns: 1,
+        ...(handle.isExecuting ? { isExecuting: handle.isExecuting } : {}),
+    });
+}
+function runStartReason(record, ceiling, continued, model) {
+    const scopes = ceiling.scopes.join(',') || 'none';
+    const disallowedTools = ceiling.disallowedTools.join(',') || 'none';
+    const ceilings = model ? ` engine=${model.engine} maxTurns=${model.maxTurns} maxSeconds=${model.maxSeconds}` : '';
+    return `run ${record.runId} ${continued ? 'continued' : 'started'} in tab ${record.tabId} [profile cwd=app-sandbox scopes=${scopes} disallowedTools=${disallowedTools}]${runAuditSuffix(record)}${ceilings}`;
+}
+function selectionAuditSuffix(selection) {
+    if (!selection)
+        return '';
+    return ` selection=${selection.name} engine=${selection.engine} model=${displayValue(selection.model ?? 'default')}`;
+}
+export function agentsResultHandler(args) {
+    const raw = (typeof args.params === 'object' && args.params !== null && !Array.isArray(args.params))
+        ? args.params
+        : {};
+    const runId = typeof raw.runId === 'string' ? raw.runId : '';
+    const record = runId ? runsById.get(runId) : undefined;
+    if (!record || record.appId !== args.appId || record.spaceKey !== args.spaceKey) {
+        throw new SdkMethodError('BAD_REQUEST', `unknown runId '${runId}' — agents.result answers only this app's runs in this Space`);
+    }
+    if (record.outcome)
+        return record.outcome;
+    return new Promise((resolve) => record.waiters.push(resolve));
+}
+export function sdkCancelHandler(args) {
+    const raw = (typeof args.params === 'object' && args.params !== null && !Array.isArray(args.params))
+        ? args.params
+        : {};
+    const requestId = typeof raw.requestId === 'string' ? raw.requestId : '';
+    if (requestId === '') {
+        throw new SdkMethodError('BAD_REQUEST', 'cancel requires params { requestId } naming the request to cancel');
+    }
+    let record;
+    for (const candidate of runsById.values()) {
+        if (candidate.requestId === requestId && candidate.appId === args.appId && candidate.spaceKey === args.spaceKey) {
+            record = candidate;
+            break;
+        }
+    }
+    if (record) {
+        cancelRunRecord(record, 'app cancel');
+        return null;
+    }
+    const subscription = listLiveSubscriptions().find((sub) => sub.requestId === requestId && sub.appId === args.appId && sub.spaceKey === args.spaceKey);
+    if (subscription) {
+        dropSubscription(subscription, 'cancel.subscriptionDropped', 'app cancel');
+        return null;
+    }
+    throw new SdkMethodError('BAD_REQUEST', `nothing cancellable for requestId '${requestId}' — no agent run or live subscription of this app rode it`);
+}
+export function cancelRunsForModel(appId, spaceKey, modelValue) {
+    const bound = [...runsById.values()].filter((record) => !record.outcome && record.appId === appId && record.spaceKey === spaceKey && record.modelValue === modelValue);
+    for (const record of bound)
+        cancelRunRecord(record, 'endpoint removed');
+    return bound.length;
+}
+export function cancelAppRunForClosedTab(tabId) {
+    sessionsByTab.delete(tabId);
+    const live = findLiveRunByTab(tabId);
+    if (!live)
+        return;
+    const record = runsById.get(live.runId);
+    if (record)
+        cancelRunRecord(record, 'tab closed');
+}
+export function mirrorTabEventToSdk(tabId, type, data, broadcast) {
+    const live = findLiveRunByTab(tabId);
+    if (!live)
+        return;
+    const record = runsById.get(live.runId);
+    if (!record || record.outcome)
+        return;
+    const translated = translateTabEvent(type, data);
+    if (!translated)
+        return;
+    const seq = recordSdkStreamEvent(runStreamIdentity(record), translated.event, translated.payload);
+    const payload = { requestId: record.requestId, event: translated.event, payload: translated.payload, seq };
+    broadcast({ type: 'sdkEvent', tabId: record.bridgeTabId, data: payload });
+}
+const WITHHELD_TIMELINE_KINDS = new Set(['question', 'question_state']);
+function translateOutputEvent(raw) {
+    const text = typeof raw.text === 'string' ? raw.text : '';
+    return text === '' ? null : { event: 'output', payload: { text } };
+}
+function translateToolUseEvent(raw) {
+    if (raw.type !== 'tool_complete' || typeof raw.toolName !== 'string')
+        return null;
+    return {
+        event: 'toolUse',
+        payload: {
+            tool: raw.toolName,
+            ...(raw.completeInput !== undefined ? { input: raw.completeInput } : {}),
+        },
+    };
+}
+function translateTimelineEvent(raw, data) {
+    const kind = typeof raw.kind === 'string' ? raw.kind : '';
+    if (WITHHELD_TIMELINE_KINDS.has(kind))
+        return null;
+    return { event: 'timelineEvent', payload: data };
+}
+function translateTabEvent(type, data) {
+    const raw = (typeof data === 'object' && data !== null) ? data : {};
+    switch (type) {
+        case 'output':
+            return translateOutputEvent(raw);
+        case 'movementStart':
+            return { event: 'status', payload: { status: 'running' } };
+        case 'toolUse':
+            return translateToolUseEvent(raw);
+        case 'timelineEvent':
+            return translateTimelineEvent(raw, data);
+        default:
+            return null;
+    }
+}

package/dist/server/services/sdk/app-endpoints.js

@@ -0,0 +1,48 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+import { ModelProfileStore, parseProfileExpiry, parseProfileModelValue, profileCredentialId, } from '../../engines/credentials/model-profiles.js';
+export function appProfileId(appId, slug) {
+    return `app-${appId}-${slug}`;
+}
+export function isAppOwnedProfile(profile) {
+    return profile.owner !== undefined;
+}
+function ownedBy(profile, owner) {
+    return (isAppOwnedProfile(profile) &&
+        profile.owner.appId === owner.appId &&
+        profile.owner.spaceKey === owner.spaceKey);
+}
+function isExpired(profile, now) {
+    const expiresMs = parseProfileExpiry(profile.expiresAt);
+    return expiresMs === undefined || expiresMs <= now;
+}
+function removeProfiles(store, credentials, profiles) {
+    for (const profile of profiles) {
+        credentials.remove(profileCredentialId(profile.id));
+        store.remove(profile.id);
+    }
+    return profiles.map((profile) => profile.id);
+}
+export function listAppProfiles(store, owner) {
+    return store.list().filter((profile) => ownedBy(profile, owner));
+}
+export function purgeExpiredAppProfiles(store, credentials, now) {
+    const expired = store.list().filter((profile) => isAppOwnedProfile(profile) && isExpired(profile, now));
+    return removeProfiles(store, credentials, expired);
+}
+export function removeAppProfiles(store, credentials, owner) {
+    return removeProfiles(store, credentials, listAppProfiles(store, owner));
+}
+export function resolveAppOwnedModel(modelValue, owner, now, deps = {}) {
+    if (typeof modelValue !== 'string')
+        return undefined;
+    const parsed = parseProfileModelValue(modelValue);
+    if (!parsed)
+        return undefined;
+    const profile = (deps.profiles ?? new ModelProfileStore()).get(parsed.profileId);
+    if (!profile || profile.id !== parsed.profileId || !ownedBy(profile, owner))
+        return undefined;
+    if (profile.engine !== parsed.engine || isExpired(profile, now))
+        return undefined;
+    return profile;
+}