teleton 0.6.0 → 0.7.1

package/dist/chunk-LRCPA7SC.js

@@ -0,0 +1,149 @@
+// src/config/providers.ts
+var PROVIDER_REGISTRY = {
+  anthropic: {
+    id: "anthropic",
+    displayName: "Anthropic (Claude)",
+    envVar: "ANTHROPIC_API_KEY",
+    keyPrefix: "sk-ant-",
+    keyHint: "sk-ant-api03-...",
+    consoleUrl: "https://console.anthropic.com/",
+    defaultModel: "claude-opus-4-5-20251101",
+    utilityModel: "claude-3-5-haiku-20241022",
+    toolLimit: null,
+    piAiProvider: "anthropic"
+  },
+  openai: {
+    id: "openai",
+    displayName: "OpenAI (GPT-4o)",
+    envVar: "OPENAI_API_KEY",
+    keyPrefix: "sk-",
+    keyHint: "sk-proj-...",
+    consoleUrl: "https://platform.openai.com/api-keys",
+    defaultModel: "gpt-4o",
+    utilityModel: "gpt-4o-mini",
+    toolLimit: 128,
+    piAiProvider: "openai"
+  },
+  google: {
+    id: "google",
+    displayName: "Google (Gemini)",
+    envVar: "GOOGLE_API_KEY",
+    keyPrefix: null,
+    keyHint: "AIza...",
+    consoleUrl: "https://aistudio.google.com/apikey",
+    defaultModel: "gemini-2.5-flash",
+    utilityModel: "gemini-2.0-flash-lite",
+    toolLimit: 128,
+    piAiProvider: "google"
+  },
+  xai: {
+    id: "xai",
+    displayName: "xAI (Grok)",
+    envVar: "XAI_API_KEY",
+    keyPrefix: "xai-",
+    keyHint: "xai-...",
+    consoleUrl: "https://console.x.ai/",
+    defaultModel: "grok-3",
+    utilityModel: "grok-3-mini-fast",
+    toolLimit: 128,
+    piAiProvider: "xai"
+  },
+  groq: {
+    id: "groq",
+    displayName: "Groq",
+    envVar: "GROQ_API_KEY",
+    keyPrefix: "gsk_",
+    keyHint: "gsk_...",
+    consoleUrl: "https://console.groq.com/keys",
+    defaultModel: "llama-3.3-70b-versatile",
+    utilityModel: "llama-3.1-8b-instant",
+    toolLimit: 128,
+    piAiProvider: "groq"
+  },
+  openrouter: {
+    id: "openrouter",
+    displayName: "OpenRouter",
+    envVar: "OPENROUTER_API_KEY",
+    keyPrefix: "sk-or-",
+    keyHint: "sk-or-v1-...",
+    consoleUrl: "https://openrouter.ai/keys",
+    defaultModel: "anthropic/claude-opus-4.5",
+    utilityModel: "google/gemini-2.5-flash-lite",
+    toolLimit: 128,
+    piAiProvider: "openrouter"
+  },
+  moonshot: {
+    id: "moonshot",
+    displayName: "Moonshot (Kimi K2.5)",
+    envVar: "MOONSHOT_API_KEY",
+    keyPrefix: "sk-",
+    keyHint: "sk-...",
+    consoleUrl: "https://platform.moonshot.ai/",
+    defaultModel: "kimi-k2.5",
+    utilityModel: "kimi-k2.5",
+    toolLimit: 128,
+    piAiProvider: "moonshot"
+  },
+  mistral: {
+    id: "mistral",
+    displayName: "Mistral AI",
+    envVar: "MISTRAL_API_KEY",
+    keyPrefix: null,
+    keyHint: "...",
+    consoleUrl: "https://console.mistral.ai/api-keys",
+    defaultModel: "devstral-small-2507",
+    utilityModel: "ministral-8b-latest",
+    toolLimit: 128,
+    piAiProvider: "mistral"
+  },
+  cocoon: {
+    id: "cocoon",
+    displayName: "Cocoon Network (Decentralized)",
+    envVar: "",
+    keyPrefix: null,
+    keyHint: "No API key needed \u2014 pays in TON",
+    consoleUrl: "https://cocoon.network",
+    defaultModel: "Qwen/Qwen3-32B",
+    utilityModel: "Qwen/Qwen3-32B",
+    toolLimit: 128,
+    piAiProvider: "cocoon"
+  },
+  local: {
+    id: "local",
+    displayName: "Local (Ollama, vLLM, LM Studio...)",
+    envVar: "",
+    keyPrefix: null,
+    keyHint: "No API key needed",
+    consoleUrl: "",
+    defaultModel: "auto",
+    utilityModel: "auto",
+    toolLimit: 128,
+    piAiProvider: "local"
+  }
+};
+function getProviderMetadata(provider) {
+  const meta = PROVIDER_REGISTRY[provider];
+  if (!meta) {
+    throw new Error(`Unknown provider: ${provider}`);
+  }
+  return meta;
+}
+function getSupportedProviders() {
+  return Object.values(PROVIDER_REGISTRY);
+}
+function validateApiKeyFormat(provider, key) {
+  const meta = PROVIDER_REGISTRY[provider];
+  if (!meta) return `Unknown provider: ${provider}`;
+  if (provider === "cocoon" || provider === "local") return void 0;
+  if (!key || key.trim().length === 0) return "API key is required";
+  if (meta.keyPrefix && !key.startsWith(meta.keyPrefix)) {
+    return `Invalid format (should start with ${meta.keyPrefix})`;
+  }
+  return void 0;
+}
+
+export {
+  getProviderMetadata,
+  getSupportedProviders,
+  validateApiKeyFormat
+};

package/dist/chunk-ND2X5FWB.js

@@ -0,0 +1,368 @@
+import {
+  getProviderMetadata
+} from "./chunk-LRCPA7SC.js";
+import {
+  appendToTranscript,
+  readTranscript
+} from "./chunk-OCLG5GKI.js";
+import {
+  fetchWithTimeout
+} from "./chunk-VAUJSSD3.js";
+import {
+  createLogger
+} from "./chunk-RCMD3U65.js";
+
+// src/agent/client.ts
+import {
+  complete,
+  getModel
+} from "@mariozechner/pi-ai";
+
+// src/agent/schema-sanitizer.ts
+var UNSUPPORTED_KEYS = /* @__PURE__ */ new Set([
+  "$schema",
+  "$id",
+  "$ref",
+  "$defs",
+  "$anchor",
+  "title",
+  "default",
+  "examples"
+]);
+function sanitizeSchema(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const result = { ...schema };
+  for (const key of UNSUPPORTED_KEYS) {
+    delete result[key];
+  }
+  if (Array.isArray(result.anyOf)) {
+    const items = result.anyOf;
+    const nonNull = items.filter((s) => s.type !== "null");
+    const allConst = nonNull.length > 0 && nonNull.every((s) => s.const !== void 0);
+    if (allConst) {
+      const enumValues = nonNull.map((s) => s.const);
+      const inferredType = nonNull[0]?.type || "string";
+      delete result.anyOf;
+      result.type = inferredType;
+      result.enum = enumValues;
+    } else if (nonNull.length > 0) {
+      delete result.anyOf;
+      const first = nonNull[0];
+      if (first.type) result.type = first.type;
+      if (first.enum) result.enum = first.enum;
+      if (first.description && !result.description) {
+        result.description = first.description;
+      }
+    }
+  }
+  if (Array.isArray(result.anyOf)) {
+    delete result.anyOf;
+    if (!result.type) result.type = "string";
+  }
+  if (result.const !== void 0) {
+    result.enum = [result.const];
+    if (!result.type) {
+      const jsType = typeof result.const;
+      result.type = jsType === "string" ? "string" : jsType === "boolean" ? "boolean" : "number";
+    }
+    delete result.const;
+  }
+  if (result.properties && typeof result.properties === "object") {
+    const props = result.properties;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(props)) {
+      sanitized[key] = value && typeof value === "object" && !Array.isArray(value) ? sanitizeSchema(value) : value;
+    }
+    result.properties = sanitized;
+  }
+  if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) {
+    result.items = sanitizeSchema(result.items);
+  }
+  return result;
+}
+function sanitizeToolsForGemini(tools) {
+  return tools.map(
+    (tool) => ({
+      ...tool,
+      parameters: sanitizeSchema({ ...tool.parameters })
+    })
+  );
+}
+
+// src/agent/client.ts
+var log = createLogger("LLM");
+function isOAuthToken(apiKey, provider) {
+  if (provider && provider !== "anthropic") return false;
+  return apiKey.startsWith("sk-ant-oat01-");
+}
+function getEffectiveApiKey(provider, rawKey) {
+  if (provider === "local") return "local";
+  if (provider === "cocoon") return "";
+  return rawKey;
+}
+var modelCache = /* @__PURE__ */ new Map();
+var COCOON_MODELS = {};
+async function registerCocoonModels(httpPort) {
+  try {
+    const res = await fetch(`http://localhost:${httpPort}/v1/models`);
+    if (!res.ok) return [];
+    const body = await res.json();
+    const models = body.data || body.models || [];
+    if (!Array.isArray(models)) return [];
+    const ids = [];
+    for (const m of models) {
+      const id = m.id || m.name || String(m);
+      COCOON_MODELS[id] = {
+        id,
+        name: id,
+        api: "openai-completions",
+        provider: "cocoon",
+        baseUrl: `http://localhost:${httpPort}/v1`,
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128e3,
+        maxTokens: 4096,
+        compat: {
+          supportsStore: false,
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false
+        }
+      };
+      ids.push(id);
+    }
+    return ids;
+  } catch {
+    return [];
+  }
+}
+var LOCAL_MODELS = {};
+async function registerLocalModels(baseUrl) {
+  try {
+    const parsed = new URL(baseUrl);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      log.warn(`Local LLM base_url must use http or https (got ${parsed.protocol})`);
+      return [];
+    }
+    const url = baseUrl.replace(/\/+$/, "");
+    const res = await fetchWithTimeout(`${url}/models`, { timeoutMs: 1e4 });
+    if (!res.ok) return [];
+    const body = await res.json();
+    const rawModels = body.data || body.models || [];
+    if (!Array.isArray(rawModels)) return [];
+    const models = rawModels.slice(0, 500);
+    const ids = [];
+    for (const m of models) {
+      const id = m.id || m.name || String(m);
+      LOCAL_MODELS[id] = {
+        id,
+        name: id,
+        api: "openai-completions",
+        provider: "local",
+        baseUrl: url,
+        reasoning: false,
+        input: ["text"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: 128e3,
+        maxTokens: 4096,
+        compat: {
+          supportsStore: false,
+          supportsDeveloperRole: false,
+          supportsReasoningEffort: false,
+          supportsStrictMode: false,
+          maxTokensField: "max_tokens"
+        }
+      };
+      ids.push(id);
+    }
+    return ids;
+  } catch {
+    return [];
+  }
+}
+var MOONSHOT_MODELS = {
+  "kimi-k2.5": {
+    id: "kimi-k2.5",
+    name: "Kimi K2.5",
+    api: "openai-completions",
+    provider: "moonshot",
+    baseUrl: "https://api.moonshot.ai/v1",
+    reasoning: false,
+    input: ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 256e3,
+    maxTokens: 8192
+  },
+  "kimi-k2-thinking": {
+    id: "kimi-k2-thinking",
+    name: "Kimi K2 Thinking",
+    api: "openai-completions",
+    provider: "moonshot",
+    baseUrl: "https://api.moonshot.ai/v1",
+    reasoning: true,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 256e3,
+    maxTokens: 8192
+  }
+};
+function getProviderModel(provider, modelId) {
+  const cacheKey = `${provider}:${modelId}`;
+  const cached = modelCache.get(cacheKey);
+  if (cached) return cached;
+  const meta = getProviderMetadata(provider);
+  if (meta.piAiProvider === "cocoon") {
+    let model = COCOON_MODELS[modelId];
+    if (!model) {
+      model = Object.values(COCOON_MODELS)[0];
+      if (model) log.warn(`Cocoon model "${modelId}" not found, using "${model.id}"`);
+    }
+    if (model) {
+      modelCache.set(cacheKey, model);
+      return model;
+    }
+    throw new Error("No Cocoon models available. Is the cocoon client running?");
+  }
+  if (meta.piAiProvider === "local") {
+    let model = LOCAL_MODELS[modelId];
+    if (!model) {
+      model = Object.values(LOCAL_MODELS)[0];
+      if (model) log.warn(`Local model "${modelId}" not found, using "${model.id}"`);
+    }
+    if (model) {
+      modelCache.set(cacheKey, model);
+      return model;
+    }
+    throw new Error("No local models available. Is the LLM server running?");
+  }
+  if (meta.piAiProvider === "moonshot") {
+    const model = MOONSHOT_MODELS[modelId] ?? MOONSHOT_MODELS[meta.defaultModel];
+    if (model) {
+      modelCache.set(cacheKey, model);
+      return model;
+    }
+  }
+  try {
+    const model = getModel(meta.piAiProvider, modelId);
+    if (!model) {
+      throw new Error(`getModel returned undefined for ${provider}/${modelId}`);
+    }
+    modelCache.set(cacheKey, model);
+    return model;
+  } catch (e) {
+    log.warn(`Model ${modelId} not found for ${provider}, falling back to ${meta.defaultModel}`);
+    const fallbackKey = `${provider}:${meta.defaultModel}`;
+    const fallbackCached = modelCache.get(fallbackKey);
+    if (fallbackCached) return fallbackCached;
+    try {
+      const model = getModel(meta.piAiProvider, meta.defaultModel);
+      if (!model) {
+        throw new Error(
+          `Fallback model ${meta.defaultModel} also returned undefined for ${provider}`
+        );
+      }
+      modelCache.set(fallbackKey, model);
+      return model;
+    } catch {
+      throw new Error(
+        `Could not find model ${modelId} or fallback ${meta.defaultModel} for ${provider}`
+      );
+    }
+  }
+}
+function getUtilityModel(provider, overrideModel) {
+  const meta = getProviderMetadata(provider);
+  const modelId = overrideModel || meta.utilityModel;
+  return getProviderModel(provider, modelId);
+}
+async function chatWithContext(config, options) {
+  const provider = config.provider || "anthropic";
+  const model = getProviderModel(provider, config.model);
+  const isCocoon = provider === "cocoon";
+  let tools = provider === "google" && options.tools ? sanitizeToolsForGemini(options.tools) : options.tools;
+  let systemPrompt = options.systemPrompt || options.context.systemPrompt || "";
+  let cocoonAllowedTools;
+  if (isCocoon) {
+    systemPrompt = "/no_think\n" + systemPrompt;
+    if (tools && tools.length > 0) {
+      cocoonAllowedTools = new Set(tools.map((t) => t.name));
+      const { injectToolsIntoSystemPrompt } = await import("./tool-adapter-Y3TCEQOC.js");
+      systemPrompt = injectToolsIntoSystemPrompt(systemPrompt, tools);
+      tools = void 0;
+    }
+  }
+  const context = {
+    ...options.context,
+    systemPrompt,
+    tools
+  };
+  const temperature = provider === "moonshot" ? 1 : options.temperature ?? config.temperature;
+  const completeOptions = {
+    apiKey: getEffectiveApiKey(provider, config.api_key),
+    maxTokens: options.maxTokens ?? config.max_tokens,
+    temperature,
+    sessionId: options.sessionId
+  };
+  if (isCocoon) {
+    const { stripCocoonPayload } = await import("./tool-adapter-Y3TCEQOC.js");
+    completeOptions.onPayload = stripCocoonPayload;
+  }
+  const response = await complete(model, context, completeOptions);
+  if (isCocoon) {
+    const textBlock = response.content.find((b) => b.type === "text");
+    if (textBlock?.type === "text" && textBlock.text.includes("<tool_call>")) {
+      const { parseToolCallsFromText, extractPlainText } = await import("./tool-adapter-Y3TCEQOC.js");
+      const syntheticCalls = parseToolCallsFromText(textBlock.text, cocoonAllowedTools);
+      if (syntheticCalls.length > 0) {
+        const plainText = extractPlainText(textBlock.text);
+        response.content = [
+          ...plainText ? [{ type: "text", text: plainText }] : [],
+          ...syntheticCalls
+        ];
+        response.stopReason = "toolUse";
+      }
+    }
+  }
+  const thinkRe = /<think>[\s\S]*?<\/think>/g;
+  for (const block of response.content) {
+    if (block.type === "text" && block.text.includes("<think>")) {
+      block.text = block.text.replace(thinkRe, "").trim();
+    }
+  }
+  if (options.persistTranscript && options.sessionId) {
+    appendToTranscript(options.sessionId, response);
+  }
+  const textContent = response.content.find((block) => block.type === "text");
+  const text = textContent?.type === "text" ? textContent.text : "";
+  const updatedContext = {
+    ...context,
+    messages: [...context.messages, response]
+  };
+  return {
+    message: response,
+    text,
+    context: updatedContext
+  };
+}
+function loadContextFromTranscript(sessionId, systemPrompt) {
+  const messages = readTranscript(sessionId);
+  return {
+    systemPrompt,
+    messages
+  };
+}
+function createClient(_config) {
+  return null;
+}
+
+export {
+  isOAuthToken,
+  getEffectiveApiKey,
+  registerCocoonModels,
+  registerLocalModels,
+  getProviderModel,
+  getUtilityModel,
+  chatWithContext,
+  loadContextFromTranscript,
+  createClient
+};