@plico-ai/runtime 0.0.0-reserved.0 → 0.1.0

package/dist/events.d.ts

@@ -0,0 +1,28 @@
+import type { EventStreamType, PlicoEventPayloads } from "@plico-ai/contracts";
+import type { EventStore, PlicoEvent, PlicoEventType } from "./types/index.js";
+export declare const runStreamType: EventStreamType;
+/**
+ * Build the terminal failure pair both recovery paths append. The caller supplies the tail so
+ * appending to an event store and inserting directly into SQLite share one sequencing scheme.
+ */
+export declare function runFailureEvents(runId: string, last: {
+    sequence: number;
+    type: string;
+} | undefined, message: string, timestamp?: string): PlicoEvent[];
+export declare class InMemoryEventLog {
+    #private;
+    private readonly runId;
+    private readonly store;
+    /**
+     * Opens the log of a run that may have started before. The loop emits the same events again when
+     * it replays; events already stored are matched, not written twice.
+     */
+    static open(runId: string, store: EventStore | undefined): Promise<InMemoryEventLog>;
+    constructor(runId: string, store?: EventStore | undefined);
+    append<T extends PlicoEventType>(type: T, payload: PlicoEventPayloads[T]): Promise<PlicoEvent>;
+    /** Skip previously persisted live chunks when replaying a model step. */
+    skipModelDeltas(turn: number): void;
+    /** Continue after the recorded tail when recovery cannot replay the workflow. */
+    continueAfterReplay(): void;
+    all(): PlicoEvent[];
+}

package/dist/events.js

@@ -0,0 +1,104 @@
+import { ProjectChangedError } from "./engine/index.js";
+export const runStreamType = "run";
+/**
+ * Build the terminal failure pair both recovery paths append. The caller supplies the tail so
+ * appending to an event store and inserting directly into SQLite share one sequencing scheme.
+ */
+export function runFailureEvents(runId, last, message, timestamp = new Date().toISOString()) {
+    const events = [];
+    let sequence = last?.sequence ?? 0;
+    if (last?.type !== "run.error") {
+        sequence += 1;
+        events.push({
+            schemaVersion: 1,
+            streamType: "run",
+            streamId: runId,
+            runId,
+            id: `evt-${String(sequence).padStart(4, "0")}`,
+            sequence,
+            timestamp,
+            type: "run.error",
+            payload: { phase: "runtime", message },
+        });
+    }
+    sequence += 1;
+    events.push({
+        schemaVersion: 1,
+        streamType: "run",
+        streamId: runId,
+        runId,
+        id: `evt-${String(sequence).padStart(4, "0")}`,
+        sequence,
+        timestamp,
+        type: "run.failed",
+        payload: { phase: "runtime" },
+    });
+    return events;
+}
+export class InMemoryEventLog {
+    runId;
+    store;
+    #events = [];
+    #replayed = 0;
+    #cursor = 0;
+    /**
+     * Opens the log of a run that may have started before. The loop emits the same events again when
+     * it replays; events already stored are matched, not written twice.
+     */
+    static async open(runId, store) {
+        const log = new InMemoryEventLog(runId, store);
+        if (store)
+            log.#events.push(...(await store.getEvents(runId)));
+        log.#replayed = log.#events.length;
+        return log;
+    }
+    constructor(runId, store = undefined) {
+        this.runId = runId;
+        this.store = store;
+    }
+    async append(type, payload) {
+        if (this.#cursor < this.#replayed) {
+            const recorded = this.#events[this.#cursor];
+            if (recorded.type !== type || JSON.stringify(recorded.payload) !== JSON.stringify(payload)) {
+                // Later events (the failure) are appended after what the earlier attempt stored.
+                this.#cursor = this.#replayed;
+                throw new ProjectChangedError("event", this.#cursor, recorded.type, type);
+            }
+            this.#cursor += 1;
+            return recorded;
+        }
+        const sequence = this.#events.length + 1;
+        // TypeScript cannot prove this generic object is a union member; callers are checked against PlicoEventPayloads[T].
+        const event = {
+            schemaVersion: 1,
+            streamType: runStreamType,
+            streamId: this.runId,
+            runId: this.runId,
+            id: `evt-${String(sequence).padStart(4, "0")}`,
+            sequence,
+            timestamp: new Date().toISOString(),
+            type,
+            payload,
+        };
+        await this.store?.appendEvent(event);
+        this.#events.push(event);
+        return event;
+    }
+    /** Skip previously persisted live chunks when replaying a model step. */
+    skipModelDeltas(turn) {
+        while (this.#cursor < this.#replayed) {
+            const event = this.#events[this.#cursor];
+            if ((event?.type !== "model.delta" && event?.type !== "model.attempt") ||
+                event.payload.turn !== turn)
+                break;
+            this.#cursor++;
+        }
+    }
+    /** Continue after the recorded tail when recovery cannot replay the workflow. */
+    continueAfterReplay() {
+        this.#cursor = this.#replayed;
+    }
+    all() {
+        return [...this.#events];
+    }
+}

package/dist/guards.d.ts

@@ -0,0 +1 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/guards.js

@@ -0,0 +1,3 @@
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { buildArtifactWorkspace, readArtifactSnapshot, readArtifactVersion } from "./artifacts.js";
+export { createEngine, createMemoryJournal, createSqliteEngine, type Engine, type Journal, ProjectChangedError, type RecoveredRun, type RunContext, type Workflow, } from "./engine/index.js";
+export { loadedEnvFiles, loadProjectEnv } from "./env.js";
+export { type ModelErrorKind, ModelProviderError } from "./errors.js";
+export { evalCaseFromRun, runEvals } from "./evals/index.js";
+export { runFailureEvents } from "./events.js";
+export { composeInstructions } from "./instructions.js";
+export { createConfiguredModelProvider, modelProviderAccountKey, modelProviderRecoveryKey, supportsModelProvider, } from "./providers/configured.js";
+export { createOpenAICompatibleProvider, type OpenAICompatibleProviderOptions, } from "./providers/openai-compatible.js";
+export { checkReadiness } from "./readiness/index.js";
+export { recoverRuns, runProject } from "./run/index.js";
+export { normalizeScript, ScriptValidationError } from "./script.js";
+export { createSqliteEventStore } from "./storage/index.js";
+export { matchesMetadata } from "./storage/metadata.js";
+export { createSqliteThreadStore, ThreadBusyError, type ThreadStore, } from "./storage/sqlite/threads.js";
+export { createThreadTitler, type ThreadTitler } from "./threads/titler.js";
+export { discoverTools } from "./tools/index.js";
+export type { ArtifactContent, ArtifactFile, ArtifactFileInput, ArtifactFileMetadata, ArtifactSnapshot, ArtifactSnapshotDetail, ArtifactVersion, ArtifactWorkspace, ComposedInstructions, CreateSqliteEventStoreOptions, DeclaredTool, DiagnosticSeverity, DryRunScriptStep, EvalCase, EvalCaseResult, EvalExpectation, EvalReport, EvalSummary, EventStore, JsonSchema, ModelChunk, ModelProvider, ModelRequest, ModelResponse, ModelToolCall, PlicoEvent, PlicoEventType, ProviderMessage, ReadinessDiagnostic, ReadinessOptions, ReadinessReport, RunEvalsOptions, RunProjectOptions, RunResult, RunStatus, RunSummary, ToolApprovalPolicy, ToolArtifactContext, ToolArtifactFile, ToolDefinition, ToolHandlerContext, ToolInputParseResult, ToolInputSchema, ZodInputParseResult, ZodInputSchema, } from "./types/index.js";

package/dist/index.js

@@ -0,0 +1,17 @@
+export { buildArtifactWorkspace, readArtifactSnapshot, readArtifactVersion } from "./artifacts.js";
+export { createEngine, createMemoryJournal, createSqliteEngine, ProjectChangedError, } from "./engine/index.js";
+export { loadedEnvFiles, loadProjectEnv } from "./env.js";
+export { ModelProviderError } from "./errors.js";
+export { evalCaseFromRun, runEvals } from "./evals/index.js";
+export { runFailureEvents } from "./events.js";
+export { composeInstructions } from "./instructions.js";
+export { createConfiguredModelProvider, modelProviderAccountKey, modelProviderRecoveryKey, supportsModelProvider, } from "./providers/configured.js";
+export { createOpenAICompatibleProvider, } from "./providers/openai-compatible.js";
+export { checkReadiness } from "./readiness/index.js";
+export { recoverRuns, runProject } from "./run/index.js";
+export { normalizeScript, ScriptValidationError } from "./script.js";
+export { createSqliteEventStore } from "./storage/index.js";
+export { matchesMetadata } from "./storage/metadata.js";
+export { createSqliteThreadStore, ThreadBusyError, } from "./storage/sqlite/threads.js";
+export { createThreadTitler } from "./threads/titler.js";
+export { discoverTools } from "./tools/index.js";

package/dist/instructions.d.ts

@@ -0,0 +1,4 @@
+import { type LoadedProject, type Skill } from "@plico-ai/core";
+import type { ComposedInstructions } from "./types/index.js";
+/** The agent's instructions plus a list of skills. A skill's full text loads on demand. */
+export declare function composeInstructions(project: LoadedProject, loaded?: Skill[]): Promise<ComposedInstructions>;

package/dist/instructions.js

@@ -0,0 +1,23 @@
+import { readFile } from "node:fs/promises";
+import { getProjectPaths, getProjectRelativePaths, parseAgentFile, readSkills, SKILL_TOOL_NAME, } from "@plico-ai/core";
+/** The agent's instructions plus a list of skills. A skill's full text loads on demand. */
+export async function composeInstructions(project, loaded) {
+    const projectPaths = getProjectPaths(project.root);
+    const sources = [getProjectRelativePaths().agentFile];
+    const parts = [parseAgentFile(await readFile(projectPaths.agentFile, "utf8")).body];
+    const skills = loaded ?? (await readSkills(project.root)).skills;
+    if (skills.length > 0) {
+        sources.push(...skills.map((skill) => skill.source));
+        parts.push([
+            "## Skills",
+            "",
+            `Call ${SKILL_TOOL_NAME} with a skill's name to read its full instructions before you use it.`,
+            "",
+            ...skills.map((skill) => `- ${skill.name}: ${skill.description}`),
+        ].join("\n"));
+    }
+    return {
+        sources,
+        content: parts.map((part) => part.trimEnd()).join("\n\n"),
+    };
+}

package/dist/policy/approval.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectConfig } from "@plico-ai/contracts";
+import type { DeclaredTool } from "../types/tools.js";
+export type ApprovalDecision = "none" | "required";
+export declare function decideApproval(tool: DeclaredTool, config: ProjectConfig): {
+    required: boolean;
+    reason?: string;
+};
+export declare function approvalTimeoutMs(config: ProjectConfig): number;

package/dist/policy/approval.js

@@ -0,0 +1,27 @@
+export function decideApproval(tool, config) {
+    const policy = config.approvals;
+    const override = policy?.tools?.[tool.name];
+    let decision;
+    if (override === "required" || override === "none") {
+        decision = override;
+    }
+    else if (tool.approval.required) {
+        decision = "required";
+    }
+    else if (policy?.default === "required") {
+        decision = "required";
+    }
+    else {
+        decision = "none";
+    }
+    // Config can escalate but never silently drop a tool-declared requirement.
+    if (tool.approval.required && decision === "none") {
+        decision = "required";
+    }
+    return tool.approval.reason
+        ? { required: decision === "required", reason: tool.approval.reason }
+        : { required: decision === "required" };
+}
+export function approvalTimeoutMs(config) {
+    return config.approvals?.timeoutMs ?? 30 * 60 * 1000;
+}

package/dist/providers/ai-sdk.d.ts

@@ -0,0 +1,10 @@
+import { type LanguageModel } from "ai";
+import type { ModelProvider } from "../types/index.js";
+export interface AiSdkProviderOptions {
+    /** The variable that holds the credential. Without one, the model is built with no key. */
+    apiKeyEnv?: string | undefined;
+    /** Builds the AI SDK model once the credential is known. */
+    createModel: (apiKey: string | undefined) => LanguageModel | Promise<LanguageModel>;
+}
+/** Wraps an AI SDK language model behind the Plico model port. Provider retries are off. */
+export declare function createAiSdkModelProvider(options: AiSdkProviderOptions): ModelProvider;

package/dist/providers/ai-sdk.js

@@ -0,0 +1,154 @@
+import { APICallError, dynamicTool, jsonSchema, streamText, } from "ai";
+import { ModelProviderError } from "../errors.js";
+function toMessages(request) {
+    return request.messages.map((message) => {
+        if (message.role === "system" || message.role === "user")
+            return { role: message.role, content: message.content };
+        if (message.role === "tool")
+            return {
+                role: "tool",
+                content: [
+                    {
+                        type: "tool-result",
+                        toolCallId: message.toolCallId ?? "",
+                        toolName: message.toolName ?? "",
+                        output: { type: "text", value: message.content },
+                    },
+                ],
+            };
+        const metadata = message.providerMetadata;
+        const envelope = metadata && typeof metadata === "object" && !Array.isArray(metadata) ? metadata : undefined;
+        const adapter = envelope?.plicoAdapter;
+        const reasoning = adapter &&
+            typeof adapter === "object" &&
+            !Array.isArray(adapter) &&
+            typeof adapter.reasoning === "string"
+            ? adapter.reasoning
+            : undefined;
+        const providerOptions = (envelope?.sdk ?? metadata);
+        return {
+            role: "assistant",
+            ...(providerOptions === undefined ? {} : { providerOptions }),
+            content: [
+                ...(reasoning ? [{ type: "reasoning", text: reasoning }] : []),
+                ...(message.content ? [{ type: "text", text: message.content }] : []),
+                ...(message.toolCalls ?? []).map((call) => ({
+                    type: "tool-call",
+                    toolCallId: call.id ?? "",
+                    toolName: call.name,
+                    input: call.arguments,
+                    ...(call.providerMetadata === undefined
+                        ? {}
+                        : {
+                            providerOptions: call.providerMetadata,
+                        }),
+                })),
+            ],
+        };
+    });
+}
+function toTools(request) {
+    return Object.fromEntries((request.tools ?? []).map((entry) => [
+        entry.name,
+        dynamicTool({ description: entry.description, inputSchema: jsonSchema(entry.inputSchema) }),
+    ]));
+}
+/** Wraps an AI SDK language model behind the Plico model port. Provider retries are off. */
+export function createAiSdkModelProvider(options) {
+    return {
+        async *stream(request, { signal }) {
+            try {
+                const apiKey = options.apiKeyEnv ? process.env[options.apiKeyEnv] : undefined;
+                if (options.apiKeyEnv && !apiKey)
+                    throw new ModelProviderError("auth", `Missing model provider credential: set ${options.apiKeyEnv}.`);
+                // Setup problems (a missing adapter package, a broken provider module) are local and
+                // actionable, so their message is kept. They are not a network failure and not retried.
+                let model;
+                try {
+                    model = await options.createModel(apiKey);
+                }
+                catch (error) {
+                    throw new ModelProviderError("bad_request", error instanceof Error ? error.message : "Model provider setup failed.");
+                }
+                const response = streamText({
+                    model,
+                    messages: toMessages(request),
+                    tools: toTools(request),
+                    allowSystemInMessages: true,
+                    maxRetries: 0,
+                    streamRetries: 0,
+                    abortSignal: signal,
+                    onError: () => { },
+                });
+                let metadata;
+                let reasoning = "";
+                for await (const part of response.fullStream) {
+                    if (part.type === "text-delta")
+                        yield { type: "text", text: part.text };
+                    else if (part.type === "reasoning-delta")
+                        reasoning += part.text;
+                    else if (part.type === "tool-call")
+                        yield {
+                            type: "tool.call",
+                            call: {
+                                id: part.toolCallId,
+                                name: part.toolName,
+                                arguments: part.input,
+                                ...(part.providerMetadata
+                                    ? { providerMetadata: part.providerMetadata }
+                                    : {}),
+                            },
+                        };
+                    else if (part.type === "finish-step")
+                        metadata = part.providerMetadata;
+                    else if (part.type === "error")
+                        throw part.error;
+                    else if (part.type === "finish") {
+                        if (part.finishReason !== "stop" && part.finishReason !== "tool-calls")
+                            throw new ModelProviderError("bad_request", `Model response did not complete (finish reason: ${part.finishReason}).`);
+                        yield {
+                            type: "finish",
+                            usage: {
+                                inputTokens: part.totalUsage.inputTokens ?? 0,
+                                outputTokens: part.totalUsage.outputTokens ?? 0,
+                            },
+                            ...(!reasoning && metadata === undefined
+                                ? {}
+                                : {
+                                    providerMetadata: {
+                                        ...(metadata === undefined ? {} : { sdk: metadata }),
+                                        ...(reasoning ? { plicoAdapter: { reasoning } } : {}),
+                                    },
+                                }),
+                        };
+                    }
+                }
+            }
+            catch (error) {
+                if (signal.aborted)
+                    throw new ModelProviderError("aborted", "Model request aborted.");
+                if (error instanceof ModelProviderError)
+                    throw error;
+                if (APICallError.isInstance(error)) {
+                    const status = error.statusCode;
+                    if (status === 401 || status === 403)
+                        throw new ModelProviderError("auth", "Model provider authentication failed. Check credentials.");
+                    if (status === 429)
+                        throw new ModelProviderError("rate_limit", "Model provider rate limit reached.");
+                    if (status === 503 || (status !== undefined && status >= 500))
+                        throw new ModelProviderError("overloaded", "Model provider is unavailable.");
+                    if (status !== undefined && status >= 400 && isContextLengthError(error))
+                        throw new ModelProviderError("context_length", "The conversation is too long for the model's context window. Start a new thread, or choose a model with a larger context.");
+                    if (status !== undefined && status >= 400)
+                        throw new ModelProviderError("bad_request", `Model provider rejected the request (HTTP ${status}).`);
+                }
+                throw new ModelProviderError("network", "Model provider request failed.");
+            }
+        },
+    };
+}
+const CONTEXT_LENGTH = /context[_ ]length|context window|prompt is too long|too many tokens|exceeds? the maximum (number of )?tokens|input token count/i;
+/** Providers word this differently, so match the code and message they return for an over-long input. */
+function isContextLengthError(error) {
+    return CONTEXT_LENGTH.test(`${error.message} ${error.responseBody ?? ""}`);
+}

package/dist/providers/configured.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectConfig } from "@plico-ai/contracts";
+import type { ModelProvider } from "../types/index.js";
+type ModelConfig = NonNullable<ProjectConfig["model"]>;
+export declare function supportsModelProvider(provider: string): boolean;
+/**
+ * The model port for a project's configured model. A provider outside the native list comes from
+ * `providers/<name>.ts` and needs the project root; without it there is no adapter.
+ */
+export declare function createConfiguredModelProvider(model: ModelConfig, projectRoot?: string): ModelProvider | undefined;
+/** Hash the provider target and credential without storing either secret in the journal. */
+export declare function modelProviderRecoveryKey(model: ModelConfig): string;
+/**
+ * Hash only the account and credential. A queued run has not called a model yet, so changing the
+ * configured model must not strand its reservation.
+ */
+export declare function modelProviderAccountKey(model: ModelConfig): string;
+export {};

package/dist/providers/configured.js

@@ -0,0 +1,60 @@
+import { createHash } from "node:crypto";
+import { NATIVE_MODEL_PROVIDERS } from "@plico-ai/core";
+import { createAiSdkModelProvider } from "./ai-sdk.js";
+import { createOpenAICompatibleProvider } from "./openai-compatible.js";
+import { createProjectModuleProvider } from "./project-module.js";
+import { nativeProvider, resolveModelEndpoint } from "./registry.js";
+export function supportsModelProvider(provider) {
+    return NATIVE_MODEL_PROVIDERS.includes(provider);
+}
+/**
+ * The model port for a project's configured model. A provider outside the native list comes from
+ * `providers/<name>.ts` and needs the project root; without it there is no adapter.
+ */
+export function createConfiguredModelProvider(model, projectRoot) {
+    const { apiKeyEnv, baseURL } = resolveModelEndpoint(model);
+    const native = nativeProvider(model.provider);
+    if (native)
+        return createAiSdkModelProvider({
+            apiKeyEnv,
+            createModel: async (apiKey) => (await native.create({
+                model: model.name,
+                apiKey: apiKey ?? "",
+                baseURL,
+            })),
+        });
+    if (model.provider === "openai-compatible")
+        return createOpenAICompatibleProvider({
+            model: model.name,
+            baseURL,
+            ...(apiKeyEnv ? { apiKeyEnv } : {}),
+        });
+    if (!projectRoot)
+        return undefined;
+    return createProjectModuleProvider(projectRoot, model.provider, {
+        model: model.name,
+        apiKeyEnv,
+        ...(model.baseURL ? { baseURL: model.baseURL } : {}),
+    });
+}
+function hashParts(parts) {
+    return createHash("sha256").update(JSON.stringify(parts)).digest("hex");
+}
+/** Hash the provider target and credential without storing either secret in the journal. */
+export function modelProviderRecoveryKey(model) {
+    const { apiKeyEnv, baseURL } = resolveModelEndpoint(model);
+    return hashParts([
+        model.provider,
+        model.name,
+        baseURL,
+        (apiKeyEnv ? process.env[apiKeyEnv] : "") ?? "",
+    ]);
+}
+/**
+ * Hash only the account and credential. A queued run has not called a model yet, so changing the
+ * configured model must not strand its reservation.
+ */
+export function modelProviderAccountKey(model) {
+    const { apiKeyEnv, baseURL } = resolveModelEndpoint(model);
+    return hashParts([model.provider, baseURL, (apiKeyEnv ? process.env[apiKeyEnv] : "") ?? ""]);
+}

package/dist/providers/openai-compatible.d.ts

@@ -0,0 +1,8 @@
+import type { ModelProvider } from "../types/index.js";
+export interface OpenAICompatibleProviderOptions {
+    model: string;
+    apiKeyEnv?: string;
+    baseURL?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare function createOpenAICompatibleProvider(options: OpenAICompatibleProviderOptions): ModelProvider;

package/dist/providers/openai-compatible.js

@@ -0,0 +1,14 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import { createAiSdkModelProvider } from "./ai-sdk.js";
+export function createOpenAICompatibleProvider(options) {
+    return createAiSdkModelProvider({
+        apiKeyEnv: options.apiKeyEnv ?? "OPENAI_API_KEY",
+        createModel: (apiKey) => createOpenAICompatible({
+            name: "plico",
+            baseURL: options.baseURL ?? "https://api.openai.com/v1",
+            ...(apiKey ? { apiKey } : {}),
+            includeUsage: true,
+            ...(options.fetch ? { fetch: options.fetch } : {}),
+        })(options.model),
+    });
+}

package/dist/providers/project-module.d.ts

@@ -0,0 +1,7 @@
+import type { ModelProvider } from "../types/index.js";
+/** A provider the project supplies in `providers/<name>.ts`, run behind the Plico model port. */
+export declare function createProjectModuleProvider(root: string, provider: string, input: {
+    model: string;
+    apiKeyEnv: string | undefined;
+    baseURL?: string;
+}): ModelProvider;

package/dist/providers/project-module.js

@@ -0,0 +1,29 @@
+import { pathToFileURL } from "node:url";
+import { findProjectProviderFile } from "@plico-ai/core";
+import { register } from "tsx/esm/api";
+import { createAiSdkModelProvider } from "./ai-sdk.js";
+let registered = false;
+/** A provider the project supplies in `providers/<name>.ts`, run behind the Plico model port. */
+export function createProjectModuleProvider(root, provider, input) {
+    return createAiSdkModelProvider({
+        apiKeyEnv: input.apiKeyEnv,
+        createModel: async (apiKey) => {
+            const file = await findProjectProviderFile(root, provider);
+            if (!file)
+                throw new Error(`Missing model provider module: providers/${provider}.ts`);
+            if (!registered) {
+                register();
+                registered = true;
+            }
+            const loaded = (await import(pathToFileURL(file).href));
+            if (typeof loaded.default !== "function")
+                throw new Error(`providers/${provider} must export a function by default.`);
+            const options = {
+                model: input.model,
+                ...(apiKey ? { apiKey } : {}),
+                ...(input.baseURL ? { baseURL: input.baseURL } : {}),
+            };
+            return (await loaded.default(options));
+        },
+    });
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,20 @@
+import type { ProjectConfig } from "@plico-ai/contracts";
+type ModelConfig = NonNullable<ProjectConfig["model"]>;
+interface NativeProvider {
+    apiKeyEnv: string;
+    /** The endpoint used when neither the config nor the environment sets one. */
+    baseURL: string;
+    /** Returns an AI SDK language model. Adapter packages may pin another `@ai-sdk/provider` copy, so it is typed loosely here. */
+    create: (input: {
+        model: string;
+        apiKey: string;
+        baseURL: string;
+    }) => Promise<unknown>;
+}
+export declare function nativeProvider(provider: string): NativeProvider | undefined;
+/** The credential variable and endpoint a configured model uses, for the run and the recovery key. */
+export declare function resolveModelEndpoint(model: ModelConfig): {
+    apiKeyEnv: string | undefined;
+    baseURL: string;
+};
+export {};

package/dist/providers/registry.js

@@ -0,0 +1,53 @@
+/** The adapters are optional peer packages, so each loads only when its provider is used. */
+async function load(packageName, importer) {
+    try {
+        return await importer();
+    }
+    catch {
+        throw new Error(`Install ${packageName} to use this model provider: pnpm add ${packageName}`);
+    }
+}
+const OPENAI_URL = "https://api.openai.com/v1";
+const NATIVE = {
+    anthropic: {
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        baseURL: "https://api.anthropic.com/v1",
+        create: async ({ model, apiKey, baseURL }) => (await load("@ai-sdk/anthropic", () => import("@ai-sdk/anthropic"))).createAnthropic({
+            apiKey,
+            baseURL,
+        })(model),
+    },
+    google: {
+        apiKeyEnv: "GOOGLE_GENERATIVE_AI_API_KEY",
+        baseURL: "https://generativelanguage.googleapis.com/v1beta",
+        create: async ({ model, apiKey, baseURL }) => (await load("@ai-sdk/google", () => import("@ai-sdk/google"))).createGoogleGenerativeAI({
+            apiKey,
+            baseURL,
+        })(model),
+    },
+    openai: {
+        apiKeyEnv: "OPENAI_API_KEY",
+        baseURL: OPENAI_URL,
+        // The chat endpoint is the one every OpenAI-compatible server also speaks.
+        create: async ({ model, apiKey, baseURL }) => (await load("@ai-sdk/openai", () => import("@ai-sdk/openai")))
+            .createOpenAI({ apiKey, baseURL })
+            .chat(model),
+    },
+};
+export function nativeProvider(provider) {
+    return NATIVE[provider];
+}
+/** The credential variable and endpoint a configured model uses, for the run and the recovery key. */
+export function resolveModelEndpoint(model) {
+    const native = nativeProvider(model.provider);
+    const usesOpenAIEnv = model.provider === "openai" || model.provider === "openai-compatible";
+    return {
+        apiKeyEnv: model.apiKeyEnv ??
+            native?.apiKeyEnv ??
+            (model.provider === "openai-compatible" ? "OPENAI_API_KEY" : undefined),
+        baseURL: model.baseURL ??
+            (usesOpenAIEnv ? process.env.OPENAI_BASE_URL : undefined) ??
+            native?.baseURL ??
+            OPENAI_URL,
+    };
+}

package/dist/readiness/check-readiness.d.ts

@@ -0,0 +1,2 @@
+import type { ReadinessOptions, ReadinessReport } from "../types/index.js";
+export declare function checkReadiness(projectRoot: string, options?: ReadinessOptions): Promise<ReadinessReport>;