@nylorun/runtime 0.3.0-beta → 0.5.0-beta

package/dist/launcher.js

@@ -0,0 +1,33 @@
+import { serve } from "@hono/node-server";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { installNodeModelFactory, installRuntimeLifecycle, } from "./model/defaults.js";
+import { piModel } from "./model/pi-model.js";
+import { loadProjectEnvironment } from "./environment.js";
+export async function start(entry = "dist/src/index.js", development = false) {
+    loadProjectEnvironment();
+    if (development)
+        process.env.NYLORUN_DEV = "1";
+    else
+        delete process.env.NYLORUN_DEV;
+    const port = Number(process.env.PORT ?? "3000");
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new Error("PORT must be an integer between 1 and 65535.");
+    const shutdowns = new Set();
+    installRuntimeLifecycle((close) => shutdowns.add(close));
+    installNodeModelFactory((options) => piModel({ onPreview: options.onPreview, media: options.media }));
+    const { default: app } = await import(pathToFileURL(resolve(entry)).href);
+    if (!app || typeof app.fetch !== "function")
+        throw new Error(`${entry} must export a Hono application with 'export default app' and a callable fetch.`);
+    const server = serve({ fetch: app.fetch.bind(app), port }, (info) => {
+        console.log(`Server is running on http://localhost:${info.port}`);
+    });
+    const stop = () => {
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        void Promise.allSettled([...shutdowns].map((close) => close())).then(() => server.close());
+        setTimeout(() => process.exit(0), 5_000).unref();
+    };
+    process.once("SIGINT", stop);
+    process.once("SIGTERM", stop);
+}

package/dist/media.d.ts

@@ -0,0 +1,29 @@
+export declare const IMAGE_MEDIA_TYPES: readonly string[];
+export declare const MAX_IMAGE_BYTES: number;
+export interface MediaAsset {
+    readonly id: string;
+    readonly mediaType: string;
+    readonly bytes: number;
+    readonly kind: "input" | "generated";
+}
+/** Opaque reference retained by Harness and resolved by the configured media adapter. */
+export interface MediaReference {
+    readonly agentId: string;
+    readonly assetId: string;
+}
+export declare function decodeImageBase64(mediaType: string, base64: string): Uint8Array;
+/** Verify the asserted media type and lightweight file signature for a supported image. */
+export declare function validateImageBytes(mediaType: string, bytes: Uint8Array): void;
+export interface RuntimeMedia {
+    saveInput(agentId: string, sessionId: string, mediaType: string, base64: string): Promise<MediaAsset>;
+    saveGenerated(agentId: string, sessionId: string, mediaType: string, bytes: Uint8Array): Promise<MediaAsset>;
+    dataUrl(reference: MediaReference, sessionId: string): Promise<{
+        readonly asset: MediaAsset;
+        readonly url: string;
+    } | undefined>;
+    latestInput(agentId: string, sessionId: string): Promise<MediaAsset | undefined>;
+    read(agentId: string, sessionId: string, assetId: string): Promise<{
+        asset: MediaAsset;
+        bytes: Uint8Array;
+    } | undefined>;
+}

package/dist/media.js

@@ -0,0 +1,53 @@
+export const IMAGE_MEDIA_TYPES = Object.freeze([
+    "image/jpeg",
+    "image/png",
+    "image/webp",
+]);
+export const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+export function decodeImageBase64(mediaType, base64) {
+    if (!IMAGE_MEDIA_TYPES.includes(mediaType))
+        throw new Error("Only JPEG, PNG, and WebP images are supported.");
+    if (typeof base64 !== "string" || base64 === "")
+        throw new Error("Image data is required.");
+    if (base64.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(base64))
+        throw new Error("Image data must be canonical base64.");
+    const decoded = atob(base64);
+    const bytes = Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+    if (btoa(decoded) !== base64)
+        throw new Error("Image data must be canonical base64.");
+    validateImageBytes(mediaType, bytes);
+    return bytes;
+}
+/** Verify the asserted media type and lightweight file signature for a supported image. */
+export function validateImageBytes(mediaType, bytes) {
+    if (!IMAGE_MEDIA_TYPES.includes(mediaType))
+        throw new Error("Only JPEG, PNG, and WebP images are supported.");
+    if (bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES)
+        throw new Error("Images must be no larger than 8 MiB.");
+    const signature = mediaType === "image/jpeg"
+        ? bytes.byteLength >= 3 &&
+            bytes[0] === 0xff &&
+            bytes[1] === 0xd8 &&
+            bytes[2] === 0xff
+        : mediaType === "image/png"
+            ? bytes.byteLength >= 8 &&
+                bytes[0] === 0x89 &&
+                bytes[1] === 0x50 &&
+                bytes[2] === 0x4e &&
+                bytes[3] === 0x47 &&
+                bytes[4] === 0x0d &&
+                bytes[5] === 0x0a &&
+                bytes[6] === 0x1a &&
+                bytes[7] === 0x0a
+            : bytes.byteLength >= 12 &&
+                bytes[0] === 0x52 &&
+                bytes[1] === 0x49 &&
+                bytes[2] === 0x46 &&
+                bytes[3] === 0x46 &&
+                bytes[8] === 0x57 &&
+                bytes[9] === 0x45 &&
+                bytes[10] === 0x42 &&
+                bytes[11] === 0x50;
+    if (!signature)
+        throw new Error(`Image bytes do not match ${mediaType}.`);
+}

package/dist/model/auth-store.d.ts

@@ -2,7 +2,8 @@ import type { Credential, CredentialInfo, CredentialStore } from "@earendil-work
 export declare class ProjectCredentialStore implements CredentialStore {
     #private;
     private readonly file;
-    constructor(file?: string);
+    private readonly legacyFile?;
+    constructor(file?: string, legacyFile?: string | undefined);
     read(providerId: string): Promise<Credential | undefined>;
     list(): Promise<readonly CredentialInfo[]>;
     modify(providerId: string, fn: (current: Credential | undefined) => Promise<Credential | undefined>): Promise<Credential | undefined>;

package/dist/model/auth-store.js

@@ -1,10 +1,13 @@
+var _a;
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 export class ProjectCredentialStore {
     file;
+    legacyFile;
     #chain = Promise.resolve();
-    constructor(file = join(process.cwd(), ".env", "auth.json")) {
+    constructor(file = join(process.cwd(), ".nylorun", "auth.json"), legacyFile) {
         this.file = file;
+        this.legacyFile = legacyFile;
     }
     async read(providerId) {
         return (await this.#all())[providerId];
@@ -54,8 +57,11 @@ export class ProjectCredentialStore {
             return JSON.parse(await readFile(this.file, "utf8"));
         }
         catch (error) {
-            if (error.code === "ENOENT")
+            if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) {
+                if (this.legacyFile)
+                    return new _a(this.legacyFile).#all();
                 return {};
+            }
             throw error;
         }
     }
@@ -83,3 +89,4 @@ export class ProjectCredentialStore {
         }
     }
 }
+_a = ProjectCredentialStore;

package/dist/model/configure.js

@@ -1,7 +1,6 @@
-import { mkdir, writeFile, rename, rm, rmdir } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { createInterface } from "node:readline/promises";
+import { saveEnvironment } from "../environment.js";
 import { ProjectCredentialStore } from "./auth-store.js";
 import { modelsFor } from "./models.js";
 export class ConfigurationCancelled extends Error {
@@ -21,7 +20,25 @@ export async function configureProvider(options = {}) {
     const signal = controller.signal;
     const forwardAbort = () => controller.abort(options.signal.reason);
     options.signal?.throwIfAborted();
-    const store = new ProjectCredentialStore(join(root, ".env", "auth.json"));
+    let enteredKey;
+    let enteredEnvironment = {};
+    const oauthStore = new ProjectCredentialStore(join(root, ".nylorun", "auth.json"), join(root, ".env", "auth.json"));
+    const store = {
+        read: (id) => oauthStore.read(id),
+        list: () => oauthStore.list(),
+        delete: (id) => oauthStore.delete(id),
+        async modify(id, fn) {
+            const next = await fn(await oauthStore.read(id));
+            if (next?.type === "api_key") {
+                if (next.key === "")
+                    throw new Error("An API key is required.");
+                enteredKey = next.key;
+                enteredEnvironment = { ...next.env };
+                return next;
+            }
+            return oauthStore.modify(id, async () => next);
+        },
+    };
     const models = modelsFor({ provider: "", model: "" }, store);
     const providers = models.getProviders();
     const prompt = createInterface({
@@ -59,7 +76,8 @@ export async function configureProvider(options = {}) {
                 custom: { baseUrl },
             };
             const customModels = modelsFor(selection, store);
-            await customModels.login("custom", "api_key", interaction());
+            if (!(await customModels.checkAuth("custom", { signal })))
+                await customModels.login("custom", "api_key", interaction());
             await save(selection);
         }
         else {
@@ -72,7 +90,17 @@ export async function configureProvider(options = {}) {
             if (!model)
                 throw new Error("Choose a listed model.");
             if (!(await models.checkAuth(chosen.id, { signal }))) {
-                await models.login(chosen.id, chosen.auth.oauth ? "oauth" : "api_key", interaction());
+                let method = chosen.auth.apiKey
+                    ? "api_key"
+                    : "oauth";
+                if (chosen.auth.apiKey && chosen.auth.oauth) {
+                    const answer = (await question("Choose authentication: 1. API key (default), 2. OAuth: ")).trim();
+                    if (answer && !["1", "2"].includes(answer))
+                        throw new Error("Choose authentication 1 or 2.");
+                    if (answer === "2")
+                        method = "oauth";
+                }
+                await models.login(chosen.id, method, interaction());
             }
             await save({ provider: chosen.id, model: model.id });
         }
@@ -92,34 +120,36 @@ export async function configureProvider(options = {}) {
     function interaction() {
         return {
             signal,
-            prompt: async (item) => question(item.message + ": "),
-            notify: (event) => output.write((event.url ?? event.verificationUri ?? event.message) + "\n"),
+            prompt: async (item) => {
+                if (item.type !== "select")
+                    return question(item.message + ": ");
+                item.options.forEach((option, index) => output.write(`${index + 1}. ${option.label}\n`));
+                const answer = (await question(item.message + " ")).trim();
+                const option = item.options.find((option) => option.id === answer) ??
+                    item.options[Number(answer) - 1];
+                if (!option)
+                    throw new Error("Choose a listed authentication option.");
+                return option.id;
+            },
+            notify: (event) => {
+                output.write(("url" in event
+                    ? event.url
+                    : "verificationUri" in event
+                        ? event.verificationUri
+                        : event.message) + "\n");
+            },
         };
     }
     async function save(selection) {
         signal.throwIfAborted();
-        const directory = join(root, ".env");
-        const temporary = join(directory, `.model-${randomUUID()}.json`);
-        try {
-            await mkdir(directory, { recursive: true });
-            await writeFile(temporary, JSON.stringify(selection, null, 2) + "\n", {
-                signal,
-            });
-            signal.throwIfAborted();
-            await rename(temporary, join(directory, "model.json"));
-            await rm(join(root, "config", "model.json"), { force: true });
-            try {
-                await rmdir(join(root, "config"));
-            }
-            catch (error) {
-                if (!(error instanceof Error) ||
-                    !("code" in error) ||
-                    !["ENOENT", "ENOTEMPTY", "EEXIST"].includes(String(error.code)))
-                    throw error;
-            }
-        }
-        finally {
-            await rm(temporary, { force: true });
-        }
+        await saveEnvironment(root, {
+            ...enteredEnvironment,
+            MODEL_PROVIDER: selection.provider,
+            MODEL: selection.model,
+            MODEL_PROVIDER_BASE_URL: selection.custom?.baseUrl,
+            ...(enteredKey === undefined
+                ? {}
+                : { MODEL_PROVIDER_API_KEY: enteredKey }),
+        }, signal);
     }
 }

package/dist/model/defaults.d.ts

@@ -0,0 +1,17 @@
+import type { ModelAdapter } from "@nylorun/harness";
+import { type ModelEnvironment } from "./http-model.js";
+export interface ModelPreview {
+    readonly invocationId: string;
+    readonly text: string;
+}
+export interface ModelFactoryOptions {
+    readonly environment?: ModelEnvironment;
+    readonly media?: import("../media.js").RuntimeMedia;
+    readonly onPreview?: (preview: ModelPreview) => void;
+}
+/** Installed only by the Node launcher before application imports. */
+export declare function installNodeModelFactory(factory: (options: ModelFactoryOptions) => ModelAdapter): void;
+export declare function defaultModel(options: ModelFactoryOptions): ModelAdapter;
+export declare function processEnvironment(): ModelEnvironment;
+export declare function installRuntimeLifecycle(register: (close: () => Promise<void>) => void): void;
+export declare function registerRuntimeLifecycle(close: () => Promise<void>): void;

package/dist/model/defaults.js

@@ -0,0 +1,21 @@
+import { httpModel } from "./http-model.js";
+let nodeFactory;
+/** Installed only by the Node launcher before application imports. */
+export function installNodeModelFactory(factory) {
+    nodeFactory = factory;
+}
+export function defaultModel(options) {
+    return options.environment === undefined && nodeFactory
+        ? nodeFactory(options)
+        : httpModel(options);
+}
+export function processEnvironment() {
+    return typeof process === "undefined" ? {} : process.env;
+}
+let runtimeLifecycle;
+export function installRuntimeLifecycle(register) {
+    runtimeLifecycle = register;
+}
+export function registerRuntimeLifecycle(close) {
+    runtimeLifecycle?.(close);
+}

package/dist/model/http-model.d.ts

@@ -0,0 +1,12 @@
+import type { ModelAdapter } from "@nylorun/harness";
+import type { ModelFactoryOptions } from "./defaults.js";
+export type ModelEnvironment = Readonly<Record<string, string | undefined>>;
+export interface HttpModelOptions extends ModelFactoryOptions {
+    readonly provider?: "openai" | "custom" | "anthropic";
+    readonly model?: string;
+    readonly apiKey?: string;
+    readonly baseUrl?: string;
+    readonly fetch?: typeof fetch;
+}
+/** Fetch-only adapter for OpenAI-compatible and Anthropic HTTP endpoints. */
+export declare function httpModel(options?: HttpModelOptions): ModelAdapter;

package/dist/model/http-model.js

@@ -0,0 +1,299 @@
+/** Fetch-only adapter for OpenAI-compatible and Anthropic HTTP endpoints. */
+export function httpModel(options = {}) {
+    return async (call, context) => {
+        const env = options.environment ??
+            (typeof process === "undefined" ? {} : process.env);
+        const provider = options.provider ?? env.MODEL_PROVIDER;
+        const model = call.model?.id ?? options.model ?? env.MODEL;
+        const baseUrl = options.baseUrl ?? env.MODEL_PROVIDER_BASE_URL;
+        if (!provider || !model)
+            throw new Error("Set both MODEL_PROVIDER and MODEL, or supply a model adapter.");
+        if (!["openai", "custom", "anthropic"].includes(provider))
+            throw new Error(`The portable HTTP adapter does not support '${provider}'. Supply onModelCall or use the Node piModel adapter.`);
+        if (provider === "custom" && !baseUrl)
+            throw new Error("MODEL_PROVIDER=custom requires MODEL_PROVIDER_BASE_URL.");
+        const apiKey = options.apiKey ??
+            env.MODEL_PROVIDER_API_KEY ??
+            (provider === "anthropic" ? env.ANTHROPIC_API_KEY : env.OPENAI_API_KEY);
+        if (!apiKey)
+            throw new Error("Set MODEL_PROVIDER_API_KEY or the provider-native API key variable.");
+        const text = (parts) => parts
+            .flatMap((part) => (part.type === "text" ? [part.text] : []))
+            .join("\n");
+        if (call.prompt.some((item) => item.content.some((part) => part.type === "media")))
+            throw new Error("Supply a media-aware model adapter for media inputs.");
+        context.signal.throwIfAborted();
+        let body;
+        let url;
+        let headers;
+        const streaming = provider !== "anthropic" && options.onPreview !== undefined;
+        if (provider === "anthropic") {
+            const messages = call.prompt
+                .filter((item) => item.kind !== "instructions")
+                .map((item) => {
+                if (item.kind === "tool-result")
+                    return {
+                        role: "user",
+                        content: [
+                            {
+                                type: "tool_result",
+                                tool_use_id: item.toolCallId,
+                                content: text(item.content),
+                                is_error: item.status !== "completed",
+                            },
+                        ],
+                    };
+                return {
+                    role: item.role === "assistant" ? "assistant" : "user",
+                    content: item.content.flatMap((part) => part.type === "tool-call"
+                        ? [
+                            {
+                                type: "tool_use",
+                                id: part.id,
+                                name: part.name,
+                                input: part.args,
+                            },
+                        ]
+                        : part.type === "text"
+                            ? [{ type: "text", text: part.text }]
+                            : []),
+                };
+            });
+            body = {
+                model,
+                messages,
+                max_tokens: call.model?.controls?.maxOutputTokens ?? 4096,
+                system: call.prompt
+                    .filter((item) => item.kind === "instructions")
+                    .map((item) => text(item.content))
+                    .join("\n"),
+                ...(call.tools.length
+                    ? {
+                        tools: call.tools.map((tool) => ({
+                            name: tool.name,
+                            description: tool.description ?? "",
+                            input_schema: tool.inputSchema,
+                        })),
+                    }
+                    : {}),
+                ...(call.outputSchema
+                    ? {
+                        output_config: {
+                            format: { type: "json_schema", schema: call.outputSchema },
+                        },
+                    }
+                    : {}),
+                ...(call.model?.controls?.temperature === undefined
+                    ? {}
+                    : { temperature: call.model.controls.temperature }),
+            };
+            url = `${(baseUrl ?? "https://api.anthropic.com").replace(/\/$/, "")}/v1/messages`;
+            headers = {
+                "content-type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": "2023-06-01",
+            };
+        }
+        else {
+            const messages = call.prompt.map((item) => {
+                if (item.kind === "tool-result")
+                    return {
+                        role: "tool",
+                        tool_call_id: item.toolCallId,
+                        content: text(item.content),
+                    };
+                const calls = item.content
+                    .filter((part) => part.type === "tool-call")
+                    .map((part) => ({
+                    id: part.id,
+                    type: "function",
+                    function: { name: part.name, arguments: JSON.stringify(part.args) },
+                }));
+                return {
+                    role: item.kind === "instructions" ? "system" : item.role,
+                    content: text(item.content),
+                    ...(calls.length ? { tool_calls: calls } : {}),
+                };
+            });
+            body = {
+                model,
+                messages,
+                stream: streaming,
+                ...(call.tools.length
+                    ? {
+                        tools: call.tools.map((tool) => ({
+                            type: "function",
+                            function: {
+                                name: tool.name,
+                                description: tool.description,
+                                parameters: tool.inputSchema,
+                            },
+                        })),
+                    }
+                    : {}),
+                ...(call.outputSchema
+                    ? {
+                        response_format: {
+                            type: "json_schema",
+                            json_schema: {
+                                name: "agent_output",
+                                strict: true,
+                                schema: call.outputSchema,
+                            },
+                        },
+                    }
+                    : {}),
+                ...(call.model?.controls?.temperature === undefined
+                    ? {}
+                    : { temperature: call.model.controls.temperature }),
+                ...(call.model?.controls?.maxOutputTokens === undefined
+                    ? {}
+                    : { max_completion_tokens: call.model.controls.maxOutputTokens }),
+            };
+            url = `${(baseUrl ?? "https://api.openai.com/v1").replace(/\/$/, "")}/chat/completions`;
+            headers = {
+                "content-type": "application/json",
+                authorization: `Bearer ${apiKey}`,
+            };
+        }
+        if (!["https:", "http:"].includes(new URL(url).protocol))
+            throw new Error("Model endpoint must use HTTP(S).");
+        context.reportPreparedCall?.({
+            adapter: "runtime.http",
+            call: JSON.parse(JSON.stringify(body)),
+        });
+        const response = await (options.fetch ?? fetch)(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            signal: context.signal,
+        });
+        if (!response.ok)
+            throw new Error(`Model provider returned HTTP ${response.status}. Check the selected model, credentials, and endpoint.`);
+        let result;
+        if (streaming)
+            result = await readOpenAIStream(response, (value) => {
+                try {
+                    void Promise.resolve(options.onPreview?.({
+                        invocationId: context.invocationId,
+                        text: value,
+                    })).catch(() => { });
+                }
+                catch {
+                    /* Preview delivery cannot affect generation. */
+                }
+            });
+        else
+            result = await response.json();
+        context.signal.throwIfAborted();
+        const output = [];
+        if (provider === "anthropic") {
+            for (const part of result.content ?? []) {
+                if (part.type === "text")
+                    output.push(call.outputSchema &&
+                        !(result.content ?? []).some((item) => item.type === "tool_use")
+                        ? { type: "json", value: JSON.parse(part.text) }
+                        : { type: "text", text: part.text });
+                if (part.type === "tool_use")
+                    output.push({
+                        type: "tool-call",
+                        id: part.id,
+                        name: part.name,
+                        args: part.input,
+                    });
+            }
+        }
+        else {
+            const message = result.choices?.[0]?.message;
+            if (!message)
+                throw new Error("Model provider returned no message.");
+            if (message.content)
+                output.push(call.outputSchema && !message.tool_calls?.length
+                    ? { type: "json", value: JSON.parse(message.content) }
+                    : { type: "text", text: message.content });
+            for (const tool of message.tool_calls ?? [])
+                output.push({
+                    type: "tool-call",
+                    id: tool.id,
+                    name: tool.function.name,
+                    args: JSON.parse(tool.function.arguments),
+                });
+        }
+        return { output, evidence: { resolvedModel: result.model ?? model } };
+    };
+}
+async function readOpenAIStream(response, preview) {
+    if (!response.body)
+        throw new Error("Model provider returned no stream.");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "", content = "", complete = false;
+    const calls = new Map();
+    const line = (value) => {
+        if (!value.startsWith("data:"))
+            return;
+        const data = value.slice(5).trim();
+        if (data === "[DONE]") {
+            complete = true;
+            return;
+        }
+        if (!data)
+            return;
+        const chunk = JSON.parse(data);
+        if (chunk.error)
+            throw new Error("Model provider reported a streaming error.");
+        const delta = chunk.choices?.[0]?.delta;
+        if (typeof delta?.content === "string") {
+            content += delta.content;
+            preview(delta.content);
+        }
+        for (const tool of delta?.tool_calls ?? []) {
+            const target = calls.get(tool.index) ?? {
+                id: "",
+                type: "function",
+                function: { name: "", arguments: "" },
+            };
+            if (tool.id)
+                target.id = tool.id;
+            if (tool.function?.name)
+                target.function.name += tool.function.name;
+            if (tool.function?.arguments)
+                target.function.arguments += tool.function.arguments;
+            calls.set(tool.index, target);
+        }
+    };
+    try {
+        while (!complete) {
+            const next = await reader.read();
+            buffer += decoder.decode(next.value, { stream: !next.done });
+            let end;
+            while ((end = buffer.indexOf("\n")) >= 0) {
+                line(buffer.slice(0, end).replace(/\r$/, ""));
+                buffer = buffer.slice(end + 1);
+            }
+            if (next.done) {
+                if (buffer)
+                    line(buffer);
+                break;
+            }
+        }
+        if (!complete)
+            throw new Error("Model stream ended before completion.");
+        return {
+            choices: [
+                {
+                    message: {
+                        content,
+                        tool_calls: [...calls]
+                            .sort(([a], [b]) => a - b)
+                            .map(([, value]) => value),
+                    },
+                },
+            ],
+        };
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

package/dist/model/models.d.ts

@@ -1,4 +1,4 @@
-import type { ProjectCredentialStore } from "./auth-store.js";
+import { type CredentialStore } from "@earendil-works/pi-ai";
 export type Selection = Readonly<{
     provider: string;
     model: string;
@@ -6,4 +6,4 @@ export type Selection = Readonly<{
         baseUrl: string;
     }>;
 }>;
-export declare function modelsFor(selection: Selection, credentials: ProjectCredentialStore): import("@earendil-works/pi-ai").MutableModels;
+export declare function modelsFor(selection: Selection, credentials: CredentialStore): import("@earendil-works/pi-ai").MutableModels;