@theclawlab/pai 1.0.0

package/dist/index.js

@@ -0,0 +1,2540 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { readFileSync } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/types.ts
+var PAIError = class extends Error {
+  constructor(message, exitCode, context) {
+    super(message);
+    this.exitCode = exitCode;
+    this.context = context;
+    this.name = "PAIError";
+  }
+};
+
+// src/config-manager.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var DEFAULT_SCHEMA_VERSION = "1.0.0";
+var ConfigurationManager = class {
+  configPath;
+  constructor(options = {}) {
+    this.configPath = options.config || process.env.PAI_CONFIG || join(homedir(), ".config", "pai", "default.json");
+  }
+  /**
+   * Load configuration from file
+   * Returns default config if file doesn't exist
+   */
+  async loadConfig() {
+    if (!existsSync(this.configPath)) {
+      return this.getDefaultConfig();
+    }
+    try {
+      const content = await readFile(this.configPath, "utf-8");
+      const config = JSON.parse(content);
+      if (!config.schema_version) {
+        throw new PAIError(
+          "Config file is missing schema_version field",
+          4,
+          { path: this.configPath }
+        );
+      }
+      if (!config.providers) {
+        throw new PAIError(
+          "Config file is missing providers field",
+          4,
+          { path: this.configPath }
+        );
+      }
+      if (!Array.isArray(config.providers)) {
+        throw new PAIError(
+          "Config file providers field must be an array",
+          4,
+          { path: this.configPath }
+        );
+      }
+      return config;
+    } catch (error) {
+      if (error instanceof PAIError) {
+        throw error;
+      }
+      if (error instanceof SyntaxError) {
+        throw new PAIError(
+          "Config file is malformed",
+          4,
+          { path: this.configPath, error: error.message }
+        );
+      }
+      throw new PAIError(
+        "Failed to read config file",
+        4,
+        { path: this.configPath, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Save configuration to file
+   * Creates directory if needed
+   */
+  async saveConfig(config) {
+    if (!config.schema_version) {
+      config.schema_version = DEFAULT_SCHEMA_VERSION;
+    }
+    try {
+      const dir = dirname(this.configPath);
+      if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+      }
+      const content = JSON.stringify(config, null, 2);
+      await writeFile(this.configPath, content, "utf-8");
+    } catch (error) {
+      throw new PAIError(
+        "Failed to write config file",
+        4,
+        { path: this.configPath, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Get provider configuration by name
+   * Throws error if not found
+   */
+  async getProvider(name) {
+    const config = await this.loadConfig();
+    const providerName = name || config.defaultProvider;
+    if (!providerName) {
+      throw new PAIError(
+        "No provider specified and no default provider configured",
+        1,
+        { configPath: this.configPath }
+      );
+    }
+    const provider = config.providers.find((p) => p.name === providerName);
+    if (!provider) {
+      throw new PAIError(
+        `Provider not found: ${providerName}`,
+        1,
+        { provider: providerName, configPath: this.configPath }
+      );
+    }
+    return provider;
+  }
+  /**
+   * Add or update a provider configuration
+   */
+  async addProvider(provider) {
+    const config = await this.loadConfig();
+    const existingIndex = config.providers.findIndex(
+      (p) => p.name === provider.name
+    );
+    if (existingIndex >= 0) {
+      config.providers[existingIndex] = provider;
+    } else {
+      config.providers.push(provider);
+    }
+    await this.saveConfig(config);
+  }
+  /**
+   * Patch an existing provider configuration (merge fields)
+   */
+  async updateProvider(name, updates) {
+    const config = await this.loadConfig();
+    const existingIndex = config.providers.findIndex((p) => p.name === name);
+    if (existingIndex < 0) {
+      throw new PAIError(
+        `Provider not found: ${name}`,
+        1,
+        { provider: name, configPath: this.configPath }
+      );
+    }
+    const existing = config.providers[existingIndex];
+    for (const [key, value] of Object.entries(updates)) {
+      if (key === "name") continue;
+      if (typeof value === "object" && value !== null && !Array.isArray(value) && typeof existing[key] === "object" && existing[key] !== null) {
+        existing[key] = { ...existing[key], ...value };
+      } else {
+        existing[key] = value;
+      }
+    }
+    config.providers[existingIndex] = existing;
+    await this.saveConfig(config);
+  }
+  /**
+   * Set the default provider
+   */
+  async setDefaultProvider(name) {
+    const config = await this.loadConfig();
+    const exists = config.providers.some((p) => p.name === name);
+    if (!exists) {
+      throw new PAIError(
+        `Provider not found: ${name}`,
+        1,
+        { provider: name, configPath: this.configPath }
+      );
+    }
+    config.defaultProvider = name;
+    await this.saveConfig(config);
+  }
+  /**
+   * Set the default embed provider and/or model
+   */
+  async setDefaultEmbed(embedProvider, embedModel) {
+    const config = await this.loadConfig();
+    if (embedProvider) {
+      const exists = config.providers.some((p) => p.name === embedProvider);
+      if (!exists) {
+        throw new PAIError(
+          `Provider not found: ${embedProvider}`,
+          1,
+          { provider: embedProvider, configPath: this.configPath }
+        );
+      }
+      config.defaultEmbedProvider = embedProvider;
+    }
+    if (embedModel) {
+      config.defaultEmbedModel = embedModel;
+    }
+    await this.saveConfig(config);
+  }
+  /**
+   * Delete a provider configuration
+   */
+  async deleteProvider(name) {
+    const config = await this.loadConfig();
+    const existingIndex = config.providers.findIndex((p) => p.name === name);
+    if (existingIndex < 0) {
+      throw new PAIError(
+        `Provider not found: ${name}`,
+        1,
+        { provider: name, configPath: this.configPath }
+      );
+    }
+    config.providers.splice(existingIndex, 1);
+    if (config.defaultProvider === name) {
+      delete config.defaultProvider;
+    }
+    await this.saveConfig(config);
+  }
+  /**
+   * Get default configuration
+   */
+  getDefaultConfig() {
+    return {
+      schema_version: DEFAULT_SCHEMA_VERSION,
+      providers: []
+    };
+  }
+  /**
+   * Get config file path
+   */
+  getConfigPath() {
+    return this.configPath;
+  }
+  /**
+   * Resolve credentials for a provider
+   * Priority: CLI param > env var > config file (apiKey or oauth)
+   */
+  async resolveCredentials(provider, cliKey) {
+    if (cliKey) {
+      return cliKey;
+    }
+    const envVarName = `PAI_${provider.toUpperCase().replace(/-/g, "_")}_API_KEY`;
+    const envKey = process.env[envVarName];
+    if (envKey) {
+      return envKey;
+    }
+    try {
+      const providerConfig = await this.getProvider(provider);
+      if (providerConfig.apiKey) {
+        return providerConfig.apiKey;
+      }
+      if (providerConfig.oauth) {
+        const oauthApiKey = await this.resolveOAuthCredentials(providerConfig);
+        if (oauthApiKey) {
+          return oauthApiKey;
+        }
+      }
+    } catch {
+    }
+    throw new PAIError(
+      `No credentials found for provider: ${provider}`,
+      1,
+      {
+        provider,
+        checkedSources: ["CLI parameter", "environment variable", "config file"]
+      }
+    );
+  }
+  /**
+   * Resolve OAuth credentials from provider config.
+   * Automatically refreshes expired tokens and saves updated credentials.
+   */
+  async resolveOAuthCredentials(providerConfig) {
+    const oauth = providerConfig.oauth;
+    if (!oauth || !oauth.access) {
+      return null;
+    }
+    if (oauth.expires && Date.now() >= oauth.expires) {
+      try {
+        const { getOAuthProvider: getOAuthProvider2 } = await import("@mariozechner/pi-ai/oauth");
+        const oauthProvider = getOAuthProvider2(providerConfig.name);
+        if (oauthProvider) {
+          const newCredentials = await oauthProvider.refreshToken(oauth);
+          providerConfig.oauth = {
+            ...oauth,
+            refresh: newCredentials.refresh,
+            access: newCredentials.access,
+            expires: newCredentials.expires
+          };
+          await this.addProvider(providerConfig);
+          return oauthProvider.getApiKey(providerConfig.oauth);
+        }
+      } catch {
+      }
+    }
+    try {
+      const { getOAuthProvider: getOAuthProvider2 } = await import("@mariozechner/pi-ai/oauth");
+      const oauthProvider = getOAuthProvider2(providerConfig.name);
+      if (oauthProvider) {
+        return oauthProvider.getApiKey(oauth);
+      }
+    } catch {
+    }
+    return oauth.access;
+  }
+};
+
+// src/session-manager.ts
+import { writeFile as writeFile2, appendFile } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+var SessionManager = class {
+  sessionPath;
+  constructor(sessionPath) {
+    this.sessionPath = sessionPath;
+  }
+  /**
+   * Load messages from session file
+   * Returns empty array if file doesn't exist
+   */
+  async loadMessages() {
+    if (!this.sessionPath || !existsSync2(this.sessionPath)) {
+      return [];
+    }
+    try {
+      const messages = [];
+      const fileStream = createReadStream(this.sessionPath, "utf-8");
+      const rl = createInterface({
+        input: fileStream,
+        crlfDelay: Infinity
+      });
+      let lineNumber = 0;
+      for await (const line of rl) {
+        lineNumber++;
+        if (line.trim() === "") {
+          continue;
+        }
+        try {
+          const message = JSON.parse(line);
+          if (!message.role || message.content === void 0) {
+            throw new Error("Missing required fields: role and content");
+          }
+          messages.push(message);
+        } catch (error) {
+          throw new PAIError(
+            `Malformed JSONL at line ${lineNumber}`,
+            4,
+            {
+              path: this.sessionPath,
+              line: lineNumber,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          );
+        }
+      }
+      return messages;
+    } catch (error) {
+      if (error instanceof PAIError) {
+        throw error;
+      }
+      throw new PAIError(
+        "Failed to read session file",
+        4,
+        { path: this.sessionPath, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Append a single message to session file
+   * Creates file if it doesn't exist
+   */
+  async appendMessage(message) {
+    if (!this.sessionPath) {
+      return;
+    }
+    if (!message.timestamp) {
+      message.timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    try {
+      const line = JSON.stringify(message) + "\n";
+      if (existsSync2(this.sessionPath)) {
+        await appendFile(this.sessionPath, line, "utf-8");
+      } else {
+        await writeFile2(this.sessionPath, line, "utf-8");
+      }
+    } catch (error) {
+      throw new PAIError(
+        "Failed to write to session file",
+        4,
+        { path: this.sessionPath, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Append multiple messages to session file
+   * TODO: Implement atomic write for concurrent access
+   */
+  async appendMessages(messages) {
+    if (!this.sessionPath || messages.length === 0) {
+      return;
+    }
+    const timestampedMessages = messages.map((msg) => ({
+      ...msg,
+      timestamp: msg.timestamp || (/* @__PURE__ */ new Date()).toISOString()
+    }));
+    try {
+      const lines = timestampedMessages.map((msg) => JSON.stringify(msg)).join("\n") + "\n";
+      if (existsSync2(this.sessionPath)) {
+        await appendFile(this.sessionPath, lines, "utf-8");
+      } else {
+        await writeFile2(this.sessionPath, lines, "utf-8");
+      }
+    } catch (error) {
+      throw new PAIError(
+        "Failed to write to session file",
+        4,
+        { path: this.sessionPath, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Get the session file path
+   */
+  getSessionPath() {
+    return this.sessionPath;
+  }
+};
+
+// src/input-resolver.ts
+import { readFile as readFile2 } from "fs/promises";
+var InputResolver = class {
+  /**
+   * Resolve user input from message/stdin/file/images
+   * Validates mutual exclusivity of input sources
+   */
+  async resolveUserInput(source) {
+    const sourceCount = [
+      source.message !== void 0,
+      source.stdin === true,
+      source.file !== void 0
+    ].filter(Boolean).length;
+    if (sourceCount > 1) {
+      throw new PAIError(
+        "Multiple input sources specified",
+        1,
+        { message: "Cannot use both positional argument and --input-file or stdin" }
+      );
+    }
+    if (sourceCount === 0) {
+      throw new PAIError(
+        "No user input provided",
+        1,
+        { message: "Provide input via argument, stdin, or --input-file" }
+      );
+    }
+    let textContent;
+    if (source.message !== void 0) {
+      textContent = source.message;
+    } else if (source.stdin) {
+      textContent = await this.readStdin();
+    } else if (source.file) {
+      textContent = await this.readFile(source.file);
+    } else {
+      throw new PAIError("No input source available", 1);
+    }
+    if (source.images && source.images.length > 0) {
+      const content = [{ type: "text", text: textContent }];
+      for (const imagePath of source.images) {
+        const imageData = await this.readImage(imagePath);
+        content.push(imageData);
+      }
+      return content;
+    }
+    return textContent;
+  }
+  /**
+   * Resolve system instruction from text or file
+   */
+  async resolveSystemInput(systemText, systemFile) {
+    if (systemText && systemFile) {
+      throw new PAIError(
+        "Multiple system instruction sources specified",
+        1,
+        { message: "Cannot use both --system and --system-file" }
+      );
+    }
+    if (systemFile) {
+      return await this.readFile(systemFile);
+    }
+    return systemText;
+  }
+  /**
+   * Read from stdin
+   */
+  async readStdin() {
+    return new Promise((resolve, reject) => {
+      let data = "";
+      process.stdin.setEncoding("utf-8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", () => {
+        resolve(data);
+      });
+      process.stdin.on("error", (error) => {
+        reject(
+          new PAIError(
+            "Failed to read from stdin",
+            4,
+            { error: String(error) }
+          )
+        );
+      });
+    });
+  }
+  /**
+   * Read file content
+   */
+  async readFile(path) {
+    try {
+      return await readFile2(path, "utf-8");
+    } catch (error) {
+      throw new PAIError(
+        "Failed to read file",
+        4,
+        { path, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Read image file and encode for pi-ai
+   */
+  async readImage(path) {
+    try {
+      const buffer = await readFile2(path);
+      const base64Data = buffer.toString("base64");
+      const ext = path.toLowerCase().split(".").pop();
+      let mimeType = "image/jpeg";
+      if (ext === "png") mimeType = "image/png";
+      else if (ext === "gif") mimeType = "image/gif";
+      else if (ext === "webp") mimeType = "image/webp";
+      return {
+        type: "image",
+        data: base64Data,
+        mimeType
+      };
+    } catch (error) {
+      throw new PAIError(
+        "Failed to read image file",
+        4,
+        { path, error: String(error) }
+      );
+    }
+  }
+};
+
+// src/output-formatter.ts
+import { appendFile as appendFile2, writeFile as writeFile3 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+
+// src/sanitize.ts
+var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
+  "apikey",
+  "api_key",
+  "apiKey",
+  "access",
+  "access_token",
+  "refresh",
+  "refresh_token",
+  "token",
+  "oauth",
+  "client_secret",
+  "client-secret",
+  "secret",
+  "password",
+  "passwd",
+  "authorization",
+  "auth"
+]);
+function isObject(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function maskPartial(s, keep = 4) {
+  if (s.length <= keep * 2) return "*".repeat(s.length);
+  return s.slice(0, keep) + "*".repeat(Math.max(0, s.length - keep * 2)) + s.slice(-keep);
+}
+var PATTERNS = [
+  // URL query params like ?key=... or &token=...
+  { re: /(https?:\/\/[^\s]*?[?&](?:api_key|apikey|key|token|access_token|auth)=)([^&\s]+)/gi, replace: (_m) => "***REDACTED***" },
+  // OpenAI keys
+  { re: /\bsk-[A-Za-z0-9\-_]{16,}\b/g, replace: (m) => maskPartial(m, 6) },
+  // Anthropic-ish
+  { re: /\bsk-ant-[A-Za-z0-9\-_]{8,}\b/g, replace: (m) => maskPartial(m, 6) },
+  // HuggingFace
+  { re: /\bhf_[A-Za-z0-9\-_]{16,}\b/g, replace: (m) => maskPartial(m, 6) },
+  // Bearer tokens (simple)
+  { re: /\bBearer\s+[A-Za-z0-9\-\._=\/+]{8,}\b/gi, replace: () => "Bearer ***REDACTED***" },
+  // JWT-ish (three base64url parts)
+  { re: /\b[a-zA-Z0-9-_]{10,}\.[a-zA-Z0-9-_]{10,}\.[a-zA-Z0-9-_]{8,}\b/g, replace: () => "JWT <redacted>" },
+  // Long base64-like strings (avoid short hashes)
+  { re: /\b[A-Za-z0-9+\/]{40,}={0,2}\b/g, replace: () => "***REDACTED***" }
+];
+function sanitizeString(input) {
+  if (!input) return { sanitized: input, secrets: [] };
+  let out = input;
+  const found = [];
+  out = out.replace(/(https?:\/\/[^\s]*?[?&](?:api_key|apikey|key|token|access_token|auth)=)([^&\s]+)/gi, (_, prefix, secret) => {
+    found.push(secret);
+    return prefix + "***REDACTED***";
+  });
+  for (const p of PATTERNS) {
+    out = out.replace(p.re, (m) => {
+      found.push(m);
+      try {
+        return p.replace(m);
+      } catch {
+        return "***REDACTED***";
+      }
+    });
+  }
+  return { sanitized: out, secrets: found };
+}
+function sanitizeContent(value) {
+  const secrets = [];
+  function _sanitize(v) {
+    if (v === null || v === void 0) return v;
+    if (typeof v === "string") {
+      const { sanitized: sanitized2, secrets: s } = sanitizeString(v);
+      secrets.push(...s);
+      return sanitized2;
+    }
+    if (Array.isArray(v)) {
+      return v.map((item) => _sanitize(item));
+    }
+    if (isObject(v)) {
+      const out = {};
+      for (const [k, val] of Object.entries(v)) {
+        try {
+          if (SENSITIVE_KEYS.has(k.toLowerCase()) || SENSITIVE_KEYS.has(k)) {
+            if (typeof val === "string") {
+              secrets.push(String(val));
+              out[k] = "***REDACTED***";
+            } else {
+              out[k] = "***REDACTED***";
+            }
+          } else {
+            out[k] = _sanitize(val);
+          }
+        } catch (e) {
+          const str = String(val);
+          const { sanitized: sanitized2, secrets: s } = sanitizeString(str);
+          secrets.push(...s);
+          out[k] = sanitized2;
+        }
+      }
+      return out;
+    }
+    return v;
+  }
+  const sanitized = _sanitize(value);
+  return { sanitized, secrets };
+}
+
+// src/output-formatter.ts
+var OutputFormatter = class {
+  jsonMode;
+  quietMode;
+  logFile;
+  constructor(jsonMode = false, quietMode = false, logFile) {
+    this.jsonMode = jsonMode;
+    this.quietMode = quietMode;
+    this.logFile = logFile;
+  }
+  /**
+   * Write model output to stdout
+   * Always writes to stdout regardless of mode
+   */
+  writeModelOutput(content) {
+    process.stdout.write(content);
+    if (this.logFile) {
+      const { sanitized } = sanitizeString(content);
+      this.appendToLog("assistant", sanitized).catch(() => {
+      });
+    }
+  }
+  /**
+   * Write progress/diagnostic information to stderr
+   */
+  writeProgress(event) {
+    if (this.quietMode) return;
+    if (this.jsonMode) {
+      const sc = sanitizeContent(event.data);
+      const outEvent = { ...event, data: sc.sanitized, timestamp: event.timestamp || Date.now() };
+      this.writeNDJSON(outEvent);
+    } else {
+      const sc = sanitizeContent(event.data);
+      const outEvent = { ...event, data: sc.sanitized };
+      this.writeHumanReadable(outEvent);
+    }
+  }
+  /**
+   * Write error to stderr
+   */
+  writeError(error) {
+    if (this.jsonMode) {
+      const errorObj = {
+        type: "error",
+        message: sanitizeString(error.message).sanitized,
+        ...error instanceof PAIError && error.context ? { context: sanitizeContent(error.context).sanitized } : {}
+      };
+      process.stderr.write(JSON.stringify(errorObj) + "\n");
+    } else {
+      process.stderr.write(`Error: ${sanitizeString(error.message).sanitized}
+`);
+      if (error instanceof PAIError && error.context) {
+        process.stderr.write(`Context: ${JSON.stringify(sanitizeContent(error.context).sanitized)}
+`);
+      }
+    }
+    if (this.logFile) {
+      const msg = sanitizeString(error.message).sanitized;
+      const ctx = error instanceof PAIError && error.context ? JSON.stringify(sanitizeContent(error.context).sanitized) : "{}";
+      this.appendToLog("error", `${msg}
+
+Context: ${ctx}`).catch(() => {
+      });
+    }
+  }
+  /**
+   * Write NDJSON event to stderr
+   */
+  writeNDJSON(event) {
+    const line = JSON.stringify({
+      ...event,
+      timestamp: event.timestamp || Date.now()
+    });
+    process.stderr.write(line + "\n");
+  }
+  /**
+   * Write human-readable event to stderr
+   */
+  writeHumanReadable(event) {
+    switch (event.type) {
+      case "start": {
+        const d = event.data;
+        const parts = [`Starting request (${d.provider || "?"}/${d.model || "?"}`];
+        if (d.messages) parts.push(`${d.messages} msgs`);
+        if (d.tools) parts.push(`${d.tools} tools`);
+        if (d.stream) parts.push("stream");
+        process.stderr.write(parts.join(", ") + ")...\n");
+        break;
+      }
+      case "chunk":
+        break;
+      case "tool_call":
+        process.stderr.write(`Tool call: ${JSON.stringify(event.data)}
+`);
+        break;
+      case "tool_result":
+        process.stderr.write(`Tool result: ${JSON.stringify(event.data)}
+`);
+        break;
+      case "complete": {
+        const d = event.data;
+        const parts = ["Request complete"];
+        if (d.finishReason) parts.push(`reason=${d.finishReason}`);
+        if (d.usage) parts.push(`tokens: in=${d.usage.input} out=${d.usage.output}`);
+        process.stderr.write(parts.join(", ") + ".\n");
+        break;
+      }
+      case "error":
+        process.stderr.write(`Error: ${event.data}
+`);
+        break;
+    }
+  }
+  /**
+   * Append to log file in Markdown format
+   */
+  async appendToLog(role, content) {
+    if (!this.logFile) return;
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const entry = `
+### ${role.charAt(0).toUpperCase() + role.slice(1)} (${timestamp})
+
+${content}
+`;
+      if (existsSync3(this.logFile)) {
+        await appendFile2(this.logFile, entry, "utf-8");
+      } else {
+        const header = `# Chat Log
+
+Generated: ${timestamp}
+`;
+        await writeFile3(this.logFile, header + entry, "utf-8");
+      }
+    } catch (error) {
+      throw new PAIError(
+        "Failed to write to log file",
+        4,
+        { path: this.logFile, error: String(error) }
+      );
+    }
+  }
+  /**
+   * Log user message
+   */
+  async logUserMessage(content) {
+    if (this.logFile) {
+      await this.appendToLog("user", content).catch(() => {
+      });
+    }
+  }
+  /**
+   * Log system message
+   */
+  async logSystemMessage(content) {
+    if (this.logFile) {
+      await this.appendToLog("system", content).catch(() => {
+      });
+    }
+  }
+  /**
+   * Log request summary (provider, model, parameters)
+   */
+  async logRequestSummary(info) {
+    if (this.logFile) {
+      const lines = [
+        `Provider: ${info.provider}`,
+        `Model: ${info.model}`
+      ];
+      if (info.temperature !== void 0) lines.push(`Temperature: ${info.temperature}`);
+      if (info.maxTokens !== void 0) lines.push(`Max Tokens: ${info.maxTokens}`);
+      if (info.stream) lines.push(`Stream: true`);
+      await this.appendToLog("request", lines.join("\n")).catch(() => {
+      });
+    }
+  }
+  /**
+   * Log tool call
+   */
+  async logToolCall(name, args) {
+    if (this.logFile) {
+      const content = `**Tool:** ${name}
+\`\`\`json
+${JSON.stringify(args, null, 2)}
+\`\`\``;
+      await this.appendToLog("tool_call", content).catch(() => {
+      });
+    }
+  }
+  /**
+   * Log tool result
+   */
+  async logToolResult(name, result) {
+    if (this.logFile) {
+      const content = `**Tool:** ${name}
+\`\`\`json
+${JSON.stringify(result, null, 2)}
+\`\`\``;
+      await this.appendToLog("tool_result", content).catch(() => {
+      });
+    }
+  }
+  /**
+   * Log error
+   */
+  async logError(error) {
+    if (this.logFile) {
+      const detail = error instanceof PAIError && error.context ? `
+
+Context: ${JSON.stringify(error.context)}` : "";
+      await this.appendToLog("error", `${error.message}${detail}`).catch(() => {
+      });
+    }
+  }
+};
+
+// src/llm-client.ts
+import { getModel, stream, complete } from "@mariozechner/pi-ai";
+function buildModel(config) {
+  if (config.api) {
+    return {
+      id: config.model,
+      name: config.model,
+      api: config.api,
+      provider: config.provider,
+      baseUrl: config.baseUrl || "",
+      reasoning: config.reasoning ?? false,
+      input: config.input ?? ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: config.contextWindow ?? 128e3,
+      maxTokens: config.maxTokens ?? 16384
+    };
+  }
+  try {
+    return getModel(config.provider, config.model);
+  } catch {
+    return {
+      id: config.model,
+      name: config.model,
+      api: "openai-completions",
+      provider: config.provider,
+      baseUrl: config.baseUrl || "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128e3,
+      maxTokens: 16384
+    };
+  }
+}
+var LLMClient = class {
+  config;
+  model;
+  constructor(config) {
+    this.config = config;
+    this.model = buildModel(config);
+  }
+  /**
+   * Chat with streaming responses
+   */
+  async *chat(messages, tools) {
+    const context = this.buildContext(messages, tools);
+    const options = this.buildOptions();
+    const streamResult = stream(this.model, context, options);
+    let currentContent = "";
+    let currentToolCalls = [];
+    for await (const event of streamResult) {
+      switch (event.type) {
+        case "text_delta":
+          currentContent += event.delta;
+          yield {
+            content: event.delta,
+            finishReason: "streaming"
+          };
+          break;
+        case "toolcall_end":
+          currentToolCalls.push({
+            id: event.toolCall.id,
+            name: event.toolCall.name,
+            arguments: event.toolCall.arguments
+          });
+          break;
+        case "done": {
+          const usageData = event.usage;
+          const doneResponse = {
+            content: currentContent,
+            finishReason: event.reason,
+            ...usageData ? {
+              usage: {
+                input: usageData.input ?? 0,
+                output: usageData.output ?? 0,
+                ...usageData.cost ? { cost: { total: usageData.cost.total ?? 0 } } : {}
+              }
+            } : {}
+          };
+          if (currentToolCalls.length > 0) {
+            doneResponse.toolCalls = currentToolCalls;
+          }
+          yield doneResponse;
+          break;
+        }
+        case "error":
+          throw new Error(event.error.errorMessage || "LLM request failed");
+      }
+    }
+  }
+  /**
+   * Chat without streaming (complete response)
+   */
+  async chatComplete(messages, tools) {
+    const context = this.buildContext(messages, tools);
+    const options = this.buildOptions();
+    const result = await complete(this.model, context, options);
+    let content = "";
+    const toolCalls = [];
+    for (const block of result.content) {
+      if (block.type === "text") {
+        content += block.text;
+      } else if (block.type === "toolCall") {
+        toolCalls.push({
+          id: block.id,
+          name: block.name,
+          arguments: block.arguments
+        });
+      }
+    }
+    const response = {
+      content,
+      finishReason: result.stopReason,
+      ...result.usage ? {
+        usage: {
+          input: result.usage.input ?? 0,
+          output: result.usage.output ?? 0,
+          ...result.usage.cost ? { cost: { total: result.usage.cost.total ?? 0 } } : {}
+        }
+      } : {}
+    };
+    if (toolCalls.length > 0) {
+      response.toolCalls = toolCalls;
+    }
+    return response;
+  }
+  /**
+   * Build context for pi-ai
+   */
+  buildContext(messages, tools) {
+    const piMessages = messages.map((msg) => {
+      if (msg.role === "system") {
+        return { role: "system", content: String(msg.content) };
+      } else if (msg.role === "user") {
+        return { role: "user", content: this.formatContent(msg.content), timestamp: Date.now() };
+      } else if (msg.role === "assistant") {
+        return this.buildAssistantMessage(msg);
+      } else if (msg.role === "tool") {
+        return {
+          role: "toolResult",
+          toolCallId: msg.tool_call_id || "",
+          toolName: msg.name || "",
+          content: [{ type: "text", text: String(msg.content) }],
+          isError: false,
+          timestamp: Date.now()
+        };
+      }
+      return { role: "user", content: String(msg.content), timestamp: Date.now() };
+    });
+    let systemPrompt;
+    let contextMessages = piMessages;
+    if (piMessages.length > 0 && piMessages[0]?.role === "system") {
+      systemPrompt = String(piMessages[0].content);
+      contextMessages = piMessages.slice(1);
+    }
+    const context = {
+      messages: contextMessages
+    };
+    if (systemPrompt) {
+      context.systemPrompt = systemPrompt;
+    }
+    if (tools && tools.length > 0) {
+      context.tools = tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }));
+    }
+    return context;
+  }
+  /**
+   * Build a pi-ai AssistantMessage from a PAI Message.
+   * pi-ai expects assistant messages with content as an array of typed blocks.
+   */
+  buildAssistantMessage(msg) {
+    const contentBlocks = [];
+    const textContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    if (textContent) {
+      contentBlocks.push({ type: "text", text: textContent });
+    }
+    const toolCalls = msg.tool_calls;
+    if (toolCalls && Array.isArray(toolCalls)) {
+      for (const tc of toolCalls) {
+        contentBlocks.push({
+          type: "toolCall",
+          id: tc.id,
+          name: tc.name,
+          arguments: tc.arguments
+        });
+      }
+    }
+    return {
+      role: "assistant",
+      content: contentBlocks,
+      api: this.model.api,
+      provider: this.model.provider,
+      model: this.model.id,
+      usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+      stopReason: toolCalls ? "toolUse" : "stop",
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Format message content for pi-ai
+   */
+  formatContent(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (Array.isArray(content)) {
+      return content;
+    }
+    if (typeof content === "object") {
+      return JSON.stringify(content);
+    }
+    return String(content);
+  }
+  /**
+   * Build options for pi-ai, including provider-specific options
+   */
+  buildOptions() {
+    const options = {
+      apiKey: this.config.apiKey
+    };
+    if (this.config.temperature !== void 0) {
+      options.temperature = this.config.temperature;
+    }
+    if (this.config.maxTokens !== void 0) {
+      options.maxTokens = this.config.maxTokens;
+    }
+    if (this.config.providerOptions) {
+      Object.assign(options, this.config.providerOptions);
+    }
+    return options;
+  }
+  /**
+   * Get model information
+   */
+  getModel() {
+    return this.model;
+  }
+};
+
+// src/tools/bash-exec.ts
+import { exec, execSync } from "child_process";
+import { platform } from "os";
+var BASH_EXEC_TOOL_MAX_OUTPUT_MB = 8;
+var BASH_EXEC_TOOL_MAX_TIMEOUT_S = 3600;
+function detectShell() {
+  const isWin32 = platform() === "win32";
+  if (!isWin32) {
+    return "bash";
+  }
+  const shellEnv = process.env.SHELL;
+  if (shellEnv && /bash/i.test(shellEnv)) {
+    return shellEnv;
+  }
+  try {
+    execSync("bash --version", { stdio: "ignore", timeout: 3e3 });
+    return "bash";
+  } catch {
+  }
+  throw new Error(
+    "bash is required but was not found on this Windows system. Please install one of: Git Bash, MSYS2, Cygwin, or use WSL2."
+  );
+}
+var BASH_EXEC_DESCRIPTION = "Execute a shell command and return the result. Supports pipes, redirections, xargs, heredocs, and shell scripts. Use cwd parameter to set working directory. Running on bash.";
+function createBashExecTool() {
+  const shell = detectShell();
+  return {
+    name: "bash_exec",
+    description: BASH_EXEC_DESCRIPTION,
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute. Supports bash syntax including pipes, redirections, xargs, heredocs, etc."
+        },
+        cwd: {
+          type: "string",
+          description: "Optional working directory for command execution"
+        },
+        comment: {
+          type: "string",
+          description: "very short briefing about intention and reason of this tool call, improve observability and auditability to the user."
+        }
+      },
+      required: ["command", "comment"]
+    },
+    handler: async (args) => {
+      if (!args.command) {
+        return {
+          stdout: "",
+          stderr: "Error: empty command",
+          exitCode: 1
+        };
+      }
+      return new Promise((resolve) => {
+        const options = {
+          shell,
+          maxBuffer: BASH_EXEC_TOOL_MAX_OUTPUT_MB * 1024 * 1024,
+          timeout: BASH_EXEC_TOOL_MAX_TIMEOUT_S * 1e3,
+          encoding: "buffer"
+        };
+        if (args.cwd) {
+          options.cwd = args.cwd;
+        }
+        exec(args.command, options, (error, stdout, stderr) => {
+          const stdoutBuf = stdout || Buffer.alloc(0);
+          const stderrBuf = stderr || Buffer.alloc(0);
+          resolve({
+            stdout: stdoutBuf.toString("utf-8"),
+            stderr: stderrBuf.toString("utf-8"),
+            exitCode: error ? error.code ?? 1 : 0
+          });
+        });
+      });
+    }
+  };
+}
+
+// src/tool-registry.ts
+var ToolRegistry = class {
+  tools;
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+    this.registerBuiltinTools();
+  }
+  /**
+   * Register built-in tools
+   */
+  registerBuiltinTools() {
+    this.register(createBashExecTool());
+  }
+  /**
+   * Register a tool
+   */
+  register(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  /**
+   * Get a tool by name
+   */
+  get(name) {
+    return this.tools.get(name);
+  }
+  /**
+   * Get all registered tools
+   */
+  getAll() {
+    return Array.from(this.tools.values());
+  }
+  /**
+   * Execute a tool by name with arguments
+   */
+  async execute(name, args) {
+    const tool = this.get(name);
+    if (!tool) {
+      throw new Error(`Tool not found: ${name}`);
+    }
+    return await tool.handler(args);
+  }
+  /**
+   * Check if a tool exists
+   */
+  has(name) {
+    return this.tools.has(name);
+  }
+  /**
+   * Get tool count
+   */
+  size() {
+    return this.tools.size;
+  }
+};
+
+// src/commands/chat.ts
+import { getModels } from "@mariozechner/pi-ai";
+var DEFAULT_MAX_TURNS = 100;
+async function handleChatCommand(prompt, options) {
+  const configManager = new ConfigurationManager(options);
+  const sessionManager = new SessionManager(options.session);
+  const inputResolver = new InputResolver();
+  const outputFormatter = new OutputFormatter(
+    options.json,
+    options.quiet,
+    options.log
+  );
+  const toolRegistry = new ToolRegistry();
+  try {
+    if (options.temperature !== void 0) {
+      if (isNaN(options.temperature) || !isFinite(options.temperature)) {
+        throw new PAIError(
+          "Invalid temperature value",
+          1,
+          { temperature: options.temperature, message: "Temperature must be a finite number" }
+        );
+      }
+      if (options.temperature < 0 || options.temperature > 2) {
+        throw new PAIError(
+          "Invalid temperature value",
+          1,
+          { temperature: options.temperature, message: "Temperature must be between 0 and 2" }
+        );
+      }
+    }
+    if (options.maxTokens !== void 0) {
+      if (isNaN(options.maxTokens) || !isFinite(options.maxTokens)) {
+        throw new PAIError(
+          "Invalid maxTokens value",
+          1,
+          { maxTokens: options.maxTokens, message: "maxTokens must be a finite number" }
+        );
+      }
+      if (options.maxTokens <= 0) {
+        throw new PAIError(
+          "Invalid maxTokens value",
+          1,
+          { maxTokens: options.maxTokens, message: "maxTokens must be greater than 0" }
+        );
+      }
+    }
+    const provider = await configManager.getProvider(options.provider);
+    let modelName = options.model || provider.defaultModel || provider.models?.[0];
+    if (!modelName) {
+      try {
+        const knownModels = getModels(provider.name);
+        if (knownModels.length > 0) {
+          modelName = knownModels[0].id;
+        }
+      } catch {
+      }
+    }
+    if (!modelName) {
+      throw new PAIError(
+        "No model specified",
+        1,
+        { provider: provider.name, message: "Specify --model or configure a default model" }
+      );
+    }
+    const apiKey = await configManager.resolveCredentials(provider.name, void 0);
+    if (options.dryRun) {
+      const info = {
+        provider: provider.name,
+        model: modelName,
+        configFile: configManager.getConfigPath(),
+        temperature: options.temperature ?? provider.temperature,
+        maxTokens: options.maxTokens ?? provider.maxTokens,
+        stream: options.stream ?? false,
+        credentialSource: "resolved"
+      };
+      process.stderr.write(JSON.stringify(info, null, 2) + "\n");
+      return;
+    }
+    const llmClient = new LLMClient({
+      provider: provider.name,
+      model: modelName,
+      apiKey,
+      temperature: options.temperature ?? provider.temperature,
+      maxTokens: options.maxTokens ?? provider.maxTokens,
+      stream: options.stream,
+      api: provider.api,
+      baseUrl: provider.baseUrl,
+      reasoning: provider.reasoning,
+      input: provider.input,
+      contextWindow: provider.contextWindow,
+      providerOptions: provider.providerOptions
+    });
+    const messages = await sessionManager.loadMessages();
+    const loadedMessageCount = messages.length;
+    const newMessages = [];
+    const systemInstruction = await inputResolver.resolveSystemInput(
+      options.system,
+      options.systemFile
+    );
+    if (systemInstruction) {
+      if (messages.length > 0 && messages[0]?.role === "system") {
+        messages[0] = { role: "system", content: systemInstruction };
+      } else {
+        const sysMsg = { role: "system", content: systemInstruction };
+        messages.unshift(sysMsg);
+        newMessages.push(sysMsg);
+      }
+      await outputFormatter.logSystemMessage(systemInstruction);
+    }
+    const hasExplicitInput = prompt !== void 0 || options.inputFile !== void 0;
+    const stdinAvailable = !process.stdin.isTTY && !hasExplicitInput;
+    const userInput = await inputResolver.resolveUserInput({
+      message: prompt,
+      stdin: stdinAvailable,
+      file: options.inputFile,
+      images: options.image
+    });
+    const userMessage = { role: "user", content: userInput };
+    const lastLoadedIsUser = loadedMessageCount > 0 && messages[messages.length - 1]?.role === "user";
+    if (lastLoadedIsUser) {
+      messages[messages.length - 1] = userMessage;
+    } else {
+      messages.push(userMessage);
+      newMessages.push(userMessage);
+    }
+    await outputFormatter.logUserMessage(
+      typeof userInput === "string" ? userInput : JSON.stringify(userInput)
+    );
+    await outputFormatter.logRequestSummary({
+      provider: provider.name,
+      model: modelName,
+      temperature: options.temperature ?? provider.temperature,
+      maxTokens: options.maxTokens ?? provider.maxTokens,
+      stream: options.stream
+    });
+    const tools = toolRegistry.getAll();
+    let continueLoop = true;
+    let maxTurns = options.maxTurns ?? DEFAULT_MAX_TURNS;
+    const turnsLimit = maxTurns;
+    let finalRoundAttempted = false;
+    const systemMsg = messages.find((m) => m.role === "system");
+    const userMsg = [...messages].reverse().find((m) => m.role === "user");
+    const systemChars = systemMsg ? String(systemMsg.content).length : 0;
+    const userChars = userMsg ? typeof userMsg.content === "string" ? userMsg.content.length : JSON.stringify(userMsg.content).length : 0;
+    while (continueLoop && maxTurns > 0) {
+      maxTurns--;
+      const isLastTurn = maxTurns === 0;
+      const currentTools = isLastTurn ? [] : tools;
+      if (isLastTurn) {
+        process.stderr.write(
+          `[Info] Approaching tool-call turn limit. Requesting final text response from model.
+`
+        );
+      }
+      outputFormatter.writeProgress({ type: "start", data: {
+        provider: provider.name,
+        model: modelName,
+        stream: options.stream ?? false,
+        messages: messages.length,
+        systemChars,
+        userChars,
+        tools: currentTools.length
+      } });
+      let assistantMessage;
+      let lastResponse;
+      if (options.stream) {
+        let fullContent = "";
+        const toolCalls2 = [];
+        for await (const response of llmClient.chat(messages, currentTools)) {
+          if (response.content && response.finishReason === "streaming") {
+            fullContent += response.content;
+            outputFormatter.writeModelOutput(response.content);
+          }
+          if (response.finishReason !== "streaming") {
+            lastResponse = response;
+            if (response.toolCalls) {
+              toolCalls2.push(...response.toolCalls);
+            }
+          }
+        }
+        assistantMessage = {
+          role: "assistant",
+          content: fullContent
+        };
+        if (toolCalls2.length > 0) {
+          assistantMessage.tool_calls = toolCalls2;
+        }
+      } else {
+        const response = await llmClient.chatComplete(messages, currentTools);
+        lastResponse = response;
+        outputFormatter.writeModelOutput(response.content);
+        assistantMessage = {
+          role: "assistant",
+          content: response.content
+        };
+        if (response.toolCalls) {
+          assistantMessage.tool_calls = response.toolCalls;
+        }
+      }
+      messages.push(assistantMessage);
+      newMessages.push(assistantMessage);
+      outputFormatter.writeProgress({ type: "complete", data: {
+        finishReason: lastResponse?.finishReason ?? "unknown",
+        usage: lastResponse?.usage
+      } });
+      const toolCalls = assistantMessage.tool_calls;
+      if (toolCalls && toolCalls.length > 0) {
+        for (const toolCall of toolCalls) {
+          outputFormatter.writeProgress({
+            type: "tool_call",
+            data: { name: toolCall.name, arguments: toolCall.arguments }
+          });
+          await outputFormatter.logToolCall(toolCall.name, toolCall.arguments);
+          if (maxTurns <= 0) {
+            const rejectContent = `Error: Tool-call turn limit (${turnsLimit}) reached. Please provide a final text summary without further tool calls.`;
+            const rejectMessage = {
+              role: "tool",
+              name: toolCall.name,
+              tool_call_id: toolCall.id,
+              content: rejectContent
+            };
+            messages.push(rejectMessage);
+            newMessages.push(rejectMessage);
+            outputFormatter.writeProgress({
+              type: "tool_result",
+              data: { error: rejectContent }
+            });
+            await outputFormatter.logToolResult(toolCall.name, { error: rejectContent });
+            continue;
+          }
+          try {
+            const result = await toolRegistry.execute(
+              toolCall.name,
+              toolCall.arguments
+            );
+            const toolResultMessage = {
+              role: "tool",
+              name: toolCall.name,
+              tool_call_id: toolCall.id,
+              content: JSON.stringify(result)
+            };
+            messages.push(toolResultMessage);
+            newMessages.push(toolResultMessage);
+            outputFormatter.writeProgress({
+              type: "tool_result",
+              data: result
+            });
+            await outputFormatter.logToolResult(toolCall.name, result);
+          } catch (error) {
+            const errorMessage = {
+              role: "tool",
+              name: toolCall.name,
+              tool_call_id: toolCall.id,
+              content: `Error: ${error instanceof Error ? error.message : String(error)}`
+            };
+            messages.push(errorMessage);
+            newMessages.push(errorMessage);
+            outputFormatter.writeProgress({
+              type: "tool_result",
+              data: { error: String(error) }
+            });
+            await outputFormatter.logToolResult(toolCall.name, { error: String(error) });
+          }
+        }
+        if (maxTurns <= 0) {
+          if (finalRoundAttempted) {
+            process.stderr.write(
+              `[Warning] Model continues to request tool calls after final round. Stopping.
+`
+            );
+            continueLoop = false;
+          } else {
+            finalRoundAttempted = true;
+            process.stderr.write(
+              `[Warning] Tool-call turn limit (${turnsLimit}) reached. Making one final request for a text summary.
+`
+            );
+            maxTurns = 1;
+          }
+        }
+        continueLoop = true;
+      } else {
+        continueLoop = false;
+      }
+    }
+    if (options.append !== false && sessionManager.getSessionPath()) {
+      await sessionManager.appendMessages(newMessages);
+    }
+  } catch (error) {
+    if (error instanceof PAIError) {
+      await outputFormatter.logError(error);
+      outputFormatter.writeError(error);
+      process.exit(error.exitCode);
+    } else {
+      const paiError = new PAIError(
+        error instanceof Error ? error.message : String(error),
+        2,
+        { originalError: String(error) }
+      );
+      await outputFormatter.logError(paiError);
+      outputFormatter.writeError(paiError);
+      process.exit(2);
+    }
+  }
+}
+
+// src/embedding-client.ts
+var PROVIDER_DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com"
+};
+var EmbeddingClient = class _EmbeddingClient {
+  endpoint;
+  apiKey;
+  model;
+  isAzure;
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.model = config.model;
+    const apiType = config.api ?? config.provider;
+    this.isAzure = apiType === "azure-openai-responses" || apiType === "azure-openai";
+    this.endpoint = this.isAzure ? _EmbeddingClient.resolveAzureEndpoint(config.baseUrl, config.model, config.providerOptions) : _EmbeddingClient.resolveEndpoint(config.provider, config.baseUrl);
+  }
+  /**
+   * Resolve the full embeddings API endpoint URL.
+   * If baseUrl is provided, use it; otherwise fall back to the provider default.
+   */
+  static resolveEndpoint(provider, baseUrl) {
+    const base = baseUrl ?? (Object.hasOwn(PROVIDER_DEFAULT_BASE_URLS, provider) ? PROVIDER_DEFAULT_BASE_URLS[provider] : void 0);
+    if (!base) {
+      throw new PAIError(
+        `No base URL configured for provider "${provider}". Please specify a baseUrl.`,
+        1 /* PARAMETER_ERROR */,
+        { provider }
+      );
+    }
+    return `${base.replace(/\/+$/, "")}/v1/embeddings`;
+  }
+  /**
+   * Resolve the Azure OpenAI embeddings endpoint URL.
+   * Azure format: {baseUrl}/openai/deployments/{deployment}/embeddings?api-version={version}
+   */
+  static resolveAzureEndpoint(baseUrl, model, providerOptions) {
+    if (!baseUrl) {
+      throw new PAIError(
+        "Azure OpenAI requires a baseUrl. Please specify a baseUrl.",
+        1 /* PARAMETER_ERROR */
+      );
+    }
+    const deployment = model ?? providerOptions?.azureDeploymentName;
+    if (!deployment) {
+      throw new PAIError(
+        "Azure OpenAI requires a deployment name. Specify a model or set providerOptions.azureDeploymentName.",
+        1 /* PARAMETER_ERROR */
+      );
+    }
+    const apiVersion = providerOptions?.azureApiVersion;
+    const resolvedVersion = apiVersion && /^\d{4}-\d{2}-\d{2}/.test(apiVersion) ? apiVersion : "2024-06-01";
+    const resourceBase = baseUrl.replace(/\/openai\/v1\/?$/, "").replace(/\/+$/, "");
+    return `${resourceBase}/openai/deployments/${deployment}/embeddings?api-version=${resolvedVersion}`;
+  }
+  /**
+   * Call the embedding API for the given texts.
+   */
+  async embed(request) {
+    const body = JSON.stringify({
+      model: request.model,
+      input: request.texts
+    });
+    let response;
+    try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (this.isAzure) {
+        headers["api-key"] = this.apiKey;
+      } else {
+        headers["Authorization"] = `Bearer ${this.apiKey}`;
+      }
+      response = await fetch(this.endpoint, {
+        method: "POST",
+        headers,
+        body
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new PAIError(
+        `Network error calling embedding API: ${message}`,
+        2 /* RUNTIME_ERROR */,
+        { endpoint: this.endpoint, cause: message }
+      );
+    }
+    if (!response.ok) {
+      let detail = "";
+      try {
+        const errorBody = await response.text();
+        detail = errorBody;
+      } catch {
+      }
+      throw new PAIError(
+        `Embedding API error (${response.status}): ${detail || response.statusText}`,
+        3 /* API_ERROR */,
+        { status: response.status, detail }
+      );
+    }
+    const json = await response.json();
+    const sorted = [...json.data].sort((a, b) => a.index - b.index);
+    return {
+      embeddings: sorted.map((d) => d.embedding),
+      model: json.model,
+      usage: {
+        promptTokens: json.usage.prompt_tokens,
+        totalTokens: json.usage.total_tokens
+      }
+    };
+  }
+};
+
+// src/embed-model-resolver.ts
+function resolveEmbedModel(options, config) {
+  const provider = options.provider ?? config.defaultEmbedProvider ?? config.defaultProvider;
+  if (!provider) {
+    throw new PAIError(
+      "No embed provider specified and no default provider configured",
+      1 /* PARAMETER_ERROR */
+    );
+  }
+  const model = options.model ?? config.defaultEmbedModel;
+  if (!model) {
+    throw new PAIError(
+      "No embed model specified and no default embed model configured",
+      1 /* PARAMETER_ERROR */
+    );
+  }
+  return { provider, model };
+}
+
+// src/embedding-models.ts
+var EMBEDDING_MODEL_LIMITS = {
+  // OpenAI
+  "text-embedding-3-small": 8191,
+  "text-embedding-3-large": 8191,
+  "text-embedding-ada-002": 8191,
+  // Google
+  "text-embedding-004": 2048,
+  // Cohere
+  "embed-english-v3.0": 512,
+  "embed-multilingual-v3.0": 512,
+  "embed-english-light-v3.0": 512,
+  "embed-multilingual-light-v3.0": 512
+};
+var CHARS_PER_TOKEN = 4;
+function estimateTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateText(text, model) {
+  const limit = EMBEDDING_MODEL_LIMITS[model];
+  const originalTokens = estimateTokens(text);
+  if (limit === void 0) {
+    return { text, truncated: false, originalTokens };
+  }
+  if (originalTokens <= limit) {
+    return { text, truncated: false, originalTokens };
+  }
+  const maxChars = limit * CHARS_PER_TOKEN;
+  return {
+    text: text.slice(0, maxChars),
+    truncated: true,
+    originalTokens
+  };
+}
+
+// src/embed-io.ts
+function vectorToHex(vec) {
+  const buf = new ArrayBuffer(4);
+  const view = new DataView(buf);
+  const result = new Array(vec.length);
+  for (let i = 0; i < vec.length; i++) {
+    view.setFloat32(0, vec[i], false);
+    let hex = "";
+    for (let b = 0; b < 4; b++) {
+      const byte = view.getUint8(b);
+      hex += (byte < 16 ? "0" : "") + byte.toString(16);
+    }
+    result[i] = hex;
+  }
+  return result;
+}
+function parseBatchInput(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new PAIError(
+      "Invalid batch input: not valid JSON",
+      1 /* PARAMETER_ERROR */
+    );
+  }
+  if (!Array.isArray(parsed)) {
+    throw new PAIError(
+      "Invalid batch input: expected a JSON array of strings",
+      1 /* PARAMETER_ERROR */
+    );
+  }
+  for (let i = 0; i < parsed.length; i++) {
+    if (typeof parsed[i] !== "string") {
+      throw new PAIError(
+        `Invalid batch input: element at index ${i} is not a string`,
+        1 /* PARAMETER_ERROR */
+      );
+    }
+  }
+  return parsed;
+}
+function formatEmbeddingOutput(result, options) {
+  if (!options.json) {
+    return result.embeddings.map((emb) => JSON.stringify(vectorToHex(emb))).join("\n");
+  }
+  const usage = {
+    prompt_tokens: result.usage.promptTokens,
+    total_tokens: result.usage.totalTokens
+  };
+  if (options.batch) {
+    return JSON.stringify({
+      embeddings: result.embeddings.map((emb) => vectorToHex(emb)),
+      model: result.model,
+      usage
+    });
+  }
+  return JSON.stringify({
+    embedding: vectorToHex(result.embeddings[0]),
+    model: result.model,
+    usage
+  });
+}
+
+// src/commands/embed.ts
+async function handleEmbedCommand(text, options) {
+  const configManager = new ConfigurationManager(options);
+  const inputResolver = new InputResolver();
+  const outputFormatter = new OutputFormatter(
+    options.json,
+    options.quiet ?? true
+  );
+  try {
+    const config = await configManager.loadConfig();
+    const { provider: providerName, model: modelName } = resolveEmbedModel(options, config);
+    const providerConfig = config.providers.find((p) => p.name === providerName);
+    if (!providerConfig) {
+      throw new PAIError(
+        `Provider not found: ${providerName}`,
+        1 /* PARAMETER_ERROR */,
+        { provider: providerName }
+      );
+    }
+    const apiKey = await configManager.resolveCredentials(providerName, void 0);
+    const hasExplicitInput = text !== void 0 || options.inputFile !== void 0;
+    const stdinAvailable = !process.stdin.isTTY && !hasExplicitInput;
+    const sourceCount = [
+      text !== void 0,
+      stdinAvailable,
+      options.inputFile !== void 0
+    ].filter(Boolean).length;
+    if (sourceCount > 1) {
+      throw new PAIError(
+        "Multiple input sources specified",
+        1 /* PARAMETER_ERROR */,
+        { message: "Provide input via argument, stdin, or --input-file (only one)" }
+      );
+    }
+    let rawInput;
+    if (text !== void 0) {
+      rawInput = text;
+    } else if (options.inputFile) {
+      rawInput = await inputResolver.resolveUserInput({
+        file: options.inputFile
+      });
+    } else if (stdinAvailable) {
+      rawInput = await inputResolver.resolveUserInput({
+        stdin: true
+      });
+    } else {
+      throw new PAIError(
+        "No input text provided",
+        1 /* PARAMETER_ERROR */,
+        { message: "Provide input via argument, stdin, or --input-file" }
+      );
+    }
+    let texts;
+    if (options.batch) {
+      texts = parseBatchInput(rawInput);
+    } else {
+      texts = [rawInput];
+    }
+    texts = texts.map((t) => {
+      const result = truncateText(t, modelName);
+      if (result.truncated) {
+        const truncatedTokens = Math.ceil(result.text.length / 4);
+        const modelLimit = EMBEDDING_MODEL_LIMITS[modelName] ?? truncatedTokens;
+        if (options.json) {
+          const warning = {
+            type: "warning",
+            data: {
+              message: `Input text truncated from ~${result.originalTokens} tokens to ${truncatedTokens} tokens (model limit: ${modelLimit})`,
+              originalTokens: result.originalTokens,
+              truncatedTokens
+            }
+          };
+          process.stderr.write(JSON.stringify(warning) + "\n");
+        } else {
+          process.stderr.write(
+            `[Warning] Input text truncated from ~${result.originalTokens} tokens to ${truncatedTokens} tokens (model limit: ${modelLimit})
+`
+          );
+        }
+      }
+      return result.text;
+    });
+    outputFormatter.writeProgress({
+      type: "start",
+      data: {
+        provider: providerName,
+        model: modelName,
+        texts: texts.length,
+        batch: options.batch ?? false
+      }
+    });
+    const clientConfig = {
+      provider: providerName,
+      apiKey,
+      model: modelName
+    };
+    if (providerConfig.baseUrl) {
+      clientConfig.baseUrl = providerConfig.baseUrl;
+    }
+    if (providerConfig.providerOptions) {
+      clientConfig.providerOptions = providerConfig.providerOptions;
+    }
+    if (providerConfig.api) {
+      clientConfig.api = providerConfig.api;
+    }
+    const client = new EmbeddingClient(clientConfig);
+    const response = await client.embed({ texts, model: modelName });
+    outputFormatter.writeProgress({
+      type: "complete",
+      data: {
+        model: response.model,
+        usage: response.usage
+      }
+    });
+    const output = formatEmbeddingOutput(response, {
+      json: options.json ?? false,
+      batch: options.batch ?? false
+    });
+    process.stdout.write(output + "\n");
+  } catch (error) {
+    if (error instanceof PAIError) {
+      outputFormatter.writeError(error);
+      process.exit(error.exitCode);
+    } else {
+      const paiError = new PAIError(
+        error instanceof Error ? error.message : String(error),
+        2 /* RUNTIME_ERROR */,
+        { originalError: String(error) }
+      );
+      outputFormatter.writeError(paiError);
+      process.exit(2 /* RUNTIME_ERROR */);
+    }
+  }
+}
+
+// src/commands/model.ts
+import { getProviders, getModels as getModels2 } from "@mariozechner/pi-ai";
+import { getOAuthProvider, getOAuthProviders } from "@mariozechner/pi-ai/oauth";
+import { createInterface as createInterface2 } from "readline";
+async function handleModelList(options) {
+  const configManager = new ConfigurationManager(options);
+  try {
+    const config = await configManager.loadConfig();
+    if (!options.json) {
+      console.log(`Config: ${configManager.getConfigPath()}
+`);
+    } else {
+      process.stderr.write(`Config: ${configManager.getConfigPath()}
+`);
+    }
+    if (options.all) {
+      const allProviders = getProviders();
+      if (options.json) {
+        const output = {
+          defaultEmbedProvider: config.defaultEmbedProvider ?? null,
+          defaultEmbedModel: config.defaultEmbedModel ?? null,
+          providers: allProviders.map((provider) => {
+            const models = getModels2(provider);
+            const configured = config.providers.some((p) => p.name === provider);
+            return {
+              name: provider,
+              provider,
+              configured,
+              models: models.map((m) => m.id)
+            };
+          })
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        if (config.defaultEmbedProvider || config.defaultEmbedModel) {
+          const ep = config.defaultEmbedProvider ?? "(not set)";
+          const em = config.defaultEmbedModel ?? "(not set)";
+          console.log(`Default Embed: ${ep}/${em}
+`);
+        }
+        console.log("Available Providers:\n");
+        for (const provider of allProviders) {
+          const models = getModels2(provider);
+          const configured = config.providers.some((p) => p.name === provider);
+          const status = configured ? "\u2713" : " ";
+          console.log(`[${status}] ${provider}`);
+          console.log(`    Models: ${models.length} available`);
+          if (models.length > 0 && models.length <= 5) {
+            models.forEach((m) => console.log(`      - ${m.id}`));
+          }
+          console.log();
+        }
+      }
+    } else {
+      if (config.providers.length === 0) {
+        console.log("No providers configured.");
+        console.log('Use "pai model config --add" to add a provider.');
+        return;
+      }
+      if (options.json) {
+        const output = {
+          defaultEmbedProvider: config.defaultEmbedProvider ?? null,
+          defaultEmbedModel: config.defaultEmbedModel ?? null,
+          providers: config.providers.map((p) => ({
+            name: p.name,
+            provider: p.name,
+            configured: true,
+            models: p.models || [],
+            defaultModel: p.defaultModel
+          }))
+        };
+        console.log(JSON.stringify(output, null, 2));
+      } else {
+        if (config.defaultEmbedProvider || config.defaultEmbedModel) {
+          const ep = config.defaultEmbedProvider ?? "(not set)";
+          const em = config.defaultEmbedModel ?? "(not set)";
+          console.log(`Default Embed: ${ep}/${em}
+`);
+        }
+        console.log("Configured Providers:\n");
+        for (const provider of config.providers) {
+          console.log(`\u2713 ${provider.name}`);
+          if (provider.defaultModel) {
+            console.log(`    Default: ${provider.defaultModel}`);
+          }
+          if (provider.models && provider.models.length > 0) {
+            console.log(`    Models: ${provider.models.join(", ")}`);
+          }
+          console.log();
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof PAIError) {
+      console.error(`Error: ${error.message}`);
+      process.exit(error.exitCode);
+    } else {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(2);
+    }
+  }
+}
+async function handleModelConfig(options) {
+  const configManager = new ConfigurationManager(options);
+  try {
+    process.stderr.write(`Config: ${configManager.getConfigPath()}
+`);
+    if (options.show) {
+      if (!options.name) {
+        throw new PAIError("Provider name is required", 1, {
+          message: "Use --name <provider-name>"
+        });
+      }
+      const provider = await configManager.getProvider(options.name);
+      const masked = { ...provider };
+      if (masked.apiKey) masked.apiKey = "***";
+      if (masked.oauth) {
+        masked.oauth = {
+          ...masked.oauth,
+          refresh: "***",
+          access: "***"
+        };
+      }
+      if (options.json) {
+        console.log(JSON.stringify(masked, null, 2));
+      } else {
+        console.log(`
+Provider: ${provider.name}`);
+        for (const [key, value] of Object.entries(masked)) {
+          if (key === "name") continue;
+          if (typeof value === "object" && value !== null) {
+            console.log(`  ${key}: ${JSON.stringify(value)}`);
+          } else {
+            console.log(`  ${key}: ${value}`);
+          }
+        }
+      }
+    } else if (options.add) {
+      if (!options.name) {
+        throw new PAIError("Provider name is required", 1, {
+          message: "Use --name <provider-name>"
+        });
+      }
+      if (!options.provider) {
+        throw new PAIError("Provider type is required", 1, {
+          message: "Use --provider <provider-type>"
+        });
+      }
+      const supportedProviders = getProviders();
+      if (!supportedProviders.includes(options.provider)) {
+        throw new PAIError(
+          `Unsupported provider: ${options.provider}`,
+          1,
+          {
+            message: `Supported providers: ${supportedProviders.join(", ")}`
+          }
+        );
+      }
+      const providerConfig = {
+        name: options.name
+      };
+      const knownKeys = /* @__PURE__ */ new Set([
+        "apiKey",
+        "defaultModel",
+        "models",
+        "temperature",
+        "maxTokens",
+        "api",
+        "baseUrl",
+        "reasoning",
+        "input",
+        "contextWindow",
+        "providerOptions"
+      ]);
+      if (options.set && options.set.length > 0) {
+        for (const setting of options.set) {
+          const eqIndex = setting.indexOf("=");
+          if (eqIndex < 1) {
+            throw new PAIError(
+              `Invalid --set format: ${setting}`,
+              1,
+              { message: "Use --set key=value" }
+            );
+          }
+          const key = setting.substring(0, eqIndex);
+          const value = setting.substring(eqIndex + 1);
+          const topKey = key.split(".")[0];
+          if (!knownKeys.has(topKey)) {
+            console.error(`Warning: unknown key "${key}". Known keys: ${[...knownKeys].join(", ")}`);
+          }
+          if (key.includes(".")) {
+            const parts = key.split(".");
+            let target = providerConfig;
+            for (let i = 0; i < parts.length - 1; i++) {
+              const part = parts[i];
+              if (!target[part] || typeof target[part] !== "object") {
+                target[part] = {};
+              }
+              target = target[part];
+            }
+            target[parts[parts.length - 1]] = value;
+          } else {
+            providerConfig[key] = value;
+          }
+        }
+      }
+      await configManager.addProvider(providerConfig);
+      if (options.default) {
+        await configManager.setDefaultProvider(options.name);
+      }
+      console.log(`Provider "${options.name}" configured successfully.`);
+    } else if (options.update) {
+      if (!options.name) {
+        throw new PAIError("Provider name is required", 1, {
+          message: "Use --name <provider-name>"
+        });
+      }
+      if (!options.set || options.set.length === 0) {
+        throw new PAIError("No fields to update", 1, {
+          message: "Use --set key=value to specify fields to update"
+        });
+      }
+      const knownKeys = /* @__PURE__ */ new Set([
+        "apiKey",
+        "defaultModel",
+        "models",
+        "temperature",
+        "maxTokens",
+        "api",
+        "baseUrl",
+        "reasoning",
+        "input",
+        "contextWindow",
+        "providerOptions"
+      ]);
+      const updates = {};
+      for (const setting of options.set) {
+        const eqIndex = setting.indexOf("=");
+        if (eqIndex < 1) {
+          throw new PAIError(
+            `Invalid --set format: ${setting}`,
+            1,
+            { message: "Use --set key=value" }
+          );
+        }
+        const key = setting.substring(0, eqIndex);
+        const value = setting.substring(eqIndex + 1);
+        const topKey = key.split(".")[0];
+        if (!knownKeys.has(topKey)) {
+          console.error(`Warning: unknown key "${key}". Known keys: ${[...knownKeys].join(", ")}`);
+        }
+        if (key.includes(".")) {
+          const parts = key.split(".");
+          let target = updates;
+          for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!target[part] || typeof target[part] !== "object") {
+              target[part] = {};
+            }
+            target = target[part];
+          }
+          target[parts[parts.length - 1]] = value;
+        } else {
+          updates[key] = value;
+        }
+      }
+      await configManager.updateProvider(options.name, updates);
+      if (options.default) {
+        await configManager.setDefaultProvider(options.name);
+      }
+      console.log(`Provider "${options.name}" updated successfully.`);
+    } else if (options.delete) {
+      if (!options.name) {
+        throw new PAIError("Provider name is required", 1, {
+          message: "Use --name <provider-name>"
+        });
+      }
+      await configManager.deleteProvider(options.name);
+      console.log(`Provider "${options.name}" deleted successfully.`);
+    } else {
+      throw new PAIError("No action specified", 1, {
+        message: "Use --add, --update, --delete, or --show"
+      });
+    }
+  } catch (error) {
+    if (error instanceof PAIError) {
+      console.error(`Error: ${error.message}`);
+      if (error.context) {
+        console.error(`Context: ${JSON.stringify(error.context)}`);
+      }
+      process.exit(error.exitCode);
+    } else {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(2);
+    }
+  }
+}
+async function handleModelDefault(options) {
+  const configManager = new ConfigurationManager(options);
+  try {
+    const hasSetEmbed = options.embedProvider || options.embedModel;
+    if (options.name || hasSetEmbed) {
+      if (options.name) {
+        await configManager.setDefaultProvider(options.name);
+      }
+      if (hasSetEmbed) {
+        await configManager.setDefaultEmbed(options.embedProvider, options.embedModel);
+      }
+      const parts = [];
+      if (options.name) parts.push(`Default provider set to "${options.name}".`);
+      if (options.embedProvider) parts.push(`Default embed provider set to "${options.embedProvider}".`);
+      if (options.embedModel) parts.push(`Default embed model set to "${options.embedModel}".`);
+      console.log(parts.join("\n"));
+    } else {
+      const config = await configManager.loadConfig();
+      if (options.json) {
+        console.log(JSON.stringify({
+          defaultProvider: config.defaultProvider ?? null,
+          defaultEmbedProvider: config.defaultEmbedProvider ?? null,
+          defaultEmbedModel: config.defaultEmbedModel ?? null
+        }));
+      } else {
+        if (config.defaultProvider) {
+          console.log(`Default provider: ${config.defaultProvider}`);
+        } else {
+          console.log("No default provider configured.");
+          console.log('Use "pai model default --name <provider>" to set one.');
+        }
+        if (config.defaultEmbedProvider || config.defaultEmbedModel) {
+          const embedParts = [];
+          if (config.defaultEmbedProvider) embedParts.push(`provider: ${config.defaultEmbedProvider}`);
+          if (config.defaultEmbedModel) embedParts.push(`model: ${config.defaultEmbedModel}`);
+          console.log(`Default embed: ${embedParts.join(", ")}`);
+        }
+      }
+    }
+  } catch (error) {
+    if (error instanceof PAIError) {
+      console.error(`Error: ${error.message}`);
+      if (error.context) {
+        console.error(`Context: ${JSON.stringify(error.context)}`);
+      }
+      process.exit(error.exitCode);
+    } else {
+      console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      process.exit(2);
+    }
+  }
+}
+async function handleModelLogin(options) {
+  const configManager = new ConfigurationManager(options);
+  try {
+    if (!options.name) {
+      throw new PAIError("Provider name is required", 1, {
+        message: "Use --name <provider-name>"
+      });
+    }
+    const oauthProviders = getOAuthProviders();
+    const oauthProvider = getOAuthProvider(options.name);
+    if (!oauthProvider) {
+      const oauthIds = oauthProviders.map((p) => p.id).join(", ");
+      throw new PAIError(
+        `Provider "${options.name}" does not support OAuth login`,
+        1,
+        { message: `OAuth providers: ${oauthIds}` }
+      );
+    }
+    const rl = createInterface2({ input: process.stdin, output: process.stdout });
+    const prompt = (msg) => new Promise((resolve) => rl.question(`${msg} `, resolve));
+    try {
+      console.log(`Logging in to ${oauthProvider.name}...`);
+      const credentials = await oauthProvider.login({
+        onAuth: (info) => {
+          console.log(`
+Open this URL in your browser:
+${info.url}`);
+          if (info.instructions) console.log(info.instructions);
+          console.log();
+        },
+        onPrompt: async (p) => {
+          return await prompt(
+            `${p.message}${p.placeholder ? ` (${p.placeholder})` : ""}:`
+          );
+        },
+        onProgress: (msg) => console.log(msg)
+      });
+      let providerConfig;
+      try {
+        providerConfig = await configManager.getProvider(options.name);
+      } catch {
+        providerConfig = { name: options.name };
+      }
+      providerConfig.oauth = {
+        refresh: credentials.refresh,
+        access: credentials.access,
+        expires: credentials.expires,
+        ...Object.fromEntries(
+          Object.entries(credentials).filter(
+            ([k]) => !["refresh", "access", "expires"].includes(k)
+          )
+        )
+      };
+      await configManager.addProvider(providerConfig);
+      console.log(`
+Provider "${options.name}" logged in and credentials saved to config.`);
+    } finally {
+      rl.close();
+    }
+  } catch (error) {
+    if (error instanceof PAIError) {
+      console.error(`Error: ${error.message}`);
+      if (error.context) {
+        console.error(`Context: ${JSON.stringify(error.context)}`);
+      }
+      process.exit(error.exitCode);
+    } else {
+      console.error(
+        `Error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      process.exit(2);
+    }
+  }
+}
+
+// src/help.ts
+var MAIN_EXAMPLES = `
+Examples:
+  $ pai chat "Hello, how are you?"                    # \u7B80\u5355\u5BF9\u8BDD
+  $ echo "Explain this" | pai chat                    # stdin \u8F93\u5165
+  $ pai chat "Write a story" --stream                 # \u6D41\u5F0F\u8F93\u51FA
+  $ pai model config --add --name openai --provider openai --set apiKey=sk-...
+  $ pai model list                                    # \u67E5\u770B\u5DF2\u914D\u7F6E provider
+  $ pai model default --name openai                   # \u8BBE\u7F6E\u9ED8\u8BA4 provider`;
+var MAIN_VERBOSE = `
+Prerequisites:
+  \u4F7F\u7528\u524D\u9700\u5148\u914D\u7F6E\u81F3\u5C11\u4E00\u4E2A provider:
+    pai model config --add --name <name> --provider <type> --set apiKey=<key>
+  \u6216\u4F7F\u7528 OAuth \u767B\u5F55:
+    pai model login --name github-copilot
+
+Config:
+  \u9ED8\u8BA4\u914D\u7F6E\u6587\u4EF6: ~/.config/pai/default.json
+  \u53EF\u901A\u8FC7 --config <path> \u6216 PAI_CONFIG \u73AF\u5883\u53D8\u91CF\u8986\u76D6
+
+Exit Codes:
+  0  \u6210\u529F
+  1  \u53C2\u6570/\u7528\u6CD5\u9519\u8BEF
+  2  \u672C\u5730\u8FD0\u884C\u65F6\u9519\u8BEF
+  3  \u5916\u90E8 API/Provider \u9519\u8BEF
+  4  IO/\u6587\u4EF6\u9519\u8BEF`;
+var CHAT_EXAMPLES = `
+Examples:
+  $ pai chat "What is the capital of France?"
+  $ echo "Summarize this" | pai chat                  # stdin \u8F93\u5165
+  $ cat doc.txt | pai chat "Summarize this document"
+  $ pai chat "Hello" --session chat.jsonl             # \u591A\u8F6E\u5BF9\u8BDD
+  $ pai chat "Describe this" --image photo.jpg        # \u56FE\u7247\u5206\u6790
+  $ pai chat --dry-run --provider openai              # \u67E5\u770B\u914D\u7F6E\u4E0D\u8C03\u7528 LLM
+
+Stdin:
+  \u652F\u6301\u901A\u8FC7\u7BA1\u9053\u4F20\u5165\u7528\u6237\u6D88\u606F\uFF0C\u4E0E --input-file \u548C\u4F4D\u7F6E\u53C2\u6570\u4E92\u65A5\u3002
+
+JSON output (--json):
+  \u8FDB\u5EA6\u4FE1\u606F\u4EE5 NDJSON \u8F93\u51FA\u5230 stderr\uFF0CLLM \u56DE\u590D\u8F93\u51FA\u5230 stdout\u3002`;
+var EMBED_EXAMPLES = `
+Examples:
+  $ pai embed "hello world" --provider openai --model text-embedding-3-small
+  $ echo "hello" | pai embed                          # stdin \u8F93\u5165
+  $ pai embed --input-file doc.txt                    # \u6587\u4EF6\u8F93\u5165
+  $ pai embed --batch '["hello","world"]'             # \u6279\u91CF\u6A21\u5F0F
+
+Stdin:
+  \u652F\u6301\u901A\u8FC7\u7BA1\u9053\u4F20\u5165\u6587\u672C\u3002\u4E0E\u4F4D\u7F6E\u53C2\u6570\u548C --input-file \u4E92\u65A5\u3002
+
+JSON output (--json):
+  \u5355\u6761: {"embedding":[...],"model":"...","usage":{...}}
+  \u6279\u91CF: {"embeddings":[[...],[...]],"model":"...","usage":{...}}`;
+var MODEL_LIST_EXAMPLES = `
+Examples:
+  $ pai model list                                    # \u5DF2\u914D\u7F6E provider
+  $ pai model list --all                              # \u6240\u6709\u652F\u6301\u7684 provider
+  $ pai model list --json                             # JSON \u8F93\u51FA`;
+var MODEL_CONFIG_EXAMPLES = `
+Examples:
+  $ pai model config --add --name openai --provider openai --set apiKey=sk-...
+  $ pai model config --update --name openai --set defaultModel=gpt-4o
+  $ pai model config --show --name openai             # \u67E5\u770B\u914D\u7F6E\uFF08\u654F\u611F\u4FE1\u606F\u8131\u654F\uFF09
+  $ pai model config --delete --name openai
+
+Note:
+  --add \u5BF9\u540C\u540D provider \u6267\u884C upsert\uFF08\u5E42\u7B49\u64CD\u4F5C\uFF09\u3002`;
+var MODEL_DEFAULT_EXAMPLES = `
+Examples:
+  $ pai model default                                 # \u67E5\u770B\u5F53\u524D\u9ED8\u8BA4
+  $ pai model default --name openai                   # \u8BBE\u7F6E\u9ED8\u8BA4 provider
+  $ pai model default --embed-provider openai --embed-model text-embedding-3-small`;
+var MODEL_LOGIN_EXAMPLES = `
+Examples:
+  $ pai model login --name github-copilot             # OAuth \u767B\u5F55
+  $ pai model login --name anthropic                  # Anthropic OAuth
+
+Supported: github-copilot, anthropic, google-gemini-cli, google-antigravity, openai-codex`;
+function installHelp(program2) {
+  program2.addHelpText("after", MAIN_EXAMPLES);
+  installVerboseHelp(program2);
+}
+function addSubcommandExamples(cmd, name) {
+  const examples = {
+    "chat": CHAT_EXAMPLES,
+    "embed": EMBED_EXAMPLES,
+    "list": MODEL_LIST_EXAMPLES,
+    "config": MODEL_CONFIG_EXAMPLES,
+    "default": MODEL_DEFAULT_EXAMPLES,
+    "login": MODEL_LOGIN_EXAMPLES
+  };
+  const text = examples[name];
+  if (text) {
+    cmd.addHelpText("after", text);
+  }
+}
+function installVerboseHelp(program2) {
+  program2.option("--verbose", "(\u4E0E --help \u4E00\u8D77\u4F7F\u7528) \u663E\u793A\u5B8C\u6574\u5E2E\u52A9\u4FE1\u606F");
+  program2.on("option:verbose", () => {
+    program2.__verboseHelp = true;
+  });
+  program2.addHelpText("afterAll", () => {
+    if (program2.__verboseHelp) {
+      return MAIN_VERBOSE;
+    }
+    return "";
+  });
+}
+
+// src/index.ts
+process.stdout.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
+process.stderr.on("error", (err) => {
+  if (err.code === "EPIPE") process.exit(0);
+  throw err;
+});
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var packageJson = JSON.parse(
+  readFileSync(join2(__dirname, "../package.json"), "utf8")
+);
+var piAiVersion = "unknown";
+try {
+  const piAiPkg = JSON.parse(
+    readFileSync(join2(__dirname, "../node_modules/@mariozechner/pi-ai/package.json"), "utf8")
+  );
+  piAiVersion = piAiPkg.version;
+} catch {
+}
+var versionString = `pai ${packageJson.version} (pi-ai ${piAiVersion}, Node ${process.version})`;
+var program = new Command();
+program.name("pai").description("PAI - A Unix-style CLI tool for interacting with LLMs").version(versionString).showHelpAfterError(true).configureOutput({
+  writeErr: (str) => process.stderr.write(str),
+  writeOut: (str) => process.stdout.write(str)
+});
+program.exitOverride();
+installHelp(program);
+var chatCmd = program.command("chat").description("Chat with an LLM").argument("[prompt]", "User message (or use stdin/--input-file)").option("--config <path>", "Config file path").option("--session <path>", "Session file path (JSONL)").option("--system <text>", "System instruction").option("--system-file <path>", "System instruction from file").option("--input-file <path>", "User input from file").option("--image <path...>", "Image file(s) to include").option("--provider <name>", "Provider name").option("--model <name>", "Model name").option("--temperature <number>", "Temperature (0-2)", parseFloat).option("--max-tokens <number>", "Max tokens", parseInt).option("--stream", "Enable streaming output").option("--no-append", "Do not append to session file").option("--json", "Output progress as NDJSON").option("--quiet", "Suppress progress output").option("--log <path>", "Log file path (Markdown)").option("--max-turns <number>", "Max tool-call turns (default: 100)", parseInt).option("--dry-run", "Show resolved config without calling LLM").action(async (prompt, options) => {
+  await handleChatCommand(prompt, options);
+});
+addSubcommandExamples(chatCmd, "chat");
+var embedCmd = program.command("embed").description("Generate text embeddings").argument("[text]", "Text to embed (or use stdin/--input-file)").option("--provider <name>", "Provider name").option("--model <name>", "Embedding model name").option("--config <path>", "Config file path").option("--json", "Output as JSON").option("--quiet", "Suppress progress output").option("--batch", "Enable batch embedding mode (input is JSON string array)").option("--input-file <path>", "Read input from file").action(async (text, options) => {
+  await handleEmbedCommand(text, options);
+});
+addSubcommandExamples(embedCmd, "embed");
+var modelCommand = program.command("model").description("Manage model configurations");
+modelCommand.command("list").description("List providers and models").option("--config <path>", "Config file path").option("--all", "Show all supported providers").option("--json", "Output as JSON").action(async (options) => {
+  await handleModelList(options);
+});
+addSubcommandExamples(modelCommand.commands.find((c) => c.name() === "list"), "list");
+modelCommand.command("config").description("Configure providers").option("--config <path>", "Config file path").option("--add", "Add or update provider").option("--update", "Update fields on an existing provider").option("--delete", "Delete provider").option("--show", "Show provider configuration").option("--name <name>", "Provider name").option("--provider <type>", "Provider type").option("--set <key=value...>", "Set configuration values").option("--default", "Set as default provider (with --add or --update)").option("--json", "Output as JSON").action(async (options) => {
+  await handleModelConfig(options);
+});
+addSubcommandExamples(modelCommand.commands.find((c) => c.name() === "config"), "config");
+modelCommand.command("login").description("Login to an OAuth provider (github-copilot, anthropic, google-gemini-cli, etc.)").option("--config <path>", "Config file path").option("--name <name>", "Provider name").action(async (options) => {
+  await handleModelLogin(options);
+});
+addSubcommandExamples(modelCommand.commands.find((c) => c.name() === "login"), "login");
+modelCommand.command("default").description("View or set the default provider").option("--config <path>", "Config file path").option("--name <name>", "Provider name to set as default").option("--embed-provider <name>", "Set default embed provider").option("--embed-model <model>", "Set default embed model").option("--json", "Output as JSON").action(async (options) => {
+  await handleModelDefault(options);
+});
+addSubcommandExamples(modelCommand.commands.find((c) => c.name() === "default"), "default");
+program.on("command:*", () => {
+  process.stderr.write(`Invalid command: ${program.args.join(" ")}
+See --help for available commands.
+`);
+  process.exit(2);
+});
+(async () => {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err && typeof err === "object" && "exitCode" in err) {
+      const exitCode = err.exitCode;
+      process.exitCode = exitCode === 1 ? 2 : exitCode;
+    } else {
+      process.stderr.write(`Error: ${err instanceof Error ? err.message : String(err)}
+`);
+      process.exitCode = 2;
+    }
+  }
+})();
+//# sourceMappingURL=index.js.map