localpi 0.2.0 → 0.4.0

package/dist/src/localpi/model-profile.js

@@ -0,0 +1,98 @@
+import { readFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { asObject, requiredString } from "../common/json.js";
+import { normalizeBaseUrl } from "../llm/openai.js";
+export async function loadLocalModelProfile(options) {
+    if (options.modelProfileFile === undefined) {
+        return undefined;
+    }
+    const raw = await readFile(expandHome(options.modelProfileFile), "utf8");
+    return parseLocalModelProfile(JSON.parse(raw), options.modelProfileFile);
+}
+export function profileMatchesModel(profile, modelId) {
+    return modelId === profile.model || modelId === profile.id;
+}
+export function profileMatchesBaseUrl(profile, baseUrl) {
+    return (profile.baseUrl === undefined || normalizeBaseUrl(profile.baseUrl) === normalizeBaseUrl(baseUrl));
+}
+function parseLocalModelProfile(value, source) {
+    const root = asObject(value, `model profile ${source}`);
+    const client = optionalObject(root["client"], `model profile ${source} client`);
+    const capabilities = optionalObject(root["capabilities"], `model profile ${source} capabilities`);
+    const contextWindow = client === undefined
+        ? undefined
+        : optionalPositiveInteger(client["context_window"], `model profile ${source} client.context_window`);
+    const maxTokens = client === undefined
+        ? undefined
+        : optionalPositiveInteger(client["max_tokens"], `model profile ${source} client.max_tokens`);
+    const reasoning = capabilities === undefined
+        ? undefined
+        : optionalBoolean(capabilities["reasoning"], `model profile ${source} capabilities.reasoning`);
+    const thinkingFormat = capabilities === undefined
+        ? undefined
+        : optionalThinkingFormat(optionalProfileString(capabilities["thinking_format"], `model profile ${source} capabilities.thinking_format`), `model profile ${source} capabilities.thinking_format`);
+    return withoutUndefined({
+        id: requiredString(root["id"], `model profile ${source} id`),
+        model: requiredString(root["model"], `model profile ${source} model`),
+        baseUrl: optionalProfileString(root["base_url"], `model profile ${source} base_url`),
+        client: client === undefined
+            ? undefined
+            : withoutUndefined({
+                contextWindow,
+                maxTokens
+            }),
+        capabilities: capabilities === undefined
+            ? undefined
+            : withoutUndefined({
+                reasoning,
+                thinkingFormat
+            })
+    });
+}
+function optionalObject(value, context) {
+    return value === undefined ? undefined : asObject(value, context);
+}
+function optionalProfileString(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${context} must be a string`);
+    }
+    return value;
+}
+function optionalBoolean(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "boolean") {
+        throw new Error(`${context} must be a boolean`);
+    }
+    return value;
+}
+function optionalPositiveInteger(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${context} must be a positive integer`);
+    }
+    return value;
+}
+function optionalThinkingFormat(value, context) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === "deepseek" || value === "qwen-chat-template") {
+        return value;
+    }
+    throw new Error(`${context} must be deepseek or qwen-chat-template`);
+}
+function expandHome(value) {
+    const home = os.homedir();
+    return value === "~" || value.startsWith("~/") ? path.join(home, value.slice(2)) : value;
+}
+function withoutUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entryValue]) => entryValue !== undefined));
+}

package/dist/src/localpi/options.js

@@ -18,10 +18,13 @@ export function defaultOptions() {
         provider: process.env["LOCALPI_PROVIDER"],
         customProviderId: envString("LOCALPI_PROVIDER_ID", "local-openai"),
         providersFile: process.env["LOCALPI_PROVIDERS_FILE"],
+        modelProfileFile: process.env["LOCALPI_MODEL_PROFILE"] ?? process.env["LOCALPAGER_AGENT_PROFILE"],
+        modelReasoning: envOptionalBoolean("LOCALPI_MODEL_REASONING", "LOCALPAGER_AGENT_REASONING"),
+        modelThinkingFormat: envOptionalThinkingFormat("LOCALPI_MODEL_THINKING_FORMAT", "LOCALPAGER_AGENT_THINKING_FORMAT"),
         stateDir,
         sessionDir: defaultSessionDir(stateDir),
         piCommand: envString("LOCALPI_PI_CMD", "npx -y @earendil-works/pi-coding-agent@latest"),
-        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "off")),
+        thinking: parseThinkingLevel(envString("LOCALPI_THINKING", "medium")),
         contextWindow: envOptionalPositiveInteger("LOCALPI_CONTEXT_WINDOW"),
         maxTokens: envPositiveInteger("LOCALPI_MAX_TOKENS", "8192"),
         timeoutMs: envPositiveInteger("LOCALPI_TIMEOUT_MS", "3000"),
@@ -34,6 +37,12 @@ export function defaultOptions() {
         tools: envString("LOCALPI_TOOLS", "read,bash,edit,write,grep,find,ls"),
         approval: envBoolean("LOCALPI_APPROVAL", true),
         tokenStatus: envBoolean("LOCALPI_TOKEN_STATUS", true),
+        demo: envBoolean("LOCALPI_DEMO", false),
+        demoFromCli: false,
+        demoInitialPrompt: process.env["LOCALPI_DEMO_INITIAL_PROMPT"],
+        demoInitialPromptFile: process.env["LOCALPI_DEMO_INITIAL_PROMPT_FILE"],
+        demoFollowupPrompt: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT"],
+        demoFollowupPromptFile: process.env["LOCALPI_DEMO_FOLLOWUP_PROMPT_FILE"],
         status: false,
         stop: false,
         list: false,
@@ -43,6 +52,7 @@ export function defaultOptions() {
 export function parseLocalpiArgs(args) {
     let options = defaultOptions();
     const forwardedArgs = [];
+    const demoPromptFlags = demoPromptFlagTracker();
     for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         if (arg === undefined) {
@@ -55,6 +65,7 @@ export function parseLocalpiArgs(args) {
         if (arg === "-h" || arg === "--help") {
             return { ...options, forwardedArgs: ["--help"] };
         }
+        trackDemoPromptFlag(demoPromptFlags, arg);
         const parsed = parseLocalpiFlag(options, args, index);
         if (parsed !== undefined) {
             options = parsed.options;
@@ -63,7 +74,7 @@ export function parseLocalpiArgs(args) {
         }
         forwardedArgs.push(arg);
     }
-    return { ...options, forwardedArgs };
+    return normalizeDemoPromptPrecedence({ ...options, forwardedArgs }, demoPromptFlags);
 }
 export function usage() {
     return `${[
@@ -89,8 +100,21 @@ export function usage() {
         "  --chat-template <path>   llama.cpp chat template file",
         "  --tools <list>           Pi tools allow list",
         "  --providers-file <path>  localpi provider registry JSON",
+        "  --model-profile <path>   local model capability profile JSON",
+        "  --model-reasoning <bool> override generated Pi reasoning capability",
+        "  --model-thinking-format <format>",
+        "                          override generated Pi thinking format",
         "  --no-approval           do not ask before tool calls",
         "  --no-token-status       do not install token status extension",
+        "  --demo                  endlessly run Pi prompts for demo mode",
+        "  --demo-initial-prompt <text>",
+        "                          first demo prompt",
+        "  --demo-followup-prompt <text>",
+        "                          repeated demo prompt after the first run",
+        "  --demo-initial-prompt-file <path>",
+        "                          UTF-8 file for the first demo prompt",
+        "  --demo-followup-prompt-file <path>",
+        "                          UTF-8 file for repeated demo prompts",
         "  --status                print runtime status and exit",
         "  --stop                  stop the localpi-owned llama-server",
         "  --list                  list model aliases",
@@ -132,7 +156,8 @@ const booleanFlagUpdaters = {
     "--stop": (options) => ({ ...options, stop: true }),
     "--list": (options) => ({ ...options, list: true }),
     "--no-approval": (options) => ({ ...options, approval: false }),
-    "--no-token-status": (options) => ({ ...options, tokenStatus: false })
+    "--no-token-status": (options) => ({ ...options, tokenStatus: false }),
+    "--demo": (options) => ({ ...options, demo: true, demoFromCli: true })
 };
 const valueFlagUpdaters = {
     "--runtime": (options, value) => ({ ...options, runtime: parseRuntime(value) }),
@@ -141,6 +166,12 @@ const valueFlagUpdaters = {
     "--provider": (options, value) => ({ ...options, provider: value }),
     "--provider-id": (options, value) => ({ ...options, customProviderId: value }),
     "--providers-file": (options, value) => ({ ...options, providersFile: value }),
+    "--model-profile": (options, value) => ({ ...options, modelProfileFile: value }),
+    "--model-reasoning": (options, value) => ({ ...options, modelReasoning: parseBoolean(value) }),
+    "--model-thinking-format": (options, value) => ({
+        ...options,
+        modelThinkingFormat: parseModelThinkingFormat(value)
+    }),
     "--state-dir": (options, value) => ({ ...options, stateDir: value }),
     "--session-dir": (options, value) => ({ ...options, sessionDir: value }),
     "--pi-command": (options, value) => ({ ...options, piCommand: value }),
@@ -159,7 +190,17 @@ const valueFlagUpdaters = {
     "--gpu-layers": (options, value) => ({ ...options, gpuLayers: parseNonNegativeInteger(value) }),
     "--parallel": (options, value) => ({ ...options, parallel: parsePositiveInteger(value) }),
     "--chat-template": (options, value) => ({ ...options, chatTemplate: value }),
-    "--tools": (options, value) => ({ ...options, tools: value })
+    "--tools": (options, value) => ({ ...options, tools: value }),
+    "--demo-initial-prompt": (options, value) => ({ ...options, demoInitialPrompt: value }),
+    "--demo-followup-prompt": (options, value) => ({ ...options, demoFollowupPrompt: value }),
+    "--demo-initial-prompt-file": (options, value) => ({
+        ...options,
+        demoInitialPromptFile: value
+    }),
+    "--demo-followup-prompt-file": (options, value) => ({
+        ...options,
+        demoFollowupPromptFile: value
+    })
 };
 function parseValueFlag(options, args, index, flag) {
     const updater = valueFlagUpdaters[flag];
@@ -168,6 +209,37 @@ function parseValueFlag(options, args, index, flag) {
     }
     return { options: updater(options, requiredValue(args, index + 1, flag)), advance: 1 };
 }
+function demoPromptFlagTracker() {
+    return {
+        initialText: false,
+        initialFile: false,
+        followupText: false,
+        followupFile: false
+    };
+}
+function trackDemoPromptFlag(tracker, arg) {
+    switch (arg) {
+        case "--demo-initial-prompt":
+            tracker.initialText = true;
+            return;
+        case "--demo-initial-prompt-file":
+            tracker.initialFile = true;
+            return;
+        case "--demo-followup-prompt":
+            tracker.followupText = true;
+            return;
+        case "--demo-followup-prompt-file":
+            tracker.followupFile = true;
+            return;
+    }
+}
+function normalizeDemoPromptPrecedence(options, tracker) {
+    return {
+        ...options,
+        demoInitialPromptFile: tracker.initialText && !tracker.initialFile ? undefined : options.demoInitialPromptFile,
+        demoFollowupPromptFile: tracker.followupText && !tracker.followupFile ? undefined : options.demoFollowupPromptFile
+    };
+}
 function parseRuntime(value) {
     if (value === "auto" ||
         value === "llama-server" ||
@@ -186,6 +258,12 @@ export function parseThinkingLevel(value) {
     }
     throw new Error(`unknown thinking level ${value}; expected off, minimal, low, medium, high, or xhigh`);
 }
+function parseModelThinkingFormat(value) {
+    if (value === "deepseek" || value === "qwen-chat-template") {
+        return value;
+    }
+    throw new Error(`unknown model thinking format ${value}; expected deepseek or qwen-chat-template`);
+}
 function envString(name, fallback) {
     return process.env[name] ?? fallback;
 }
@@ -203,11 +281,22 @@ function envOptionalPositiveInteger(name) {
     const value = process.env[name];
     return value === undefined ? undefined : parsePositiveInteger(value);
 }
+function envOptionalBoolean(primaryName, fallbackName) {
+    const [name, value] = envFirst([primaryName, fallbackName]);
+    return value === undefined ? undefined : parseBoolean(value, name);
+}
+function envOptionalThinkingFormat(primaryName, fallbackName) {
+    const [, value] = envFirst([primaryName, fallbackName]);
+    return value === undefined ? undefined : parseModelThinkingFormat(value);
+}
 function envBoolean(name, fallback) {
     const value = process.env[name];
     if (value === undefined) {
         return fallback;
     }
+    return parseBoolean(value, name);
+}
+function parseBoolean(value, name = "value") {
     if (["1", "true", "yes", "on"].includes(value.toLowerCase())) {
         return true;
     }
@@ -216,6 +305,15 @@ function envBoolean(name, fallback) {
     }
     throw new Error(`${name} must be boolean-like, got ${value}`);
 }
+function envFirst(names) {
+    for (const name of names) {
+        const value = process.env[name];
+        if (value !== undefined) {
+            return [name, value];
+        }
+    }
+    return [names[0] ?? "", undefined];
+}
 function defaultSessionDir(stateDir) {
     return envString("LOCALPI_SESSION_DIR", envString("PI_CODING_AGENT_SESSION_DIR", path.join(stateDir, "sessions")));
 }

package/dist/src/localpi/runtime-connection.js

@@ -1,4 +1,4 @@
-import { formatCatalogWarning, managedModelSupportsReasoning } from "./catalog.js";
+import { formatCatalogWarning, managedCapabilityConfig } from "./catalog.js";
 export function connectionStatus(connection) {
     return ([
         `runtime: ${connection.runtime}`,
@@ -39,9 +39,7 @@ export function catalogModelFromModelInfo(providerId, providerName, runtime, bas
         aliases: [],
         displayName: `${providerName} / ${model.id}`,
         maxTokens: options.maxTokens,
-        ...(runtime === "managed-llama-server"
-            ? { reasoning: managedModelSupportsReasoning(model.id) }
-            : {}),
+        ...(runtime === "managed-llama-server" ? managedCapabilityConfig(model.id, options) : {}),
         capabilities: ["text"],
         availability: "loaded",
         ...optionalContextWindow(contextWindow ?? model.contextWindow)

package/dist/src/localpi/settings-state.js

@@ -0,0 +1,37 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { asObject, optionalString } from "../common/json.js";
+import { parseThinkingLevel } from "./options.js";
+export function localpiSettingsPath(options) {
+    return path.join(options.stateDir, "settings.json");
+}
+export async function applyRememberedSettings(options, explicit) {
+    const settings = await readLocalpiSettings(options);
+    return {
+        ...options,
+        thinking: explicit.thinking || settings.thinking === undefined ? options.thinking : settings.thinking
+    };
+}
+async function readLocalpiSettings(options) {
+    let raw;
+    try {
+        raw = await readFile(localpiSettingsPath(options), "utf8");
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return {};
+        }
+        throw error;
+    }
+    try {
+        const root = asObject(JSON.parse(raw), "localpi settings");
+        const thinking = optionalString(root["thinking"]);
+        return thinking === undefined ? {} : { thinking: parseThinkingLevel(thinking) };
+    }
+    catch {
+        return {};
+    }
+}
+function isMissingFile(error) {
+    return (error instanceof Error && "code" in error && error.code === "ENOENT");
+}

package/dist/src/pi/app.js

@@ -0,0 +1,108 @@
+import { localpiVersion } from "./version.js";
+const localpiAppIdentity = {
+    id: "localpi",
+    name: "localpi",
+    version: localpiVersion
+};
+export function createLocalpiAppDefinition(options, connection, extensions) {
+    return {
+        ...localpiAppIdentity,
+        ...appDirectories(options),
+        ...piCommand(options),
+        ...runtimeSelection(options, connection),
+        ...extensionConfig(extensions)
+    };
+}
+function appDirectories(options) {
+    return {
+        stateDir: options.stateDir,
+        sessionDir: options.sessionDir
+    };
+}
+function piCommand(options) {
+    return {
+        piCommand: options.piCommand,
+        forwardedArgs: options.forwardedArgs
+    };
+}
+function runtimeSelection(options, connection) {
+    const selection = {
+        providers: providersForConnection(options, connection),
+        defaultProvider: connection.providerId,
+        defaultModel: connection.model,
+        thinking: options.thinking
+    };
+    return options.tools === undefined ? selection : { ...selection, tools: options.tools };
+}
+function providersForConnection(options, connection) {
+    const models = connection.catalogModels.length === 0 ? fallbackCatalog(connection) : connection.catalogModels;
+    return groupedByProvider(models).map((group) => ({
+        id: group.providerId,
+        baseUrl: group.baseUrl,
+        api: "openai-completions",
+        apiKey: "local",
+        compat: {
+            supportsDeveloperRole: false,
+            supportsReasoningEffort: false
+        },
+        models: group.models.map((model) => modelDefinition(options, model))
+    }));
+}
+function groupedByProvider(models) {
+    const groups = new Map();
+    for (const model of models) {
+        const existing = groups.get(model.providerId);
+        groups.set(model.providerId, existing === undefined
+            ? { providerId: model.providerId, baseUrl: model.baseUrl, models: [model] }
+            : { ...existing, models: [...existing.models, model] });
+    }
+    return [...groups.values()];
+}
+function modelDefinition(options, model) {
+    const contextWindow = modelContextWindow(options, model);
+    return {
+        id: model.modelId,
+        name: model.displayName,
+        reasoning: model.reasoning ?? false,
+        ...(model.thinkingFormat === undefined ? {} : { thinkingFormat: model.thinkingFormat }),
+        input: ["text"],
+        ...(contextWindow === undefined ? {} : { contextWindow }),
+        ...(model.maxTokens === undefined
+            ? { maxTokens: options.maxTokens }
+            : { maxTokens: model.maxTokens })
+    };
+}
+function modelContextWindow(options, model) {
+    if (options.contextWindow !== undefined) {
+        return options.contextWindow;
+    }
+    return model.contextWindow;
+}
+function fallbackCatalog(connection) {
+    return [
+        {
+            providerId: connection.providerId,
+            providerName: connection.providerName,
+            runtime: connection.runtime.startsWith("llama-server")
+                ? "managed-llama-server"
+                : "openai-compatible",
+            baseUrl: connection.baseUrl,
+            modelId: connection.model,
+            aliases: [],
+            displayName: `Local model (${connection.model})`,
+            reasoning: false,
+            capabilities: ["text"],
+            availability: "loaded",
+            ...(connection.contextWindow === undefined ? {} : { contextWindow: connection.contextWindow })
+        }
+    ];
+}
+function extensionConfig(extensions) {
+    if (extensions === undefined) {
+        return {};
+    }
+    return {
+        extensions: extensions.paths.map((extensionPath) => ({ path: extensionPath })),
+        appendSystemPrompts: [extensions.systemPrompt]
+    };
+}

package/dist/src/pi/demo.js

@@ -0,0 +1,12 @@
+import { readFile } from "node:fs/promises";
+export const defaultDemoInitialPrompt = "You are narrating a never-ending sci-fi adventure. Continue in short paragraphs. Whenever the user sends a message, treat it as a live director note and incorporate it immediately. Never end the story.";
+export const defaultDemoFollowupPrompt = "Continue. Try to write as long as possible.";
+export async function resolveDemoPrompts(options) {
+    return {
+        initial: await resolvePrompt(options.demoInitialPrompt, options.demoInitialPromptFile, defaultDemoInitialPrompt),
+        followup: await resolvePrompt(options.demoFollowupPrompt, options.demoFollowupPromptFile, defaultDemoFollowupPrompt)
+    };
+}
+async function resolvePrompt(text, file, fallback) {
+    return file === undefined ? (text ?? fallback) : await readFile(file, "utf8");
+}

package/dist/src/pi/extension-sources/demo-mode.js

@@ -0,0 +1,52 @@
+export function demoModeExtensionSource(prompts) {
+    const initialPromptSource = JSON.stringify(prompts.initial);
+    const followupPromptSource = JSON.stringify(prompts.followup);
+    return `import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+const initialPrompt = ${initialPromptSource};
+const followupPrompt = ${followupPromptSource};
+
+export default function localpiDemoMode(pi: ExtensionAPI): void {
+  let started = false;
+  let stopped = false;
+
+  pi.on("session_start", (event, ctx) => {
+    if (started || stopped || event.reason !== "startup" || ctx.mode !== "tui") {
+      return;
+    }
+    started = true;
+    queueMicrotask(() => {
+      if (!stopped) {
+        pi.sendUserMessage(initialPrompt);
+      }
+    });
+  });
+
+  pi.on("turn_end", (event, ctx) => {
+    if (!started || stopped || ctx.mode !== "tui") {
+      return;
+    }
+    if (event.message.role !== "assistant") {
+      return;
+    }
+    switch (event.message.stopReason) {
+      case "aborted":
+      case "error":
+        stopped = true;
+        return;
+      case "toolUse":
+        return;
+    }
+    queueMicrotask(() => {
+      if (!stopped) {
+        pi.sendUserMessage(followupPrompt, { deliverAs: "followUp" });
+      }
+    });
+  });
+
+  pi.on("session_shutdown", () => {
+    stopped = true;
+  });
+}
+`;
+}

package/dist/src/pi/extension-sources/startup-model-selector.js

@@ -0,0 +1,78 @@
+export function startupModelSelectorExtensionSource(options) {
+    const startupModelsSource = JSON.stringify(options.models);
+    return `import type { ExtensionAPI, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { ModelSelectorComponent } from "@earendil-works/pi-coding-agent";
+
+type SelectedModel = Parameters<ExtensionAPI["setModel"]>[0];
+const startupModels = ${startupModelsSource} as const;
+const startupModelKeys = new Set(startupModels.map((model) => modelKey(model)));
+
+export default function localpiStartupModelSelector(pi: ExtensionAPI): void {
+  let opened = false;
+
+  pi.on("session_start", async (event, ctx) => {
+    if (opened || event.reason !== "startup" || ctx.mode !== "tui") {
+      return;
+    }
+
+    const selectableModels = startupAvailableModels(ctx.modelRegistry);
+    if (selectableModels.length <= 1) {
+      return;
+    }
+    const scopedModels = selectableModels.map((model) => ({ model }));
+
+    opened = true;
+    const selected = await ctx.ui.custom<SelectedModel | undefined>((tui, _theme, _keybindings, done) => {
+      const settings = {
+        setDefaultModelAndProvider: () => {}
+      } as unknown as SettingsManager;
+      return new ModelSelectorComponent(
+        tui,
+        ctx.model,
+        settings,
+        startupModelRegistry(ctx.modelRegistry) as typeof ctx.modelRegistry,
+        scopedModels,
+        (model) => done(model),
+        () => done(undefined)
+      );
+    });
+
+    if (selected === undefined) {
+      return;
+    }
+
+    const ok = await pi.setModel(selected);
+    if (!ok) {
+      ctx.ui.notify(\`No API key for \${selected.provider}/\${selected.id}\`, "error");
+    }
+  });
+}
+
+function startupAvailableModels(registry: {
+  getAvailable(): SelectedModel[];
+}): SelectedModel[] {
+  return registry.getAvailable().filter((model) => startupModelKeys.has(modelKey(model)));
+}
+
+function startupModelRegistry(registry: {
+  refresh(): void;
+  getError(): string | undefined;
+  getAvailable(): SelectedModel[];
+  find(provider: string, modelId: string): SelectedModel | undefined;
+}): typeof registry {
+  return {
+    refresh: () => registry.refresh(),
+    getError: () => registry.getError(),
+    getAvailable: () => startupAvailableModels(registry),
+    find: (provider, modelId) => {
+      const model = registry.find(provider, modelId);
+      return model !== undefined && startupModelKeys.has(modelKey(model)) ? model : undefined;
+    }
+  };
+}
+
+function modelKey(model: { readonly provider: string; readonly id: string }): string {
+  return \`\${model.provider}\\u0000\${model.id}\`;
+}
+`;
+}