@chenpengfei/daily-brief 0.1.0

package/dist/src/agent/daily-brief-agent.js

@@ -0,0 +1,350 @@
+import { Agent } from "@earendil-works/pi-agent-core";
+import { fauxAssistantMessage, registerFauxProvider } from "@earendil-works/pi-ai";
+import { readFile } from "node:fs/promises";
+import { generateDailyBrief, renderDailyBriefMarkdown } from "../brief/index.js";
+import { collectSources } from "../collection/index.js";
+import { deliverCoreFailureNotification, deliverDiscordNotification } from "../discord/index.js";
+import { briefArchivePath, createAgentRunArtifact, readSourceItems, writeAgentRunArtifact, writeBriefArchive } from "../storage/index.js";
+import { readModelRuntimeConfig } from "./model-runtime-config.js";
+import { enrichDailyBriefNarrativeWithAgent } from "./signal-narrative.js";
+import { runSignalSelectionAndRankingStages } from "./signal-selection-ranking.js";
+import { AnalysisFailureError, runSourceGroundingAuditStage } from "./source-grounding-audit.js";
+import { runSourceGroundingRepairStage } from "./source-grounding-repair.js";
+import { runSourceItemUnderstandingStage } from "./source-item-understanding.js";
+import { runAgentStage } from "./stage-runner.js";
+export async function runOnce(options = {}) {
+    const date = options.date ?? new Date();
+    const dateKey = options.dateKey;
+    let collection;
+    try {
+        collection = await collectSources({
+            date,
+            ...(dateKey ? { dateKey } : {}),
+            fetchedAt: date,
+            ...(options.sourceRegistryPath ? { sourceRegistryPath: options.sourceRegistryPath } : {}),
+            ...(options.sourceItemRoot ? { sourceItemRoot: options.sourceItemRoot } : {})
+        });
+    }
+    catch (error) {
+        const coreFailure = {
+            kind: "unreadable-source-registry",
+            message: error instanceof Error ? error.message : String(error)
+        };
+        const delivery = await deliverCoreFailureNotification(coreFailure, {
+            ...(options.discordWebhookUrl ? { webhookUrl: options.discordWebhookUrl } : {}),
+            ...(options.discordFetchImpl ? { fetchImpl: options.discordFetchImpl } : {})
+        });
+        return {
+            archivePath: "",
+            markdown: "",
+            sourceCount: 0,
+            sourceItemCount: 0,
+            piEvents: [],
+            collection: { storePath: "", sources: [] },
+            delivery,
+            coreFailure
+        };
+    }
+    const collectedItems = await readSourceItems(date, options.sourceItemRoot, dateKey);
+    const collectionFailure = classifyCollectionCoreFailure(collection, collectedItems.length);
+    if (collectionFailure) {
+        const delivery = await deliverCoreFailureNotification(collectionFailure, {
+            ...(options.discordWebhookUrl ? { webhookUrl: options.discordWebhookUrl } : {}),
+            ...(options.discordFetchImpl ? { fetchImpl: options.discordFetchImpl } : {})
+        });
+        return {
+            archivePath: "",
+            markdown: "",
+            sourceCount: collection.sources.length,
+            sourceItemCount: collectedItems.length,
+            piEvents: [],
+            collection,
+            delivery,
+            coreFailure: collectionFailure
+        };
+    }
+    const collectionFailures = collectionFailureRefs(collection);
+    const generated = await generateOnce({
+        ...options,
+        ...(dateKey ? { dateKey } : {}),
+        sourceCount: collection.sources.length,
+        ...(collectionFailures.length > 0
+            ? {
+                partialFailures: collectionFailures.map((failure) => `${failure.sourceId}: ${failure.reason}`),
+                collectionFailures
+            }
+            : {})
+    });
+    const delivery = await deliverOnce({
+        ...options,
+        date,
+        brief: generated.brief,
+        archivePath: generated.archivePath
+    });
+    return {
+        archivePath: generated.archivePath,
+        markdown: generated.markdown,
+        sourceCount: collection.sources.length,
+        sourceItemCount: generated.sourceItemCount,
+        piEvents: generated.piEvents,
+        collection,
+        delivery,
+        ...(generated.agentRunArtifactPath ? { agentRunArtifactPath: generated.agentRunArtifactPath } : {})
+    };
+}
+export async function generateOnce(options = {}) {
+    const date = options.date ?? new Date();
+    const dateKey = options.dateKey;
+    const sourceItems = await readSourceItems(date, options.sourceItemRoot, dateKey);
+    const modelRuntimeConfig = readModelRuntimeConfig(options.modelRuntimeEnv);
+    if (sourceItems.length === 0) {
+        throw new Error("No usable Source Items found for generation; Daily Brief will not archive a false low-signal brief.");
+    }
+    if (!modelRuntimeConfig.ready) {
+        throw new Error(`Model runtime is not ready:\n${modelRuntimeConfig.issues.map((issue) => `- ${issue}`).join("\n")}`);
+    }
+    const baseBrief = generateDailyBrief({
+        date,
+        ...(dateKey ? { dateKey } : {}),
+        sourceItems,
+        ...(options.partialFailures ? { partialFailures: options.partialFailures } : {}),
+        ...(options.sourceCount ? { sourceCount: options.sourceCount } : {})
+    });
+    const artifact = createAgentRunArtifact({
+        date,
+        ...(dateKey ? { dateKey } : {}),
+        modelRuntimeConfig,
+        inputRefs: {
+            sourceItemIds: sourceItems.map((item) => item.id),
+            signalIds: baseBrief.signals.map((signal) => signal.id),
+            ...(options.collectionFailures ? { collectionFailures: options.collectionFailures } : {})
+        }
+    });
+    try {
+        const collectionInputRefs = options.collectionFailures
+            ? { collectionFailures: options.collectionFailures }
+            : undefined;
+        const understanding = await runSourceItemUnderstandingStage({
+            sourceItems,
+            modelRuntimeConfig,
+            artifact,
+            ...(collectionInputRefs ? { inputRefs: collectionInputRefs } : {}),
+            ...(options.modelRuntimeEnv ? { modelRuntimeEnv: options.modelRuntimeEnv } : {})
+        });
+        const selected = await runSignalSelectionAndRankingStages({
+            sourceItems,
+            annotations: understanding.annotations,
+            artifact,
+            modelRuntimeConfig,
+            ...(collectionInputRefs ? { inputRefs: collectionInputRefs } : {}),
+            ...(options.modelRuntimeEnv ? { modelRuntimeEnv: options.modelRuntimeEnv } : {})
+        });
+        const selectedBrief = {
+            ...baseBrief,
+            executiveSummary: selected.signals.length === 0
+                ? "今天是 low-signal day：Selection/Ranking Stages 没有选出足够强的 Source-grounded Signals。"
+                : `今天有 ${selected.signals.length} 个 Agent-selected Source-grounded Signals，均保留 Source Item citation 以便回溯。`,
+            signals: selected.signals
+        };
+        const narrativeEvents = [];
+        const narrative = await enrichDailyBriefNarrativeWithAgent({
+            brief: selectedBrief,
+            sourceItems,
+            modelRuntimeConfig,
+            ...(options.modelRuntimeEnv ? { modelRuntimeEnv: options.modelRuntimeEnv } : {})
+        });
+        narrativeEvents.push(...narrative.events);
+        const narrativeStage = await recordNarrativeStage({
+            artifact,
+            date,
+            sourceItems,
+            brief: narrative.brief,
+            ...(options.collectionFailures ? { collectionFailures: options.collectionFailures } : {})
+        });
+        const audited = await auditBriefWithSingleRepairAttempt({
+            narrativeBrief: narrative.brief,
+            sourceItems,
+            artifact,
+            date,
+            modelRuntimeConfig,
+            ...(options.modelRuntimeEnv ? { modelRuntimeEnv: options.modelRuntimeEnv } : {}),
+            ...(options.collectionFailures ? { collectionFailures: options.collectionFailures } : {}),
+            ...(collectionInputRefs ? { collectionInputRefs } : {})
+        });
+        narrativeEvents.push(...audited.narrativeEvents);
+        const writtenArtifact = options.agentRunRoot ? await writeAgentRunArtifact(artifact, date, options.agentRunRoot, dateKey) : undefined;
+        const markdown = renderDailyBriefMarkdown(audited.brief);
+        const piResult = await renderBriefThroughPiRuntime(markdown);
+        const archived = await writeBriefArchive(piResult.markdown, date, options.archiveRoot, dateKey);
+        return {
+            archivePath: archived.path,
+            markdown: piResult.markdown,
+            brief: audited.brief,
+            sourceItemCount: sourceItems.length,
+            piEvents: [...understanding.events, ...selected.events, ...narrativeEvents, ...piResult.events],
+            modelRuntimeConfig,
+            ...((writtenArtifact?.path ?? narrativeStage.artifactPath) ? { agentRunArtifactPath: writtenArtifact?.path ?? narrativeStage.artifactPath } : {})
+        };
+    }
+    catch (error) {
+        artifact.failure = {
+            kind: "execution",
+            message: error instanceof Error ? error.message : String(error)
+        };
+        if (options.agentRunRoot) {
+            await writeAgentRunArtifact(artifact, date, options.agentRunRoot, dateKey);
+        }
+        throw error;
+    }
+}
+async function recordNarrativeStage(input) {
+    const result = await runAgentStage({
+        stage: "narrative",
+        artifact: input.artifact,
+        date: input.date,
+        inputRefs: {
+            ...(input.collectionFailures ? { collectionFailures: input.collectionFailures } : {}),
+            sourceItemIds: input.sourceItems.map((item) => item.id),
+            signalIds: input.brief.signals.map((signal) => signal.id)
+        },
+        validationContext: {
+            signalIds: input.brief.signals.map((signal) => signal.id)
+        },
+        execute: async () => ({
+            stage: "narrative",
+            executiveSummary: input.brief.executiveSummary,
+            signalNarratives: input.brief.signals.map((signal) => ({
+                signalId: signal.id,
+                focusAreas: signal.focusAreas ?? [],
+                directions: signal.directions ?? [],
+                whatItIs: signal.summary.whatItIs,
+                whatItIsNot: signal.summary.whatItIsNot,
+                minimalExample: signal.summary.minimalExample,
+                whyItMatters: signal.whyItMatters
+            }))
+        })
+    });
+    return result;
+}
+async function auditBriefWithSingleRepairAttempt(input) {
+    const narrativeEvents = [];
+    try {
+        const audited = await runSourceGroundingAuditStage({
+            brief: input.narrativeBrief,
+            sourceItems: input.sourceItems,
+            artifact: input.artifact,
+            modelRuntimeConfig: input.modelRuntimeConfig,
+            ...(input.collectionInputRefs ? { inputRefs: input.collectionInputRefs } : {}),
+            ...(input.modelRuntimeEnv ? { modelRuntimeEnv: input.modelRuntimeEnv } : {})
+        });
+        return { brief: audited.brief, narrativeEvents };
+    }
+    catch (error) {
+        if (!(error instanceof AnalysisFailureError)) {
+            throw error;
+        }
+        const repaired = await runSourceGroundingRepairStage({
+            brief: input.narrativeBrief,
+            sourceItems: input.sourceItems,
+            auditFindings: error.findings,
+            artifact: input.artifact,
+            modelRuntimeConfig: input.modelRuntimeConfig,
+            ...(input.collectionInputRefs ? { inputRefs: input.collectionInputRefs } : {}),
+            ...(input.modelRuntimeEnv ? { modelRuntimeEnv: input.modelRuntimeEnv } : {})
+        });
+        narrativeEvents.push(...repaired.events);
+        const audited = await runSourceGroundingAuditStage({
+            brief: repaired.brief,
+            sourceItems: input.sourceItems,
+            artifact: input.artifact,
+            modelRuntimeConfig: input.modelRuntimeConfig,
+            ...(input.collectionInputRefs ? { inputRefs: input.collectionInputRefs } : {}),
+            ...(input.modelRuntimeEnv ? { modelRuntimeEnv: input.modelRuntimeEnv } : {})
+        });
+        return { brief: audited.brief, narrativeEvents };
+    }
+}
+function collectionFailureRefs(collection) {
+    return collection.sources
+        .filter((source) => source.status === "failed")
+        .map((source) => ({ sourceId: source.sourceId, reason: source.reason ?? "Unknown failure" }));
+}
+function classifyCollectionCoreFailure(collection, storedSourceItemCount) {
+    const enabledResults = collection.sources.filter((source) => source.status !== "skipped");
+    const failedResults = enabledResults.filter((source) => source.status === "failed");
+    if (enabledResults.length === 0 && storedSourceItemCount === 0) {
+        return {
+            kind: "no-usable-source-items",
+            message: "No enabled Sources produced Source Items; Daily Brief will not generate a false low-signal brief."
+        };
+    }
+    if (enabledResults.length > 0 && failedResults.length === enabledResults.length && storedSourceItemCount === 0) {
+        return {
+            kind: "no-usable-source-items",
+            message: `All enabled Sources failed and no Source Items exist for this date: ${failedResults
+                .map((source) => `${source.sourceId}: ${source.reason ?? "Unknown failure"}`)
+                .join("; ")}`
+        };
+    }
+    return undefined;
+}
+export async function deliverOnce(options = {}) {
+    const date = options.date ?? new Date();
+    const archivePath = options.archivePath ?? briefArchivePath(date, options.archiveRoot, options.dateKey);
+    try {
+        await readFile(archivePath, "utf8");
+    }
+    catch {
+        return { status: "failed", reason: `Brief Archive entry not found: ${archivePath}` };
+    }
+    const brief = options.brief ??
+        generateDailyBrief({
+            date,
+            ...(options.dateKey ? { dateKey: options.dateKey } : {}),
+            sourceItems: await readSourceItems(date, options.sourceItemRoot, options.dateKey)
+        });
+    return deliverDiscordNotification({
+        brief,
+        briefPath: archivePath,
+        ...(options.discordTemplatePath ? { templatePath: options.discordTemplatePath } : {})
+    }, {
+        ...(options.discordWebhookUrl ? { webhookUrl: options.discordWebhookUrl } : {}),
+        ...(options.discordFetchImpl ? { fetchImpl: options.discordFetchImpl } : {})
+    });
+}
+export async function renderBriefThroughPiRuntime(markdown) {
+    const provider = registerFauxProvider();
+    provider.setResponses([fauxAssistantMessage(markdown)]);
+    try {
+        const events = [];
+        const model = provider.getModel();
+        const agent = new Agent({
+            initialState: {
+                systemPrompt: "You are the Daily Brief Agent. Return only the already grounded Markdown Daily Brief you are given.",
+                model,
+                thinkingLevel: "off"
+            },
+            sessionId: "daily-brief-run-once"
+        });
+        agent.subscribe((event) => {
+            events.push(event.type);
+        });
+        await agent.prompt([
+            "Render this Source-grounded Daily Brief exactly as Markdown.",
+            "",
+            markdown
+        ].join("\n"));
+        const assistantMessage = [...agent.state.messages].reverse().find((message) => message.role === "assistant");
+        const rendered = assistantMessage?.content
+            .filter((block) => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        if (!rendered) {
+            throw new Error("Pi Agent Runtime did not return Daily Brief Markdown");
+        }
+        return { markdown: rendered, events };
+    }
+    finally {
+        provider.unregister();
+    }
+}

package/dist/src/agent/index.js

@@ -0,0 +1,10 @@
+export * from "./daily-brief-agent.js";
+export * from "./model-runtime-config.js";
+export * from "./model-stage-runtime.js";
+export * from "./signal-narrative.js";
+export * from "./signal-selection-ranking.js";
+export * from "./source-item-understanding.js";
+export * from "./source-grounding-audit.js";
+export * from "./source-grounding-repair.js";
+export * from "./stage-contracts.js";
+export * from "./stage-runner.js";

package/dist/src/agent/model-runtime-config.js

@@ -0,0 +1,221 @@
+import { existsSync } from "node:fs";
+import { getOAuthApiKey, loginOpenAICodex } from "@earendil-works/pi-ai/oauth";
+import { envNameFromCredentialRef, getCredential, isEnvCredentialRef, putCredential, readCredentialStore, readModelConfig, removeCredential, writeCredentialStore } from "../config/index.js";
+import { resolveDailyBriefPaths } from "../config/paths.js";
+export const defaultOAuthHelpers = {
+    getOAuthApiKey,
+    loginOpenAICodex
+};
+export function readModelRuntimeConfig(env = process.env, options = {}) {
+    const paths = resolveDailyBriefPaths(env);
+    const configPath = options.configPath ?? paths.configPath;
+    const authPath = options.authPath ?? paths.authPath;
+    const config = readEnvModelConfig(env) ?? (existsSync(configPath) ? readModelConfig(configPath) : undefined);
+    if (!config) {
+        return {
+            provider: "openai-codex",
+            model: "gpt-5.5",
+            credentialRef: "openai-codex.default",
+            ready: false,
+            issues: [`Model config not found: ${configPath}. Run daily-brief setup and daily-brief model configure/login first.`]
+        };
+    }
+    const issues = credentialIssues(config.provider, config.credentialRef, env, authPath);
+    return {
+        provider: config.provider,
+        model: config.model,
+        ...(config.credentialRef ? { credentialRef: config.credentialRef } : {}),
+        ...(config.baseUrl ? { baseUrl: config.baseUrl } : {}),
+        ready: issues.length === 0,
+        issues
+    };
+}
+export async function resolveModelApiKey(config, env = process.env, options = {}) {
+    if (config.provider === "faux") {
+        return undefined;
+    }
+    const credentialRef = config.credentialRef;
+    if (!credentialRef) {
+        throw new Error(`credentialRef is required for ${config.provider}`);
+    }
+    if (isEnvCredentialRef(credentialRef)) {
+        const envName = envNameFromCredentialRef(credentialRef);
+        return env[envName]?.trim();
+    }
+    const authPath = options.authPath ?? resolveDailyBriefPaths(env).authPath;
+    const credential = getCredential(credentialRef, authPath);
+    if (!credential) {
+        throw new Error(`Credential not found: ${credentialRef}`);
+    }
+    if (credential.provider !== config.provider) {
+        throw new Error(`Credential ${credentialRef} is for ${credential.provider}, not ${config.provider}`);
+    }
+    if (credential.type === "api-key") {
+        return credential.apiKey;
+    }
+    const helpers = options.oauthHelpers ?? defaultOAuthHelpers;
+    const result = await helpers.getOAuthApiKey(credential.provider, {
+        [credential.provider]: credential.credentials
+    });
+    if (!result) {
+        throw new Error(`OAuth credential ${credentialRef} is not logged in`);
+    }
+    persistRefreshedOAuthCredential(credentialRef, credential, result.newCredentials, authPath);
+    return result.apiKey;
+}
+export async function loginModelCredential(input) {
+    if (input.provider !== "openai-codex") {
+        throw new Error(`model login currently supports OAuth provider openai-codex, received ${input.provider}`);
+    }
+    const helpers = input.oauthHelpers ?? defaultOAuthHelpers;
+    const credentials = await helpers.loginOpenAICodex({
+        onAuth: (info) => {
+            input.io.stdout(`Open authorization URL: ${info.url}`);
+            if (info.instructions) {
+                input.io.stdout(info.instructions);
+            }
+        },
+        onDeviceCode: (info) => {
+            input.io.stdout(`Open verification URL: ${info.verificationUri}`);
+            input.io.stdout(`Device code: ${info.userCode}`);
+        },
+        onPrompt: (prompt) => promptForOAuth(input.io, prompt.message),
+        onManualCodeInput: () => promptForOAuth(input.io, "Authorization code:"),
+        onProgress: (message) => input.io.stdout(message),
+        onSelect: async (prompt) => {
+            for (const option of prompt.options) {
+                input.io.stdout(`${option.id}: ${option.label}`);
+            }
+            const selected = await promptForOAuth(input.io, prompt.message);
+            return selected || undefined;
+        }
+    });
+    putCredential(input.credentialRef, {
+        type: "oauth",
+        provider: "openai-codex",
+        credentials
+    }, input.authPath ?? resolveDailyBriefPaths(input.env ?? process.env).authPath);
+}
+export function logoutModelCredential(ref, env = process.env, authPath) {
+    removeCredential(ref, authPath ?? resolveDailyBriefPaths(env).authPath);
+}
+export function statusModelCredentials(env = process.env, options = {}) {
+    const authPath = options.authPath ?? resolveDailyBriefPaths(env).authPath;
+    return Object.entries(readCredentialStore(authPath).credentials).map(([ref, credential]) => ({
+        ref,
+        type: credential.type,
+        provider: credential.provider,
+        secret: "<redacted>"
+    }));
+}
+function credentialIssues(provider, credentialRef, env, authPath) {
+    if (provider === "faux") {
+        return [];
+    }
+    if (!credentialRef) {
+        return [`credentialRef is required for ${provider}`];
+    }
+    if (isEnvCredentialRef(credentialRef)) {
+        const envName = envNameFromCredentialRef(credentialRef);
+        return env[envName]?.trim() ? [] : [`${envName} is required for credentialRef ${credentialRef}`];
+    }
+    const credential = getCredential(credentialRef, authPath);
+    if (!credential) {
+        return [`Credential not found: ${credentialRef}`];
+    }
+    if (credential.provider !== provider) {
+        return [`Credential ${credentialRef} is for ${credential.provider}, not ${provider}`];
+    }
+    return [];
+}
+function readEnvModelConfig(env) {
+    const provider = env.DAILY_BRIEF_MODEL_PROVIDER?.trim();
+    if (!provider) {
+        return undefined;
+    }
+    const normalizedProvider = normalizeProvider(provider, env);
+    return {
+        provider: normalizedProvider,
+        model: env.DAILY_BRIEF_MODEL?.trim() || defaultModelForProvider(normalizedProvider),
+        ...(env.DAILY_BRIEF_MODEL_BASE_URL?.trim() ? { baseUrl: env.DAILY_BRIEF_MODEL_BASE_URL.trim() } : {}),
+        ...readEnvCredentialRef(env, normalizedProvider)
+    };
+}
+function normalizeProvider(value, env) {
+    const provider = value.trim().toLowerCase();
+    if (provider === "codex" || provider === "hermes") {
+        return "openai-codex";
+    }
+    if (provider === "faux") {
+        if (env.DAILY_BRIEF_ALLOW_FAUX_PROVIDER === "true") {
+            return provider;
+        }
+        throw new Error("DAILY_BRIEF_MODEL_PROVIDER=faux is only allowed when DAILY_BRIEF_ALLOW_FAUX_PROVIDER=true");
+    }
+    if (provider === "openai-codex" || provider === "openai" || provider === "deepseek" || provider === "openai-compatible") {
+        return provider;
+    }
+    throw new Error(`Unsupported DAILY_BRIEF_MODEL_PROVIDER: ${value}`);
+}
+function defaultModelForProvider(provider) {
+    if (provider === "openai-codex") {
+        return "gpt-5.5";
+    }
+    if (provider === "openai") {
+        return "gpt-4.1-mini";
+    }
+    if (provider === "deepseek") {
+        return "deepseek-chat";
+    }
+    if (provider === "openai-compatible") {
+        return "openai-compatible-model";
+    }
+    return "faux-daily-brief-renderer";
+}
+function defaultCredentialRefForProvider(provider) {
+    if (provider === "faux") {
+        return undefined;
+    }
+    if (provider === "openai") {
+        return "env:OPENAI_API_KEY";
+    }
+    if (provider === "deepseek") {
+        return "env:DEEPSEEK_API_KEY";
+    }
+    if (provider === "openai-compatible") {
+        return "env:OPENAI_API_KEY";
+    }
+    return "openai-codex.default";
+}
+function persistRefreshedOAuthCredential(ref, credential, credentials, authPath) {
+    const store = readCredentialStore(authPath);
+    const previous = store.credentials[ref];
+    store.credentials[ref] = {
+        ...credential,
+        ...((previous?.createdAt ?? credential.createdAt) ? { createdAt: previous?.createdAt ?? credential.createdAt } : {}),
+        updatedAt: new Date().toISOString(),
+        credentials
+    };
+    writeCredentialStore(store, authPath);
+}
+function readEnvCredentialRef(env, provider) {
+    const credentialRef = env.DAILY_BRIEF_MODEL_CREDENTIAL_REF?.trim() ||
+        defaultCredentialRefForProvider(provider);
+    return credentialRef ? { credentialRef } : {};
+}
+function promptForOAuth(io, message) {
+    if (!io.prompt) {
+        throw new Error(`OAuth login requires interactive input: ${message}`);
+    }
+    return io.prompt(message);
+}
+export function toApiKeyCredential(provider, apiKey) {
+    if (provider === "faux" || provider === "openai-codex") {
+        throw new Error(`${provider} does not accept API key credentials in auth.json`);
+    }
+    return {
+        type: "api-key",
+        provider,
+        apiKey
+    };
+}

package/dist/src/agent/model-stage-runtime.js

@@ -0,0 +1,63 @@
+import { fauxAssistantMessage, getModel, registerBuiltInApiProviders, registerFauxProvider } from "@earendil-works/pi-ai";
+import { resolveModelApiKey } from "./model-runtime-config.js";
+export function createStageModelRuntime(input) {
+    const { config, env } = input;
+    if (config.provider === "faux") {
+        if (!input.fauxResponse) {
+            throw new Error("fauxResponse is required for faux model runtime");
+        }
+        const provider = registerFauxProvider({
+            models: [{ id: config.model, name: config.model }]
+        });
+        provider.setResponses([fauxAssistantMessage(input.fauxResponse)]);
+        return {
+            model: provider.getModel(config.model) ?? provider.getModel(),
+            thinkingLevel: "off",
+            unregister: provider.unregister
+        };
+    }
+    registerBuiltInApiProviders();
+    if (config.provider === "openai-codex") {
+        return {
+            model: getModel("openai-codex", config.model),
+            getApiKey: (provider) => (provider === "openai-codex" ? resolveModelApiKey(config, env) : undefined),
+            thinkingLevel: input.openAICodexThinkingLevel ?? "low"
+        };
+    }
+    if (config.provider === "deepseek") {
+        return {
+            model: getModel("deepseek", config.model),
+            getApiKey: (provider) => (provider === "deepseek" ? resolveModelApiKey(config, env) : undefined),
+            thinkingLevel: "off"
+        };
+    }
+    if (config.provider === "openai-compatible") {
+        return {
+            model: buildOpenAICompatibleModel(config),
+            getApiKey: (provider) => (provider === "openai-compatible" ? resolveModelApiKey(config, env) : undefined),
+            thinkingLevel: "off"
+        };
+    }
+    return {
+        model: getModel("openai", config.model),
+        getApiKey: (provider) => (provider === "openai" ? resolveModelApiKey(config, env) : undefined),
+        thinkingLevel: "off"
+    };
+}
+export function buildOpenAICompatibleModel(config) {
+    if (!config.baseUrl) {
+        throw new Error("baseUrl is required for openai-compatible model runtime");
+    }
+    return {
+        id: config.model,
+        name: config.model,
+        api: "openai-completions",
+        provider: "openai-compatible",
+        baseUrl: config.baseUrl,
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128000,
+        maxTokens: 4096
+    };
+}