arisa 3.0.14 → 3.1.4

package/src/core/tools/tool-registry.js

@@ -1,10 +1,11 @@
-import { mkdir, readdir, readFile, unlink, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, rmdir, unlink, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { getToolConfigPath, getToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
+import { getToolConfigPath, getToolTmpDir, getChatToolTmpDir, toolsDir as userToolsRoot } from "../../runtime/paths.js";
 import { loadToolConfig, parseConfigModule, writeToolConfig } from "./tool-config.js";
 import { normalizeToolResult } from "./tool-result.js";
+import { SkillRegistry } from "../skills/skill-registry.js";
 
 const bundledToolsRoot = fileURLToPath(new URL("../../../tools", import.meta.url));
 const toolRoots = [
@@ -27,6 +28,7 @@ export class ToolRegistry {
   constructor({ logger } = {}) {
     this.logger = logger;
     this.tools = new Map();
+    this.skillRegistry = new SkillRegistry();
   }
 
   async load() {
@@ -52,8 +54,10 @@ export class ToolRegistry {
           const configSource = await readFile(configPath, "utf8");
           const defaults = parseConfigModule(configSource);
           const config = await loadToolConfig(manifest.name, defaults);
+          const skillHints = this.skillRegistry.normalizeHints(manifest);
           this.tools.set(manifest.name, {
             ...manifest,
+            skillHints,
             dir: toolDir,
             entry: path.join(toolDir, manifest.entry || "index.js"),
             localConfigPath: configPath,
@@ -77,7 +81,8 @@ export class ToolRegistry {
       description: tool.description,
       input: tool.input,
       output: tool.output,
-      configSchema: tool.configSchema || {}
+      configSchema: tool.configSchema || {},
+      skillHints: tool.skillHints || []
     }));
   }
 
@@ -89,33 +94,73 @@ export class ToolRegistry {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
     const result = await runProcess("node", [tool.entry, "--help"], { cwd: tool.dir, env: process.env });
-    return result.stdout || result.stderr;
+    const help = result.stdout || result.stderr;
+    const skills = await this.resolveSkills(name);
+    if (!skills.length) return help;
+    const skillHelp = skills.map((item) => [
+      `- ${item.name}${item.when ? ` (${item.when})` : ""}`,
+      item.description ? `  ${item.description}` : null,
+      item.found ? `  path: ${item.path}` : "  warning: skill not found"
+    ].filter(Boolean).join("\n")).join("\n");
+    return `${help}\n\nAssigned skills:\n${skillHelp}\n`;
   }
 
-  async setConfig(name, field, value) {
+  async resolveSkills(name) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
-    const config = { ...(tool.config || {}) };
-    config[field] = value;
-    const configPath = await writeToolConfig(name, config);
-    tool.config = config;
-    tool.configPath = configPath;
+    const hints = await this.skillRegistry.resolveHints(tool.skillHints || []);
+    return hints.map((hint) => ({
+      name: hint.name,
+      when: hint.when,
+      found: hint.found,
+      description: hint.skill?.description || "",
+      path: hint.skill?.path || "",
+      content: hint.skill?.content || ""
+    }));
+  }
+
+  async resolveConfigForChat(name, chatId) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    if (chatId == null) return tool.config || {};
+    return loadToolConfig(name, tool.defaults || {}, chatId);
+  }
+
+  async setConfig(name, field, value, chatId = null) {
+    const tool = this.get(name);
+    if (!tool) throw new Error(`Tool not found: ${name}`);
+    const current = chatId != null
+      ? await this.resolveConfigForChat(name, chatId)
+      : { ...(tool.config || {}) };
+    current[field] = value;
+    const configPath = await writeToolConfig(name, current, chatId);
+    if (chatId == null) {
+      tool.config = current;
+      tool.configPath = configPath;
+    }
     return { ok: true, tool: name, field, configPath };
   }
 
-  async run({ name, request }) {
+  async run({ name, request, chatId = null }) {
     const tool = this.get(name);
     if (!tool) throw new Error(`Tool not found: ${name}`);
     this.logger?.log("tools", `running ${name}`);
-    const tmpDir = getToolTmpDir(name);
+    const tmpDir = chatId != null ? getChatToolTmpDir(chatId, name) : getToolTmpDir(name);
     await mkdir(tmpDir, { recursive: true });
     const requestFile = path.join(tmpDir, `.request-${Date.now()}.json`);
-    await writeFile(requestFile, `${JSON.stringify(request, null, 2)}\n`, "utf8");
+    const skills = await this.resolveSkills(name);
+    const enrichedRequest = { ...request, chatId, skills };
+    await writeFile(requestFile, `${JSON.stringify(enrichedRequest, null, 2)}\n`, "utf8");
     const result = await runProcess("node", [tool.entry, "run", "--request-file", requestFile], {
       cwd: tool.dir,
       env: process.env
     });
     await unlink(requestFile).catch(() => {});
+    await rmdir(tmpDir).catch(() => {});
+    if (chatId != null) {
+      await rmdir(path.dirname(tmpDir)).catch(() => {});
+      await rmdir(path.dirname(path.dirname(tmpDir))).catch(() => {});
+    }
     try {
       const parsed = JSON.parse(result.stdout || result.stderr);
       const normalized = normalizeToolResult(name, parsed);

package/src/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { createServer } from "node:http";
 import { bootstrapIfNeeded } from "./runtime/bootstrap.js";
 import { createApp } from "./runtime/create-app.js";
 import { createLogger } from "./runtime/logger.js";
@@ -8,25 +9,117 @@ import { flushArisaHome } from "./runtime/flush.js";
 import { installPiPackage, removePiPackage } from "./runtime/pi-package-manager.js";
 
 const args = process.argv.slice(2);
-const command = args.find((arg) => !arg.startsWith("--")) || "run";
-const forceBootstrap = args.includes("--bootstrap");
-const verbose = args.includes("--verbose");
-const serviceRunner = args.includes("--service-runner");
+const cli = parseCliArgs(args);
+const command = cli.positionals[0] || "run";
+const forceBootstrap = Boolean(cli.flags.bootstrap);
+const verbose = Boolean(cli.flags.verbose);
+const serviceRunner = Boolean(cli.flags["service-runner"]);
+const bootstrapOverrides = toBootstrapOverrides(cli.nestedFlags);
+const runtimeOverrides = toRuntimeOverrides(cli.nestedFlags);
 const logger = createLogger({ verbose });
 
+const httpPort = Number(process.env.PORT);
+let httpRequestHandler = null;
+
+function setHttpRequestHandler(handler) {
+  httpRequestHandler = handler;
+}
+
+if (httpPort && bootstrapOverrides.telegram) {
+  createServer((req, res) => {
+    if (httpRequestHandler) return httpRequestHandler(req, res);
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("ok");
+  }).listen(httpPort)
+    .on("listening", () => logger.log("http", `health server on port ${httpPort}`));
+}
+
+function parseCliArgs(rawArgs) {
+  const flags = {};
+  const nestedFlags = {};
+  const positionals = [];
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const token = rawArgs[index];
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+
+    const flagName = token.slice(2);
+    if (!flagName) continue;
+    if (flagName.includes(".")) {
+      const next = rawArgs[index + 1];
+      const hasValue = typeof next === "string" && !next.startsWith("--");
+      if (hasValue) {
+        nestedFlags[flagName] = next;
+        index += 1;
+      }
+      continue;
+    }
+
+    flags[flagName] = true;
+  }
+
+  return { flags, nestedFlags, positionals };
+}
+
+function toBootstrapOverrides(nestedFlags) {
+  const overrides = {};
+  for (const [flatKey, value] of Object.entries(nestedFlags)) {
+    const parts = flatKey.split(".");
+    let cursor = overrides;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+      const key = parts[index];
+      if (!cursor[key] || typeof cursor[key] !== "object") {
+        cursor[key] = {};
+      }
+      cursor = cursor[key];
+    }
+    cursor[parts[parts.length - 1]] = value;
+  }
+  return overrides;
+}
+
+function toRuntimeOverrides(nestedFlags) {
+  return toBootstrapOverrides(nestedFlags);
+}
+
+function toServiceRunnerArgs(nestedFlags) {
+  const args = [];
+  if (nestedFlags["pi.model"]) {
+    args.push("--pi.model", nestedFlags["pi.model"]);
+  }
+  return args;
+}
+
+const bootstrapHttpOptions = httpPort ? { httpPort, setHttpRequestHandler } : {};
+const webhookUrl = bootstrapOverrides.webhook?.url || "";
+const appHttpOptions = httpPort ? { webhookUrl, setHttpRequestHandler } : {};
+
 async function runForeground() {
+  const hasRuntimePiOverrides = Boolean(
+    runtimeOverrides?.pi?.model
+    || runtimeOverrides?.pi?.provider
+    || runtimeOverrides?.pi?.apiKey
+  );
   logger.log("app", `starting${verbose ? " in verbose mode" : ""}`);
-  await bootstrapIfNeeded({ force: forceBootstrap });
+  await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
   try {
-    const app = await createApp({ logger });
+    const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
     await app.start();
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     if (message.includes("No auth found")) {
       console.log(`\n${message}\n`);
+      if (hasRuntimePiOverrides) {
+        console.log("Skipping automatic bootstrap because Pi runtime overrides were provided.");
+        console.log("Keeping existing Telegram config. Run `arisa --bootstrap` manually if you want to update persisted auth/config.\n");
+        throw error;
+      }
       console.log("Reopening bootstrap so you can provide a Pi API key or switch to a provider you already authenticated with.\n");
-      await bootstrapIfNeeded({ force: true });
-      const app = await createApp({ logger });
+      await bootstrapIfNeeded({ force: true, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
+      const app = await createApp({ logger, runtimeOverrides, ...appHttpOptions });
       await app.start();
       return;
     }
@@ -42,8 +135,8 @@ async function main() {
   }
 
   if (command === "start") {
-    await bootstrapIfNeeded({ force: forceBootstrap });
-    const result = await startService({ verbose });
+    await bootstrapIfNeeded({ force: forceBootstrap, cliConfigOverrides: bootstrapOverrides, ...bootstrapHttpOptions });
+    const result = await startService({ verbose, cliArgs: toServiceRunnerArgs(cli.nestedFlags) });
     if (!result.ok) {
       console.log(`Arisa is already running in background (pid ${result.pid}).`);
       return;
@@ -85,7 +178,7 @@ async function main() {
   }
 
   if (command === "install") {
-    const source = args.filter((arg) => !arg.startsWith("--")).slice(1)[0];
+    const source = cli.positionals[1];
     if (!source) {
       console.log("Usage: arisa install <pi-package-source>");
       return;
@@ -96,7 +189,7 @@ async function main() {
   }
 
   if (command === "remove") {
-    const source = args.filter((arg) => !arg.startsWith("--")).slice(1)[0];
+    const source = cli.positionals[1];
     if (!source) {
       console.log("Usage: arisa remove <pi-package-source>");
       return;

package/src/runtime/bootstrap.js

@@ -15,9 +15,82 @@ async function exists(file) {
   }
 }
 
+function normalizeString(value) {
+  if (typeof value !== "string") return "";
+  return value.trim();
+}
+
+function parseMaxChatIds(value, fallback = 1) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return fallback;
+  return parsed;
+}
+
+function buildConfig({ telegramApiKey, telegramMaxChatIds, provider, model, piApiKey }) {
+  return {
+    telegram: {
+      token: telegramApiKey,
+      maxChatIds: telegramMaxChatIds,
+      authorizedChatIds: [],
+      chatMeta: {}
+    },
+    pi: {
+      provider,
+      model,
+      apiKey: piApiKey
+    },
+    createdAt: new Date().toISOString()
+  };
+}
+
+function resolvePiDefaults(runtime, { provider: preferredProvider = "", model: preferredModel = "" } = {}) {
+  const providers = sortBootstrapProviders(listPiProviders(runtime));
+  if (!providers.length) {
+    throw new Error("No Pi providers are available for bootstrap.");
+  }
+
+  const preferredProviderValue = normalizeString(preferredProvider);
+  const providerExists = providers.some((item) => item.provider === preferredProviderValue);
+  if (preferredProviderValue && !providerExists) {
+    console.log(`Ignoring unknown Pi provider override: ${preferredProviderValue}`);
+  }
+
+  const selectedProvider = providerExists
+    ? preferredProviderValue
+    : providers[0].provider;
+
+  const models = sortBootstrapModels(selectedProvider, listProviderModels(selectedProvider, runtime));
+  if (!models.length) {
+    throw new Error(`No Pi models are available for provider ${selectedProvider}.`);
+  }
+
+  const preferredModelValue = normalizeString(preferredModel);
+  const modelExists = models.some((item) => item.id === preferredModelValue);
+  if (preferredModelValue && !modelExists) {
+    console.log(`Ignoring unknown Pi model override for ${selectedProvider}: ${preferredModelValue}`);
+  }
+
+  const selectedModel = modelExists ? preferredModelValue : models[0].id;
+  return { provider: selectedProvider, model: selectedModel };
+}
+
+function sortBootstrapProviders(providers) {
+  const preferredOrder = ["openai-codex"];
+  const positions = new Map(providers.map((provider, index) => [provider.provider, index]));
+
+  return [...providers].sort((a, b) => {
+    const aPref = preferredOrder.indexOf(a.provider);
+    const bPref = preferredOrder.indexOf(b.provider);
+    const aRank = aPref === -1 ? Number.MAX_SAFE_INTEGER : aPref;
+    const bRank = bPref === -1 ? Number.MAX_SAFE_INTEGER : bPref;
+    if (aRank !== bRank) return aRank - bRank;
+    return (positions.get(a.provider) || 0) - (positions.get(b.provider) || 0);
+  });
+}
+
 function sortBootstrapModels(provider, models) {
   const preferred = {
-    "openai-codex": ["gpt-5.4"]
+    "openai-codex": ["gpt-5.5"]
   };
 
   const priority = preferred[provider] || [];
@@ -49,7 +122,78 @@ async function maybeOpenExternal(url) {
   });
 }
 
-async function runInternalPiLogin(provider, rl) {
+function installAuthRelay(httpPort, setHttpRequestHandler) {
+  let authUrl = "";
+  let resolveRedirectUrl;
+  const redirectUrlPromise = new Promise((resolve) => {
+    resolveRedirectUrl = resolve;
+  });
+
+  const page = (body) => [
+    "<!DOCTYPE html><html><head><meta charset='utf-8'><meta name='viewport' content='width=device-width'>",
+    "<title>Arisa Auth</title>",
+    "<style>body{font-family:system-ui,sans-serif;max-width:600px;margin:40px auto;padding:0 20px;line-height:1.6}",
+    "input[type=text]{width:100%;padding:8px;box-sizing:border-box;margin:8px 0}",
+    "button{padding:8px 24px;cursor:pointer}code{background:#f0f0f0;padding:2px 6px;border-radius:3px}</style>",
+    "</head><body>",
+    body,
+    "</body></html>"
+  ].join("");
+
+  setHttpRequestHandler((req, res) => {
+    const parsed = new URL(req.url, `http://localhost:${httpPort}`);
+
+    if (req.method === "GET" && parsed.pathname === "/auth/callback" && parsed.searchParams.has("code")) {
+      const callbackUrl = `http://localhost:1455${parsed.pathname}${parsed.search}`;
+      resolveRedirectUrl(callbackUrl);
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(page("<h2>Authentication received</h2><p>You can close this page. Arisa is starting&hellip;</p>"));
+      return;
+    }
+
+    if (req.method === "GET" && parsed.pathname === "/") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(page([
+        "<h2>Arisa &mdash; Pi Authentication</h2>",
+        authUrl
+          ? `<p><strong>1.</strong> <a href="${authUrl}" target="_blank">Click here to log in with Pi</a></p>`
+          : "<p>Waiting for authentication URL&hellip;</p>",
+        "<p><strong>2.</strong> After login your browser will redirect to a <code>localhost</code> URL that won't load. That's expected.</p>",
+        "<p><strong>3.</strong> In your browser's address bar, replace <code>localhost:1455</code> with your server's domain and press Enter.</p>",
+        "<hr>",
+        "<p><em>Or paste the full redirect URL here:</em></p>",
+        '<form method="POST" action="/auth/relay">',
+        '<input type="text" name="url" placeholder="Paste the localhost redirect URL here&hellip;" required />',
+        "<button type='submit'>Submit</button>",
+        "</form>"
+      ].join("\n")));
+      return;
+    }
+
+    if (req.method === "POST" && parsed.pathname === "/auth/relay") {
+      let body = "";
+      req.on("data", (chunk) => { body += chunk; });
+      req.on("end", () => {
+        const url = (new URLSearchParams(body).get("url") || "").trim();
+        if (url) resolveRedirectUrl(url);
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(page("<h2>Authentication received</h2><p>You can close this page. Arisa is starting&hellip;</p>"));
+      });
+      return;
+    }
+
+    res.writeHead(200, { "Content-Type": "text/plain" });
+    res.end("ok");
+  });
+
+  return {
+    setAuthUrl(url) { authUrl = url; },
+    waitForRedirectUrl() { return redirectUrlPromise; },
+    uninstall() { setHttpRequestHandler(null); }
+  };
+}
+
+async function runInternalPiLogin(provider, { rl = null, authRelay = null } = {}) {
   const authStorage = AuthStorage.create();
   const selected = authStorage.getOAuthProviders().find((item) => item.id === provider);
   if (!selected) {
@@ -67,7 +211,15 @@ async function runInternalPiLogin(provider, rl) {
     onAuth: async ({ url, instructions }) => {
       console.log(`${instructions || "Open this URL to continue authentication:"}\n${url}\n`);
       await maybeOpenExternal(url);
-      if (selected.usesCallbackServer) {
+      if (authRelay) {
+        authRelay.setAuthUrl(url);
+        console.log("Waiting for authentication via the web relay...");
+        const redirectUrl = await authRelay.waitForRedirectUrl();
+        if (redirectUrl && manualCodeResolve) {
+          manualCodeResolve(redirectUrl);
+          manualCodeResolve = undefined;
+        }
+      } else if (selected.usesCallbackServer && rl) {
         const pasted = (await rl.question("Paste the redirect URL here if the browser does not return automatically, or press Enter to keep waiting: ")).trim();
         if (pasted && manualCodeResolve) {
           manualCodeResolve(pasted);
@@ -81,6 +233,9 @@ async function runInternalPiLogin(provider, rl) {
       await maybeOpenExternal(verificationUri);
     },
     onPrompt: async ({ message }) => {
+      if (!rl) {
+        throw new Error(`Pi login for ${provider} requires interactive input: ${message}`);
+      }
       return (await rl.question(`${message} `)).trim();
     },
     onProgress: (message) => {
@@ -96,10 +251,54 @@ async function runInternalPiLogin(provider, rl) {
   });
 }
 
-export async function bootstrapIfNeeded({ force = false } = {}) {
+export async function bootstrapIfNeeded({ force = false, cliConfigOverrides = {}, httpPort = 0, setHttpRequestHandler } = {}) {
   await ensureArisaHome();
   if (!force && await exists(configFile)) return;
 
+  const telegramApiKeyFromCli = normalizeString(cliConfigOverrides?.telegram?.token);
+  if (telegramApiKeyFromCli) {
+    const runtime = createPiRuntime();
+    const resolvedPi = resolvePiDefaults(runtime, cliConfigOverrides?.pi || {});
+    const telegramMaxChatIds = parseMaxChatIds(cliConfigOverrides?.telegram?.maxChatIds, 1);
+    const piApiKey = normalizeString(cliConfigOverrides?.pi?.apiKey);
+    if (!piApiKey && !hasProviderAuth(resolvedPi.provider, runtime)) {
+      if (!supportsProviderOAuth(resolvedPi.provider, runtime)) {
+        throw new Error(
+          `No auth found for ${resolvedPi.provider}. Provide --pi.apiKey for non-interactive bootstrap, or use a provider that supports OAuth.`
+        );
+      }
+      if (!httpPort || !setHttpRequestHandler) {
+        throw new Error(
+          `No auth found for ${resolvedPi.provider}. Auth relay requires an HTTP server on PORT. Provide --pi.apiKey or set the PORT environment variable.`
+        );
+      }
+      const authRelay = installAuthRelay(httpPort, setHttpRequestHandler);
+      console.log(`No existing Pi auth found for ${resolvedPi.provider}. Auth relay active on port ${httpPort}.`);
+      console.log(`Open your server URL in a browser to complete Pi authentication.\n`);
+      try {
+        await runInternalPiLogin(resolvedPi.provider, { authRelay });
+      } finally {
+        authRelay.uninstall();
+      }
+      if (!hasProviderAuth(resolvedPi.provider, createPiRuntime())) {
+        throw new Error(
+          `Pi login did not complete for ${resolvedPi.provider}. Retry or provide --pi.apiKey.`
+        );
+      }
+      console.log(`Detected Pi auth for ${resolvedPi.provider}. Continuing bootstrap.`);
+    }
+    const config = buildConfig({
+      telegramApiKey: telegramApiKeyFromCli,
+      telegramMaxChatIds,
+      provider: resolvedPi.provider,
+      model: resolvedPi.model,
+      piApiKey
+    });
+    await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+    console.log(`\nConfig saved to ${configFile} (non-interactive bootstrap)\n`);
+    return;
+  }
+
   const rl = readline.createInterface({ input, output });
   const ask = async (label, fallback = "") => {
     const suffix = fallback ? ` (${fallback})` : "";
@@ -113,7 +312,7 @@ export async function bootstrapIfNeeded({ force = false } = {}) {
   const telegramMaxChatIds = Number(await ask("Maximum authorized chat IDs", "1"));
 
   const runtime = createPiRuntime();
-  const providers = listPiProviders(runtime);
+  const providers = sortBootstrapProviders(listPiProviders(runtime));
   console.log("\nAvailable Pi providers:");
   providers.forEach((item, index) => {
     const authLabel = item.authConfigured ? "auth: configured" : item.supportsOAuth ? "auth: login or API key" : "auth: API key";
@@ -153,7 +352,7 @@ export async function bootstrapIfNeeded({ force = false } = {}) {
 
     console.log(`No existing Pi auth found for ${selectedProvider.provider}. Starting internal Pi login...`);
     try {
-      await runInternalPiLogin(selectedProvider.provider, rl);
+      await runInternalPiLogin(selectedProvider.provider, { rl });
     } catch (error) {
       console.log(`Internal Pi login failed: ${error instanceof Error ? error.message : String(error)}`);
     }
@@ -166,20 +365,13 @@ export async function bootstrapIfNeeded({ force = false } = {}) {
     console.log(`Pi auth for ${selectedProvider.provider} is still missing after login.`);
   }
 
-  const config = {
-    telegram: {
-      apiKey: telegramApiKey,
-      maxChatIds: telegramMaxChatIds,
-      authorizedChatIds: [],
-      chatMeta: {}
-    },
-    pi: {
-      provider: selectedProvider.provider,
-      model: selectedModel.id,
-      apiKey: piApiKey
-    },
-    createdAt: new Date().toISOString()
-  };
+  const config = buildConfig({
+    telegramApiKey,
+    telegramMaxChatIds,
+    provider: selectedProvider.provider,
+    model: selectedModel.id,
+    piApiKey
+  });
 
   await writeFile(configFile, `${JSON.stringify(config, null, 2)}\n`, "utf8");
   rl.close();

package/src/runtime/create-app.js

@@ -5,9 +5,51 @@ import { TaskStore } from "../core/tasks/task-store.js";
 import { AgentManager } from "../core/agent/agent-manager.js";
 import { createTelegramBot } from "../transport/telegram/bot.js";
 
-export async function createApp({ logger } = {}) {
+function normalizeString(value) {
+  const text = String(value ?? "").trim();
+  return text ? text : "";
+}
+
+function splitModelOverride(modelOverride) {
+  const separatorIndex = modelOverride.indexOf("/");
+  if (separatorIndex <= 0 || separatorIndex === modelOverride.length - 1) {
+    return null;
+  }
+  return {
+    provider: modelOverride.slice(0, separatorIndex),
+    model: modelOverride.slice(separatorIndex + 1)
+  };
+}
+
+function applyRuntimeOverrides(config, runtimeOverrides) {
+  const providerOverride = normalizeString(runtimeOverrides?.pi?.provider);
+  const modelOverride = normalizeString(runtimeOverrides?.pi?.model);
+  if (!providerOverride && !modelOverride) return config;
+
+  const splitOverride = modelOverride ? splitModelOverride(modelOverride) : null;
+  const provider = providerOverride || splitOverride?.provider || config.pi.provider;
+  const model = splitOverride && (!providerOverride || providerOverride === splitOverride.provider)
+    ? splitOverride.model
+    : (modelOverride || config.pi.model);
+
+  return {
+    ...config,
+    pi: {
+      ...config.pi,
+      provider,
+      model
+    }
+  };
+}
+
+export async function createApp({ logger, runtimeOverrides, webhookUrl, setHttpRequestHandler } = {}) {
   logger?.log("app", "loading config");
-  const config = await loadConfig();
+  const persistedConfig = await loadConfig();
+  const config = applyRuntimeOverrides(persistedConfig, runtimeOverrides);
+  if (config.pi.provider !== persistedConfig.pi.provider || config.pi.model !== persistedConfig.pi.model) {
+    logger?.log("app", `applying runtime model override: ${persistedConfig.pi.provider}/${persistedConfig.pi.model} -> ${config.pi.provider}/${config.pi.model}`);
+  }
+
   const artifactStore = new ArtifactStore();
   const toolRegistry = new ToolRegistry({ logger });
   const taskStore = new TaskStore();
@@ -15,7 +57,7 @@ export async function createApp({ logger } = {}) {
   logger?.log("app", `loaded ${toolRegistry.list().length} tools`);
 
   const agentManager = new AgentManager({ config, artifactStore, toolRegistry, taskStore, logger });
-  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger });
+  const bot = await createTelegramBot({ config, artifactStore, toolRegistry, taskStore, agentManager, saveConfig, updateConfig, logger, webhookUrl, setHttpRequestHandler });
 
   return {
     async start() {