bazilion 0.12.0 → 0.12.2

package/dist/worker.js

@@ -279,6 +279,20 @@ var SERVICES = [
     hint: "MiniMax M2/M3 family via the China endpoint",
     fields: [{ envVar: "MINIMAX_CN_API_KEY", kind: "secret", label: "API key" }]
   },
+  {
+    id: "qwen-token-plan",
+    displayName: "Qwen Token Plan",
+    category: "provider",
+    hint: "Coding-model subscription endpoint in Singapore",
+    fields: [{ envVar: "QWEN_TOKEN_PLAN_API_KEY", kind: "secret", label: "API key" }]
+  },
+  {
+    id: "qwen-token-plan-cn",
+    displayName: "Qwen Token Plan (CN)",
+    category: "provider",
+    hint: "Coding-model subscription endpoint in China",
+    fields: [{ envVar: "QWEN_TOKEN_PLAN_CN_API_KEY", kind: "secret", label: "API key" }]
+  },
   {
     id: "xiaomi",
     displayName: "Xiaomi MiMo",
@@ -1177,37 +1191,142 @@ function piMessagesToProviderView(messages) {
 import { existsSync as existsSync13, mkdirSync as mkdirSync5, readdirSync as readdirSync8, statSync as statSync5 } from "fs";
 import { basename as basename3, join as join18 } from "path";
 import {
-  AuthStorage,
   createAgentSession,
-  createExtensionRuntime,
-  ModelRegistry,
+  DefaultResourceLoader,
   SessionManager,
   SettingsManager
 } from "@earendil-works/pi-coding-agent";
 
-// ../daemon/src/runtime/providers/pi-adapter.ts
-import {
-  getModel,
-  streamSimple,
-  Type
-} from "@earendil-works/pi-ai/compat";
-function defaultBaseUrlFor(providerName) {
+// ../daemon/src/runtime/providers/pi-runtime.ts
+import { InMemoryCredentialStore } from "@earendil-works/pi-ai";
+import { ModelRuntime } from "@earendil-works/pi-coding-agent";
+var PROVIDER_ALIASES = {
+  bedrock: "amazon-bedrock",
+  "azure-openai": "azure-openai-responses"
+};
+var LOCAL_PROVIDERS = {
+  lmstudio: {
+    baseUrl: "http://127.0.0.1:1234/v1",
+    apiKey: "lm-studio",
+    authHeader: false
+  },
+  ollama: { baseUrl: "http://127.0.0.1:11434/v1", apiKey: "ollama", authHeader: false },
+  llamacpp: { baseUrl: "http://127.0.0.1:8080/v1", apiKey: "no-key", authHeader: true }
+};
+var API_KEY_ENV = {
+  anthropic: ["ANTHROPIC_OAUTH_TOKEN", "ANTHROPIC_API_KEY"],
+  openai: ["OPENAI_API_KEY"],
+  google: ["GEMINI_API_KEY"],
+  "azure-openai": ["AZURE_OPENAI_API_KEY"],
+  mistral: ["MISTRAL_API_KEY"],
+  groq: ["GROQ_API_KEY"],
+  cerebras: ["CEREBRAS_API_KEY"],
+  xai: ["XAI_API_KEY"],
+  zai: ["ZAI_API_KEY"],
+  huggingface: ["HF_TOKEN"],
+  openrouter: ["OPENROUTER_API_KEY"],
+  "vercel-ai-gateway": ["AI_GATEWAY_API_KEY"],
+  deepseek: ["DEEPSEEK_API_KEY"],
+  fireworks: ["FIREWORKS_API_KEY"],
+  together: ["TOGETHER_API_KEY"],
+  moonshotai: ["MOONSHOT_API_KEY"],
+  "moonshotai-cn": ["MOONSHOT_CN_API_KEY"],
+  "kimi-coding": ["KIMI_API_KEY"],
+  minimax: ["MINIMAX_API_KEY"],
+  "minimax-cn": ["MINIMAX_CN_API_KEY"],
+  "qwen-token-plan": ["QWEN_TOKEN_PLAN_API_KEY"],
+  "qwen-token-plan-cn": ["QWEN_TOKEN_PLAN_CN_API_KEY"],
+  xiaomi: ["XIAOMI_API_KEY"],
+  "xiaomi-token-plan-ams": ["XIAOMI_TOKEN_PLAN_AMS_API_KEY"],
+  "xiaomi-token-plan-cn": ["XIAOMI_TOKEN_PLAN_CN_API_KEY"],
+  "xiaomi-token-plan-sgp": ["XIAOMI_TOKEN_PLAN_SGP_API_KEY"],
+  "ant-ling": ["ANT_LING_API_KEY"],
+  nvidia: ["NVIDIA_API_KEY"],
+  opencode: ["OPENCODE_API_KEY"],
+  "opencode-go": ["OPENCODE_GO_API_KEY"],
+  "zai-coding-cn": ["ZAI_CODING_CN_API_KEY"],
+  "github-copilot": ["COPILOT_GITHUB_TOKEN"],
+  "cloudflare-ai-gateway": ["CLOUDFLARE_API_KEY"],
+  "cloudflare-workers-ai": ["CLOUDFLARE_API_KEY"],
+  lmstudio: ["LMSTUDIO_API_KEY"],
+  ollama: ["OLLAMA_API_KEY"],
+  llamacpp: ["LLAMACPP_API_KEY"]
+};
+var PROVIDER_ENV = {
+  bedrock: [
+    "AWS_PROFILE",
+    "AWS_BEARER_TOKEN_BEDROCK",
+    "AWS_ACCESS_KEY_ID",
+    "AWS_SECRET_ACCESS_KEY",
+    "AWS_SESSION_TOKEN",
+    "AWS_REGION",
+    "AWS_DEFAULT_REGION"
+  ],
+  "google-vertex": [
+    "GOOGLE_CLOUD_PROJECT",
+    "GOOGLE_CLOUD_LOCATION",
+    "GOOGLE_APPLICATION_CREDENTIALS"
+  ],
+  "cloudflare-ai-gateway": ["CLOUDFLARE_API_KEY", "CLOUDFLARE_ACCOUNT_ID", "CLOUDFLARE_GATEWAY_ID"],
+  "cloudflare-workers-ai": ["CLOUDFLARE_API_KEY", "CLOUDFLARE_ACCOUNT_ID"]
+};
+function piProviderName(providerName) {
+  return PROVIDER_ALIASES[providerName] ?? providerName;
+}
+function providerApiKey(providerName, env) {
+  for (const name of API_KEY_ENV[providerName] ?? []) {
+    const value = env[name];
+    if (value) return value;
+  }
+  return LOCAL_PROVIDERS[providerName]?.apiKey;
+}
+function providerBaseUrl(providerName, env) {
   switch (providerName) {
     case "lmstudio":
-      return process.env.LMSTUDIO_URL ?? "http://127.0.0.1:1234/v1";
+      return env.LMSTUDIO_URL ?? LOCAL_PROVIDERS.lmstudio?.baseUrl;
     case "ollama":
-      return process.env.OLLAMA_URL ?? "http://127.0.0.1:11434/v1";
+      return env.OLLAMA_URL ?? LOCAL_PROVIDERS.ollama?.baseUrl;
+    case "llamacpp":
+      return env.LLAMACPP_URL ?? LOCAL_PROVIDERS.llamacpp?.baseUrl;
+    case "vercel-ai-gateway":
+      return env.AI_GATEWAY_BASE_URL;
+    default:
+      return void 0;
+  }
+}
+function providerCredentialEnv(providerName, env) {
+  const result = {};
+  for (const name of PROVIDER_ENV[providerName] ?? []) {
+    const value = env[name];
+    if (value !== void 0) result[name] = value;
+  }
+  return Object.keys(result).length > 0 ? result : void 0;
+}
+function fallbackApi(providerName) {
+  switch (providerName) {
+    case "anthropic":
+      return "anthropic-messages";
+    case "google":
+      return "google-generative-ai";
+    case "google-vertex":
+      return "google-vertex";
+    case "azure-openai":
+      return "azure-openai-responses";
+    case "bedrock":
+      return "bedrock-converse-stream";
+    case "openai-codex":
+      return "openai-codex-responses";
     default:
-      return "";
+      return "openai-completions";
   }
 }
-function buildModelLiteral(cfg, modelId) {
+function fallbackPiModel(providerName, modelId, baseUrl) {
   return {
     id: modelId,
     name: modelId,
-    api: cfg.fallbackApi,
-    provider: cfg.providerName,
-    baseUrl: cfg.baseUrl ?? defaultBaseUrlFor(cfg.providerName),
+    api: fallbackApi(providerName),
+    provider: piProviderName(providerName),
+    baseUrl: baseUrl ?? "",
     reasoning: false,
     input: ["text"],
     cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
@@ -1215,24 +1334,50 @@ function buildModelLiteral(cfg, modelId) {
     maxTokens: 4096
   };
 }
-function resolveModel(cfg, modelId) {
-  const lookupName = cfg.piProviderName ?? cfg.providerName;
-  try {
-    const known = getModel(
-      lookupName,
-      modelId
-    );
-    if (known && typeof known === "object" && "api" in known) {
-      if (cfg.baseUrl) return { ...known, baseUrl: cfg.baseUrl };
-      return known;
-    }
-  } catch {
+async function createBazilionPiRuntime(options) {
+  const providerName = options.providerName;
+  const canonicalName = piProviderName(providerName);
+  const credentials = new InMemoryCredentialStore();
+  const apiKey = options.apiKey ?? providerApiKey(providerName, options.env);
+  const credentialEnv = providerCredentialEnv(providerName, options.env);
+  if (apiKey || credentialEnv) {
+    await credentials.modify(canonicalName, async () => ({
+      type: "api_key",
+      ...apiKey ? { key: apiKey } : {},
+      ...credentialEnv ? { env: credentialEnv } : {}
+    }));
+  }
+  const runtime = await ModelRuntime.create({ credentials, modelsPath: null });
+  const local = LOCAL_PROVIDERS[providerName];
+  const baseUrl = options.baseUrl ?? providerBaseUrl(providerName, options.env);
+  if (local) {
+    const modelId = options.modelId ?? "model-name";
+    const model = fallbackPiModel(providerName, modelId, baseUrl ?? local.baseUrl);
+    runtime.registerProvider(canonicalName, {
+      baseUrl: baseUrl ?? local.baseUrl,
+      api: "openai-completions",
+      authHeader: local.authHeader,
+      apiKey: apiKey ?? local.apiKey,
+      models: [model]
+    });
+  } else if (baseUrl) {
+    runtime.registerProvider(canonicalName, { baseUrl });
   }
-  return buildModelLiteral(cfg, modelId);
+  return runtime;
+}
+function resolvePiModel(runtime, providerName, modelId, baseUrl) {
+  const known = runtime.getModel(piProviderName(providerName), modelId);
+  if (known) return baseUrl ? { ...known, baseUrl } : known;
+  return fallbackPiModel(providerName, modelId, baseUrl);
 }
 
 // ../daemon/src/runtime/auth/openai-codex.ts
-import { loginOpenAICodex, refreshOpenAICodexToken } from "@earendil-works/pi-ai/oauth";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+
+// ../daemon/src/runtime/providers/pi-adapter.ts
+import {
+  Type
+} from "@earendil-works/pi-ai";
 
 // ../daemon/src/runtime/session/prompt.ts
 import { existsSync as existsSync10, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
@@ -3713,30 +3858,16 @@ async function createBazilionSession(opts) {
   if (enabledProviders.size > 0 && !enabledProviders.has(providerName)) {
     throw new Error(`${providerName} provider is disabled \u2014 enable it on the /config page`);
   }
-  const piProviderName = mapProviderName(providerName);
-  const model = resolveModel(
-    {
-      providerName,
-      piProviderName,
-      fallbackApi: pickFallbackApi(providerName),
-      baseUrl: resolveBaseUrl(providerName, env)
-    },
+  const apiKey = opts.apiKey ?? providerApiKey(providerName, env);
+  const baseUrl = providerBaseUrl(providerName, env);
+  const modelRuntime = await createBazilionPiRuntime({
+    providerName,
+    env,
+    ...apiKey ? { apiKey } : {},
+    ...baseUrl ? { baseUrl } : {},
     modelId
-  );
-  const apiKey = opts.apiKey ?? resolveApiKey(providerName, env);
-  const authStorage = AuthStorage.inMemory();
-  if (apiKey) {
-    authStorage.setRuntimeApiKey(piProviderName, apiKey);
-  }
-  const modelRegistry = ModelRegistry.inMemory(authStorage);
-  if (providerName === "lmstudio" || providerName === "ollama") {
-    modelRegistry.registerProvider(piProviderName, {
-      baseUrl: model.baseUrl,
-      api: "openai-completions",
-      authHeader: false,
-      apiKey: apiKey ?? "dummy"
-    });
-  }
+  });
+  const model = resolvePiModel(modelRuntime, providerName, modelId, baseUrl);
   const cwd = agent.team.path;
   if (!existsSync13(cwd)) mkdirSync5(cwd, { recursive: true });
   const promptSkills = restricted ? [] : loadPromptSkills(paths.skillsDir, agent.skills);
@@ -3766,7 +3897,17 @@ async function createBazilionSession(opts) {
     skills: promptSkills,
     sandboxMode: shellTools?.config.sandboxMode ?? "off"
   });
-  const resourceLoader = createBazilionResourceLoader(bazilionPrompt);
+  const resourceLoader = new DefaultResourceLoader({
+    cwd,
+    agentDir: join18(paths.home, "pi"),
+    settingsManager,
+    noExtensions: true,
+    noSkills: true,
+    noPromptTemplates: true,
+    noThemes: true,
+    noContextFiles: true,
+    appendSystemPrompt: bazilionPrompt ? [bazilionPrompt] : void 0
+  });
   await resourceLoader.reload();
   const bazilionTools = restricted ? restricted.tools : createBazilionCustomTools({
     agent,
@@ -3790,13 +3931,12 @@ async function createBazilionSession(opts) {
     customTools,
     sessionManager,
     settingsManager,
-    authStorage,
-    modelRegistry,
+    modelRuntime,
     resourceLoader
   });
   if (refreshApiKey) {
     session.agent.getApiKey = async (requestedProvider) => {
-      if (requestedProvider !== piProviderName) return void 0;
+      if (requestedProvider !== piProviderName(providerName)) return void 0;
       try {
         return await refreshApiKey(providerName);
       } catch {
@@ -3818,67 +3958,6 @@ function splitModelString(s) {
   }
   return { providerName: s.slice(0, idx), modelId: s.slice(idx + 1) };
 }
-function mapProviderName(name) {
-  if (name === "bedrock") return "amazon-bedrock";
-  return name;
-}
-function pickFallbackApi(providerName) {
-  switch (providerName) {
-    case "anthropic":
-      return "anthropic-messages";
-    case "google":
-      return "google-generative-ai";
-    case "google-vertex":
-      return "google-vertex";
-    case "azure-openai":
-      return "azure-openai-responses";
-    case "bedrock":
-      return "bedrock-converse-stream";
-    case "openai-codex":
-      return "openai-codex-responses";
-    default:
-      return "openai-completions";
-  }
-}
-function resolveBaseUrl(providerName, env) {
-  if (providerName === "lmstudio") return env.LMSTUDIO_URL ?? "http://127.0.0.1:1234/v1";
-  if (providerName === "ollama") return env.OLLAMA_URL ?? "http://127.0.0.1:11434/v1";
-  return void 0;
-}
-function resolveApiKey(providerName, env) {
-  switch (providerName) {
-    case "anthropic":
-      return env.ANTHROPIC_OAUTH_TOKEN ?? env.ANTHROPIC_API_KEY;
-    case "openai":
-      return env.OPENAI_API_KEY;
-    case "google":
-      return env.GEMINI_API_KEY;
-    case "mistral":
-      return env.MISTRAL_API_KEY;
-    case "groq":
-      return env.GROQ_API_KEY;
-    case "cerebras":
-      return env.CEREBRAS_API_KEY;
-    case "xai":
-      return env.XAI_API_KEY;
-    case "zai":
-      return env.ZAI_API_KEY;
-    case "huggingface":
-      return env.HF_TOKEN;
-    case "openrouter":
-      return env.OPENROUTER_API_KEY;
-    case "vercel-ai-gateway":
-      return env.AI_GATEWAY_API_KEY;
-    case "azure-openai":
-      return env.AZURE_OPENAI_API_KEY;
-    case "lmstudio":
-      return env.LMSTUDIO_API_KEY ?? "lm-studio";
-    case "ollama":
-      return env.OLLAMA_API_KEY ?? "ollama";
-    default:
-      return void 0;
-  }
-}
 function toPiThinkingLevel(level) {
   switch (level) {
     case "off":
@@ -3892,22 +3971,6 @@ function toPiThinkingLevel(level) {
       return "medium";
   }
 }
-function createBazilionResourceLoader(appendSystemPrompt) {
-  const extensions = { extensions: [], errors: [], runtime: createExtensionRuntime() };
-  return {
-    getExtensions: () => extensions,
-    getSkills: () => ({ skills: [], diagnostics: [] }),
-    getPrompts: () => ({ prompts: [], diagnostics: [] }),
-    getThemes: () => ({ themes: [], diagnostics: [] }),
-    getAgentsFiles: () => ({ agentsFiles: [] }),
-    getSystemPrompt: () => void 0,
-    getAppendSystemPrompt: () => appendSystemPrompt ? [appendSystemPrompt] : [],
-    extendResources: () => {
-    },
-    async reload() {
-    }
-  };
-}
 function findMostRecent(sessionDir) {
   if (!existsSync13(sessionDir)) return null;
   let newest = null;