@vtstech/pi-api 1.0.3

package/api.js

@@ -0,0 +1,411 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// .build-npm/api/api.temp.ts
+var api_temp_exports = {};
+__export(api_temp_exports, {
+  default: () => api_temp_default
+});
+module.exports = __toCommonJS(api_temp_exports);
+var import_format = require("@vtstech/pi-shared/format");
+var import_ollama = require("@vtstech/pi-shared/ollama");
+var API_MODES = {
+  "anthropic-messages": "Anthropic Claude API and compatibles",
+  "openai-completions": "OpenAI Chat Completions API and compatibles",
+  "openai-responses": "OpenAI Responses API",
+  "azure-openai-responses": "Azure OpenAI Responses API",
+  "openai-codex-responses": "OpenAI Codex Responses API",
+  "mistral-conversations": "Mistral SDK Conversations/Chat streaming",
+  "google-generative-ai": "Google Generative AI API",
+  "google-gemini-cli": "Google Cloud Code Assist API",
+  "google-vertex": "Google Vertex AI API",
+  "bedrock-converse-stream": "Amazon Bedrock Converse API"
+};
+var COMPAT_FLAGS = {
+  supportsDeveloperRole: {
+    description: 'Use "system" instead of "developer" role',
+    values: ["true", "false"]
+  },
+  supportsReasoningEffort: {
+    description: "Provider supports reasoning effort parameter",
+    values: ["true", "false"]
+  },
+  maxTokensField: {
+    description: 'Token field name ("max_tokens" or "max_completion_tokens")',
+    values: ["max_tokens", "max_completion_tokens"]
+  },
+  requiresToolResultName: {
+    description: "Tool results need name field",
+    values: ["true", "false"]
+  },
+  thinkingFormat: {
+    description: "Thinking token format (e.g., qwen, deepseek)",
+    values: ["qwen", "deepseek", "default"]
+  }
+};
+function getLocalProvider(config) {
+  for (const [name, provider] of Object.entries(config.providers)) {
+    const url = provider.baseUrl || "";
+    if (url.includes("localhost") || url.includes("127.0.0.1") || url.includes("0.0.0.0") || name === "ollama") {
+      return { name, isLocal: true };
+    }
+  }
+  const first = Object.keys(config.providers)[0];
+  return { name: first || "ollama", isLocal: false };
+}
+function resolveProvider(config, explicit) {
+  const target = explicit || getLocalProvider(config).name;
+  const provider = config.providers[target];
+  if (!provider) return null;
+  return { name: target, config: provider };
+}
+function api_temp_default(pi) {
+  const branding = [
+    `  \u26A1 Pi API Mode Switcher v1.0.3`,
+    `  Written by VTSTech`,
+    `  GitHub: https://github.com/VTSTech`,
+    `  Website: www.vts-tech.org`
+  ].join("\n");
+  pi.registerCommand("api", {
+    description: "View and switch API modes, base URLs, thinking, and compat flags",
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/);
+      const sub = parts[0]?.toLowerCase() || "";
+      const rest = parts.slice(1).join(" ");
+      const config = (0, import_ollama.readModelsJson)();
+      const provider = resolveProvider(config);
+      if (!provider) {
+        ctx.ui.notify("No providers found in models.json", "error");
+        return;
+      }
+      switch (sub) {
+        case "":
+        case "show":
+          return showConfig(provider);
+        case "mode":
+          return setMode(ctx, provider.name, rest);
+        case "url":
+          return setUrl(ctx, provider.name, rest);
+        case "think":
+          return setThink(ctx, provider.name, rest);
+        case "compat":
+          return handleCompat(ctx, provider.name, rest);
+        case "reload":
+          return reloadConfig(ctx);
+        case "modes":
+          return listModes();
+        case "providers":
+          return listProviders(config);
+        default:
+          ctx.ui.notify(`Unknown sub-command: "${sub}". Use: mode, url, think, compat, reload, modes, providers`, "error");
+      }
+    }
+  });
+  function showConfig(provider) {
+    const p = provider.config;
+    const compat = p.compat || {};
+    const modelCount = p.models?.length || 0;
+    const firstModel = p.models?.[0]?.id || "none";
+    const lines = [branding];
+    lines.push((0, import_format.section)("CURRENT PROVIDER CONFIG"));
+    lines.push((0, import_format.info)(`Provider: ${provider.name}`));
+    lines.push((0, import_format.info)(`API mode: ${p.api || "(not set)"}`));
+    lines.push((0, import_format.info)(`Base URL: ${p.baseUrl || "(not set)"}`));
+    lines.push((0, import_format.info)(`API key: ${p.apiKey ? "\u2022\u2022\u2022\u2022" + String(p.apiKey).slice(-4) : "(not set)"}`));
+    lines.push((0, import_format.info)(`Models: ${modelCount} (first: ${firstModel})`));
+    if (Object.keys(compat).length > 0) {
+      lines.push((0, import_format.section)("COMPAT FLAGS"));
+      for (const [key, value] of Object.entries(compat)) {
+        lines.push((0, import_format.info)(`  ${key}: ${JSON.stringify(value)}`));
+      }
+    }
+    const ollamaBase = (0, import_ollama.getOllamaBaseUrl)();
+    lines.push((0, import_format.section)("RESOLVED"));
+    lines.push((0, import_format.info)(`Ollama base: ${ollamaBase}`));
+    lines.push((0, import_format.info)(`(strip /v1 \u2192 ${ollamaBase})`));
+    pi.sendMessage({
+      customType: "api-config",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+  }
+  function setMode(ctx, providerName, mode) {
+    if (!mode) {
+      ctx.ui.notify("Usage: /api mode <mode>. Use /api modes to list available modes.", "error");
+      return;
+    }
+    const modeLower = mode.toLowerCase();
+    let matched = Object.keys(API_MODES).find((m) => m === modeLower);
+    if (!matched) {
+      matched = Object.keys(API_MODES).find((m) => m.includes(modeLower));
+    }
+    if (!matched) {
+      ctx.ui.notify(`Unknown API mode: "${mode}". Use /api modes to list available modes.`, "error");
+      return;
+    }
+    const config = (0, import_ollama.readModelsJson)();
+    const provider = config.providers[providerName];
+    if (!provider) {
+      ctx.ui.notify(`Provider "${providerName}" not found in models.json`, "error");
+      return;
+    }
+    const oldMode = provider.api || "(not set)";
+    provider.api = matched;
+    (0, import_ollama.writeModelsJson)(config);
+    const lines = [branding];
+    lines.push((0, import_format.section)("API MODE CHANGED"));
+    lines.push((0, import_format.ok)(`Provider: ${providerName}`));
+    lines.push((0, import_format.info)(`Old mode: ${oldMode}`));
+    lines.push((0, import_format.ok)(`New mode: ${matched}`));
+    lines.push((0, import_format.info)(`Description: ${API_MODES[matched]}`));
+    lines.push((0, import_format.warn)("Run /api reload or /reload to apply changes in Pi"));
+    pi.sendMessage({
+      customType: "api-mode-changed",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+    ctx.ui.notify(`API mode set to ${matched}`, "success");
+  }
+  function setUrl(ctx, providerName, url) {
+    if (!url) {
+      ctx.ui.notify("Usage: /api url <base-url>", "error");
+      return;
+    }
+    let normalizedUrl = url.trim();
+    if (!normalizedUrl.startsWith("http")) {
+      normalizedUrl = "http://" + normalizedUrl;
+    }
+    const config = (0, import_ollama.readModelsJson)();
+    const provider = config.providers[providerName];
+    if (!provider) {
+      ctx.ui.notify(`Provider "${providerName}" not found in models.json`, "error");
+      return;
+    }
+    const oldUrl = provider.baseUrl || "(not set)";
+    provider.baseUrl = normalizedUrl;
+    (0, import_ollama.writeModelsJson)(config);
+    const lines = [branding];
+    lines.push((0, import_format.section)("BASE URL CHANGED"));
+    lines.push((0, import_format.ok)(`Provider: ${providerName}`));
+    lines.push((0, import_format.info)(`Old URL: ${oldUrl}`));
+    lines.push((0, import_format.ok)(`New URL: ${normalizedUrl}`));
+    lines.push((0, import_format.warn)("Run /api reload or /reload to apply changes in Pi"));
+    pi.sendMessage({
+      customType: "api-url-changed",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+    ctx.ui.notify(`Base URL set to ${normalizedUrl}`, "success");
+  }
+  function setThink(ctx, providerName, value) {
+    if (!value) {
+      ctx.ui.notify("Usage: /api think <on|off|auto>", "error");
+      return;
+    }
+    const config = (0, import_ollama.readModelsJson)();
+    const provider = config.providers[providerName];
+    if (!provider) {
+      ctx.ui.notify(`Provider "${providerName}" not found in models.json`, "error");
+      return;
+    }
+    const models = provider.models || [];
+    if (models.length === 0) {
+      ctx.ui.notify(`No models found in provider "${providerName}"`, "error");
+      return;
+    }
+    const valLower = value.toLowerCase();
+    const setAll = (state) => {
+      for (const model of models) {
+        if (state === null) {
+          const name = (model.id || "").toLowerCase();
+          model.reasoning = name.includes("deepseek-r1") || name.includes("qwq") || name.includes("o1") || name.includes("o3") || name.includes("think") || name.includes("qwen3");
+        } else {
+          model.reasoning = state;
+        }
+      }
+    };
+    if (valLower === "on" || valLower === "true" || valLower === "1") {
+      setAll(true);
+    } else if (valLower === "off" || valLower === "false" || valLower === "0") {
+      setAll(false);
+    } else if (valLower === "auto") {
+      setAll(null);
+    } else {
+      ctx.ui.notify("Invalid value. Use: on, off, or auto", "error");
+      return;
+    }
+    (0, import_ollama.writeModelsJson)(config);
+    const lines = [branding];
+    lines.push((0, import_format.section)("THINKING MODE"));
+    lines.push((0, import_format.info)(`Provider: ${providerName}`));
+    lines.push((0, import_format.info)(`Mode: ${valLower}`));
+    lines.push((0, import_format.info)(`Affected ${models.length} model(s):`));
+    for (const model of models) {
+      lines.push((0, import_format.info)(`  ${(model.id || "?").padEnd(40)} reasoning: ${model.reasoning ? "true" : "false"}`));
+    }
+    lines.push((0, import_format.warn)("Run /api reload or /reload to apply changes in Pi"));
+    pi.sendMessage({
+      customType: "api-think-changed",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+    ctx.ui.notify(`Thinking set to ${valLower} for ${models.length} model(s)`, "success");
+  }
+  function handleCompat(ctx, providerName, args) {
+    const parts = args.split(/\s+/);
+    const key = parts[0];
+    const value = parts.slice(1).join(" ");
+    if (!key) {
+      const config2 = (0, import_ollama.readModelsJson)();
+      const provider2 = config2.providers[providerName];
+      if (!provider2) {
+        ctx.ui.notify(`Provider "${providerName}" not found`, "error");
+        return;
+      }
+      const compat = provider2.compat || {};
+      const lines2 = [branding];
+      lines2.push((0, import_format.section)("COMPAT FLAGS"));
+      if (Object.keys(compat).length === 0) {
+        lines2.push((0, import_format.info)("No compat flags set"));
+      } else {
+        for (const [k, v] of Object.entries(compat)) {
+          const flag = COMPAT_FLAGS[k];
+          lines2.push((0, import_format.info)(`  ${k}: ${JSON.stringify(v)}${flag ? ` \u2014 ${flag.description}` : ""}`));
+        }
+      }
+      lines2.push((0, import_format.section)("AVAILABLE FLAGS"));
+      for (const [k, flag] of Object.entries(COMPAT_FLAGS)) {
+        lines2.push((0, import_format.info)(`  ${k} = <${flag.values.join(" | ")}>  \u2014 ${flag.description}`));
+      }
+      lines2.push((0, import_format.info)("Usage: /api compat <key> <value>"));
+      pi.sendMessage({
+        customType: "api-compat-flags",
+        content: lines2.join("\n"),
+        display: { type: "content", content: lines2.join("\n") }
+      });
+      return;
+    }
+    if (!value) {
+      const config2 = (0, import_ollama.readModelsJson)();
+      const provider2 = config2.providers[providerName];
+      if (!provider2) {
+        ctx.ui.notify(`Provider "${providerName}" not found`, "error");
+        return;
+      }
+      const current = provider2.compat?.[key];
+      ctx.ui.notify(`${key} = ${current !== void 0 ? JSON.stringify(current) : "(not set)"}`, "info");
+      return;
+    }
+    const config = (0, import_ollama.readModelsJson)();
+    const provider = config.providers[providerName];
+    if (!provider) {
+      ctx.ui.notify(`Provider "${providerName}" not found`, "error");
+      return;
+    }
+    if (!provider.compat) provider.compat = {};
+    let parsedValue = value;
+    if (value === "true") parsedValue = true;
+    else if (value === "false") parsedValue = false;
+    else if (value === "null") parsedValue = null;
+    else {
+      try {
+        parsedValue = JSON.parse(value);
+      } catch {
+      }
+    }
+    const oldValue = provider.compat[key];
+    provider.compat[key] = parsedValue;
+    (0, import_ollama.writeModelsJson)(config);
+    const lines = [branding];
+    lines.push((0, import_format.section)("COMPAT FLAG SET"));
+    lines.push((0, import_format.ok)(`Provider: ${providerName}`));
+    lines.push((0, import_format.info)(`Key: ${key}`));
+    lines.push((0, import_format.info)(`Old value: ${oldValue !== void 0 ? JSON.stringify(oldValue) : "(not set)"}`));
+    lines.push((0, import_format.ok)(`New value: ${JSON.stringify(parsedValue)}`));
+    lines.push((0, import_format.warn)("Run /api reload or /reload to apply changes in Pi"));
+    pi.sendMessage({
+      customType: "api-compat-set",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+    ctx.ui.notify(`Compat flag ${key} set to ${JSON.stringify(parsedValue)}`, "success");
+  }
+  function reloadConfig(ctx) {
+    const lines = [branding];
+    lines.push((0, import_format.section)("RELOAD"));
+    lines.push((0, import_format.ok)("models.json has been modified"));
+    lines.push((0, import_format.info)("To apply changes, run Pi's built-in command:"));
+    lines.push((0, import_format.info)("  /reload"));
+    lines.push((0, import_format.warn)("This will reload all provider configurations from models.json"));
+    pi.sendMessage({
+      customType: "api-reload",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+    ctx.ui.notify("Run /reload to apply models.json changes", "info");
+  }
+  function listModes() {
+    const lines = [branding];
+    lines.push((0, import_format.section)("SUPPORTED API MODES"));
+    const config = (0, import_ollama.readModelsJson)();
+    const provider = resolveProvider(config);
+    const currentMode = provider?.config?.api || "(not set)";
+    for (const [mode, description] of Object.entries(API_MODES)) {
+      const isActive = mode === currentMode;
+      const marker = isActive ? (0, import_format.ok)(" \u25C0 current") : "";
+      lines.push((0, import_format.info)(`  ${mode.padEnd(30)} ${description}${marker}`));
+    }
+    lines.push((0, import_format.info)(""));
+    lines.push((0, import_format.info)("Usage: /api mode <mode>"));
+    pi.sendMessage({
+      customType: "api-modes",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+  }
+  function listProviders(config) {
+    const lines = [branding];
+    lines.push((0, import_format.section)("PROVIDERS"));
+    for (const [name, provider] of Object.entries(config.providers)) {
+      const modelCount = provider.models?.length || 0;
+      const url = provider.baseUrl || "(no URL)";
+      const api = provider.api || "(no mode)";
+      const isLocal = url.includes("localhost") || url.includes("127.0.0.1") || name === "ollama";
+      lines.push((0, import_format.info)(`  ${name}${isLocal ? " (local)" : ""}`));
+      lines.push((0, import_format.info)(`    API: ${api}  |  URL: ${url}  |  Models: ${modelCount}`));
+    }
+    pi.sendMessage({
+      customType: "api-providers",
+      content: lines.join("\n"),
+      display: { type: "content", content: lines.join("\n") }
+    });
+  }
+  pi.registerCompletion?.("api", {
+    getCompletions: () => {
+      return [
+        { value: "mode", label: "mode", description: "Switch API mode" },
+        { value: "url", label: "url", description: "Switch base URL" },
+        { value: "think", label: "think", description: "Toggle thinking mode (on/off/auto)" },
+        { value: "compat", label: "compat", description: "View/set compat flags" },
+        { value: "reload", label: "reload", description: "Reload models.json" },
+        { value: "modes", label: "modes", description: "List all supported API modes" },
+        { value: "providers", label: "providers", description: "List all configured providers" }
+      ];
+    }
+  });
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@vtstech/pi-api",
+  "version": "1.0.3",
+  "description": "API Mode Switcher extension for Pi Coding Agent",
+  "main": "api.js",
+  "keywords": ["pi-package", "pi-extensions"],
+  "license": "MIT",
+  "access": "public",
+  "author": "VTSTech",
+  "homepage": "https://www.vts-tech.org",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VTSTech/pi-coding-agent"
+  },
+  "dependencies": {
+    "@vtstech/pi-shared": "1.0.3"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": ">=0.66"
+  },
+  "pi": {
+    "extensions": ["./api.js"]
+  }
+}