@yukino.js/yukino 0.0.1

package/dist/lib/chunk-5TGXH7BX.js

@@ -0,0 +1,624 @@
+import {
+  normalizeToolResultContentBlock
+} from "./chunk-F2YJG72O.js";
+import {
+  AuthenticationError,
+  ContextTooLongError,
+  LLMError,
+  MIN_THINKING_ANSWER_TOKENS,
+  NetworkError,
+  RateLimitError,
+  clampThinkingLevel,
+  ensureToolPairing,
+  getMaxOutputTokens,
+  getSupportedThinkingLevels,
+  getThinkingLevel,
+  resolveAPIKey,
+  thinkingBudgetForLevel,
+  toAnthropicThinkingEffort,
+  toReasoningEffort
+} from "./chunk-QYBQT2DM.js";
+import {
+  MCP_TOOL_PREFIX,
+  isMcpToolLike
+} from "./chunk-I34MAQRE.js";
+import {
+  asErrorString,
+  asRecord,
+  asString,
+  contentToText,
+  createChildLogger,
+  isRecord,
+  strArg
+} from "./chunk-6OMQD7MK.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/llm/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  AnthropicClient: () => AnthropicClient,
+  buildAnthropicMessages: () => buildAnthropicMessages,
+  fetchModelContextWindow: () => fetchModelContextWindow,
+  markLastUserTailForCache: () => markLastUserTailForCache,
+  markToolsForCache: () => markToolsForCache,
+  needsToolSearchBeta: () => needsToolSearchBeta
+});
+import Anthropic from "@anthropic-ai/sdk";
+import { safeParseAsync, z } from "zod";
+
+// src/mcp/strategy.ts
+var strategy_exports = {};
+__export(strategy_exports, {
+  CHARS_PER_TOKEN: () => CHARS_PER_TOKEN,
+  DEFAULT_EAGER_THRESHOLD_PERCENT: () => DEFAULT_EAGER_THRESHOLD_PERCENT,
+  NATIVE_TOOL_USE_BETA: () => NATIVE_TOOL_USE_BETA,
+  applyMode: () => applyMode,
+  decideAndApply: () => decideAndApply,
+  decideMode: () => decideMode,
+  estimateSchemaTokens: () => estimateSchemaTokens,
+  isOfficialAnthropicEndpoint: () => isOfficialAnthropicEndpoint,
+  measureSchemaChars: () => measureSchemaChars
+});
+var DEFAULT_EAGER_THRESHOLD_PERCENT = 10;
+var CHARS_PER_TOKEN = 2.5;
+var NATIVE_TOOL_USE_BETA = "advanced-tool-use-2025-11-20";
+var OFFICIAL_HOSTS = /* @__PURE__ */ new Set(["api.anthropic.com"]);
+var ENV_OVERRIDE = "YUKINO_MCP_LOADING";
+function isOfficialAnthropicEndpoint(baseUrl) {
+  if (!baseUrl) {
+    return true;
+  }
+  try {
+    return OFFICIAL_HOSTS.has(new URL(baseUrl).hostname.toLowerCase());
+  } catch {
+    return false;
+  }
+}
+function estimateSchemaTokens(schemaChars) {
+  return Math.floor(schemaChars / CHARS_PER_TOKEN);
+}
+function decideMode(baseUrl, contextWindow, mcpSchemaChars, thresholdPercent = DEFAULT_EAGER_THRESHOLD_PERCENT) {
+  const override = (process.env[ENV_OVERRIDE] ?? "").trim().toLowerCase();
+  if (override === "eager" || override === "native" || override === "dispatch") {
+    return override;
+  }
+  if (mcpSchemaChars <= 0) {
+    return "eager";
+  }
+  const budget = contextWindow * thresholdPercent / 100;
+  if (estimateSchemaTokens(mcpSchemaChars) < budget) {
+    return "eager";
+  }
+  return isOfficialAnthropicEndpoint(baseUrl) ? "native" : "dispatch";
+}
+function measureSchemaChars(registry) {
+  let total = 0;
+  for (const tool of registry.listTools()) {
+    if (!tool.name.startsWith(MCP_TOOL_PREFIX)) {
+      continue;
+    }
+    try {
+      total += JSON.stringify(tool.schema()).length;
+    } catch {
+      total += tool.name.length + (tool.description?.length ?? 0);
+    }
+  }
+  return total;
+}
+function applyMode(registry, mode) {
+  registry.mcpLoadingMode = mode;
+  const eager = mode === "eager";
+  for (const tool of registry.listTools()) {
+    if (isMcpToolLike(tool) && typeof tool.setDeferLoading === "function") {
+      tool.setDeferLoading(!eager);
+    }
+  }
+  registry.exposeToolSearch = !eager;
+  registry.exposeMcpCall = mode === "dispatch";
+}
+function decideAndApply(registry, baseUrl, contextWindow) {
+  const mode = decideMode(baseUrl, contextWindow, measureSchemaChars(registry));
+  applyMode(registry, mode);
+  return mode;
+}
+
+// src/llm/anthropic.ts
+function markToolsForCache(tools) {
+  for (let i = tools.length - 1; i >= 0; i--) {
+    const t = tools[i];
+    if (t.defer_loading === true) {
+      continue;
+    }
+    t.cache_control = { type: "ephemeral" };
+    return;
+  }
+}
+function needsToolSearchBeta(toolSchemas) {
+  return toolSchemas.some(
+    (schema) => "defer_loading" in schema && schema.defer_loading === true
+  );
+}
+function toAnthropicToolSchema(schema, useExplicitCustomType) {
+  if ("input_schema" in schema) {
+    const tool = schema;
+    const { cache_control: cacheControl, ...rest } = tool;
+    if (!useExplicitCustomType) {
+      delete rest.type;
+    }
+    return {
+      ...rest,
+      ...useExplicitCustomType ? { type: "custom" } : {},
+      ...tool.defer_loading !== true && cacheControl ? { cache_control: cacheControl } : {}
+    };
+  }
+  throw new Error(
+    "Anthropic received a tool schema serialized for another protocol."
+  );
+}
+var log = createChildLogger({ module: "llm" });
+var MODEL_FETCH_TIMEOUT_MS = 3e3;
+var ModelContextWindowResSchema = z.object({
+  max_input_tokens: z.coerce.number()
+});
+async function fetchModelContextWindow(config) {
+  if (config.protocol !== "anthropic") {
+    return 0;
+  }
+  const apiKey = resolveAPIKey(config);
+  const base = config.base_url.replace(/\/+$/, "");
+  const url = `${base}/v1/models/${encodeURIComponent(config.model)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, MODEL_FETCH_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      headers: {
+        "anthropic-version": "2023-06-01",
+        ...apiKey ? { "x-api-key": apiKey } : {}
+      },
+      signal: controller.signal
+    });
+    if (!res.ok) {
+      return 0;
+    }
+    const body = await res.json();
+    const { success, error, data } = await safeParseAsync(
+      ModelContextWindowResSchema,
+      body
+    );
+    if (!success) {
+      log.warn(
+        { message: error.message },
+        "model context window schema validation failed"
+      );
+      return 0;
+    }
+    const maxInputTokens = data.max_input_tokens;
+    return Math.max(maxInputTokens, 0);
+  } catch (err) {
+    log.error({ err }, "failed to fetch model context window");
+    return 0;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function userBlocksFor(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+  return content.map((raw) => {
+    const block = normalizeToolResultContentBlock(raw);
+    if (!block || block.type === "tool_reference") {
+      throw new Error(
+        `Unsupported user content block: ${strArg(raw, "type", "unknown")}`
+      );
+    }
+    return block;
+  });
+}
+function buildAnthropicMessages(messages) {
+  const result = [];
+  for (const m of messages) {
+    if (m.role === "assistant") {
+      const blocks = [];
+      if (m.thinkingBlocks) {
+        for (const tb of m.thinkingBlocks) {
+          blocks.push({
+            type: "thinking",
+            thinking: tb.thinking,
+            signature: tb.signature
+          });
+        }
+      }
+      const assistantText = typeof m.content === "string" ? m.content : contentToText(m.content);
+      if (assistantText) {
+        blocks.push({
+          type: "text",
+          text: assistantText
+        });
+      }
+      if (m.toolUses) {
+        for (const tu of m.toolUses) {
+          blocks.push({
+            type: "tool_use",
+            // tool use **request**
+            id: tu.toolUseId,
+            name: tu.toolName === "ComputerUse" ? "computer" : tu.toolName,
+            input: tu.arguments
+          });
+        }
+      }
+      if (blocks.length === 0) {
+        blocks.push({ type: "text", text: "" });
+      }
+      result.push({ role: "assistant", content: blocks });
+    } else if (m.toolResults && m.toolResults.length > 0) {
+      const blocks = [];
+      for (const tr of m.toolResults) {
+        blocks.push({
+          type: "tool_result",
+          // tool result
+          tool_use_id: tr.toolUseId,
+          is_error: tr.isError,
+          content: tr.contentBlocks?.length ? tr.contentBlocks : tr.content
+        });
+      }
+      if (m.content.length > 0) {
+        blocks.push(...userBlocksFor(m.content));
+      }
+      result.push({ role: "user", content: blocks });
+    } else {
+      if (result.length === 0) {
+        result.push({
+          role: "user",
+          content: userBlocksFor(m.content)
+        });
+        continue;
+      }
+      let canMerge = false;
+      const prev = result[result.length - 1];
+      let content = prev.content;
+      if (prev.role === "user" && (typeof content === "string" || Array.isArray(content) && content.length > 0 && // content[0].type !== "tool_result"
+      (content[0].type === "text" || content[0].type === "image"))) {
+        canMerge = true;
+      }
+      if (canMerge) {
+        if (typeof content === "string") {
+          content = prev.content = content.trim().length > 0 ? [
+            {
+              type: "text",
+              text: content
+            }
+          ] : [];
+        }
+        content.push(...userBlocksFor(m.content));
+      } else {
+        result.push({
+          role: "user",
+          content: userBlocksFor(m.content)
+        });
+      }
+    }
+  }
+  return result;
+}
+var AnthropicClient = class {
+  protocol = "anthropic";
+  client;
+  model;
+  /** Effective logical level for budget or explicitly configured adaptive mode. */
+  thinkingLevel;
+  systemPrompt;
+  maxOutputTokens;
+  config;
+  useExplicitCustomToolType;
+  constructor(config, systemPrompt) {
+    const apiKey = resolveAPIKey(config);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "Anthropic API key not found, set ANTHROPIC_API_KEY in ~/.yukino/config.yaml, or via ANTHROPIC_API_KEY env variable."
+      );
+    }
+    this.client = new Anthropic({
+      apiKey,
+      baseURL: config.base_url
+    });
+    this.useExplicitCustomToolType = isOfficialAnthropicEndpoint(
+      config.base_url
+    );
+    this.model = config.model;
+    this.config = { ...config };
+    this.thinkingLevel = getThinkingLevel(config);
+    this.systemPrompt = systemPrompt;
+    this.maxOutputTokens = getMaxOutputTokens(config);
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  setMaxOutputTokens(maxTokens) {
+    this.config = { ...this.config, max_output_tokens: maxTokens };
+    this.maxOutputTokens = getMaxOutputTokens(this.config);
+    this.setThinkingLevel(this.thinkingLevel);
+  }
+  setThinkingLevel(level) {
+    this.thinkingLevel = clampThinkingLevel(this.config, level);
+    return this.thinkingLevel;
+  }
+  getThinkingLevel() {
+    return this.thinkingLevel;
+  }
+  getSupportedThinkingLevels() {
+    return getSupportedThinkingLevels(this.config);
+  }
+  async *stream(conversation, toolSchemas, abortSignal) {
+    const messages = buildAnthropicMessages(
+      ensureToolPairing(conversation.getMessages())
+    );
+    const sendToolSearchBeta = needsToolSearchBeta(toolSchemas);
+    const antToolSchemas = toolSchemas.map(
+      (schema) => toAnthropicToolSchema(schema, this.useExplicitCustomToolType)
+    );
+    markToolsForCache(antToolSchemas);
+    markLastUserTailForCache(messages);
+    const params = {
+      model: this.model,
+      max_tokens: this.maxOutputTokens,
+      stream: true,
+      system: [
+        {
+          type: "text",
+          text: this.systemPrompt,
+          cache_control: {
+            type: "ephemeral"
+            // Prompt cache
+          }
+        }
+      ],
+      messages,
+      ...antToolSchemas.length > 0 ? (
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        { tools: antToolSchemas }
+      ) : {}
+    };
+    const level = this.getThinkingLevel();
+    if (this.config.reasoning !== false) {
+      if (level === "off") {
+        params.thinking = { type: "disabled" };
+      } else if (this.config.thinking_mode === "adaptive") {
+        const effort = toAnthropicThinkingEffort(level, this.config);
+        if (effort !== null) {
+          params.thinking = { type: "adaptive" };
+          params.output_config = { effort };
+        }
+      } else {
+        const effort = toReasoningEffort(level, this.config);
+        if (effort !== null && effort !== "none") {
+          params.thinking = {
+            type: "enabled",
+            budget_tokens: Math.min(
+              thinkingBudgetForLevel(effort),
+              this.maxOutputTokens - MIN_THINKING_ANSWER_TOKENS
+            )
+          };
+        }
+      }
+    }
+    let inputTokens = 0;
+    let outputTokens = 0;
+    let cacheReadInputTokens = 0;
+    let cacheCreationInputTokens = 0;
+    let stopReason = "end_turn";
+    let thinkingAccumulate = "";
+    let thinkingSignature = "";
+    let inThinking = false;
+    try {
+      const betas = [...sendToolSearchBeta ? [NATIVE_TOOL_USE_BETA] : []];
+      const response = this.client.messages.stream(params, {
+        ...abortSignal ? { signal: abortSignal } : {},
+        ...betas.length > 0 ? { headers: { "anthropic-beta": betas.join(",") } } : {}
+      });
+      let currentToolName = "";
+      let currentToolId = "";
+      let jsonAccumulate = "";
+      for await (const event of response) {
+        switch (event.type) {
+          case "content_block_start": {
+            const block = event.content_block;
+            if (block.type === "thinking") {
+              inThinking = true;
+              thinkingAccumulate = "";
+              thinkingSignature = "";
+            } else if (block.type === "tool_use") {
+              currentToolId = block.id;
+              currentToolName = block.name === "computer" ? "ComputerUse" : block.name;
+              jsonAccumulate = "";
+              yield {
+                type: "tool_call_start",
+                toolName: currentToolName,
+                toolId: currentToolId
+              };
+            }
+            break;
+          }
+          // end case "content_block_start"
+          case "content_block_delta": {
+            const delta = event.delta;
+            if (delta.type === "thinking_delta") {
+              thinkingAccumulate += delta.thinking;
+              yield {
+                type: "thinking_delta",
+                text: delta.thinking
+              };
+            } else if (delta.type === "signature_delta") {
+              thinkingSignature += delta.signature;
+            } else if (delta.type === "text_delta") {
+              yield {
+                type: "text_delta",
+                text: delta.text
+              };
+            } else if (delta.type === "input_json_delta") {
+              jsonAccumulate += delta.partial_json;
+              yield {
+                type: "tool_call_delta",
+                text: delta.partial_json
+              };
+            }
+            break;
+          }
+          // end case "content_block_delta"
+          case "content_block_stop": {
+            if (inThinking) {
+              yield {
+                type: "thinking_complete",
+                thinking: thinkingAccumulate,
+                signature: thinkingSignature
+              };
+              inThinking = false;
+            }
+            if (currentToolName) {
+              let args = {};
+              if (jsonAccumulate) {
+                try {
+                  const parsed = JSON.parse(jsonAccumulate);
+                  args = isRecord(parsed) ? asRecord(parsed) : {};
+                } catch (err) {
+                  log.error({ err }, "llm operation failed");
+                  args = {};
+                }
+              }
+              yield {
+                type: "tool_call_complete",
+                toolId: currentToolId,
+                toolName: currentToolName,
+                arguments: args
+              };
+              currentToolName = "";
+              currentToolId = "";
+              jsonAccumulate = "";
+            }
+            break;
+          }
+          // end case "content_block_stop"
+          case "message_delta": {
+            if (event.delta.stop_reason) {
+              stopReason = event.delta.stop_reason;
+            }
+            if (event.usage.output_tokens) {
+              outputTokens = event.usage.output_tokens;
+              if (event.usage.input_tokens) {
+                inputTokens = event.usage.input_tokens;
+              }
+              if (event.usage.cache_read_input_tokens) {
+                cacheReadInputTokens = event.usage.cache_read_input_tokens;
+              }
+              if (event.usage.cache_creation_input_tokens) {
+                cacheCreationInputTokens = event.usage.cache_creation_input_tokens;
+              }
+            }
+            break;
+          }
+          // end case "message_delta"
+          case "message_start": {
+            inputTokens = event.message.usage.input_tokens;
+            outputTokens = event.message.usage.output_tokens;
+            cacheReadInputTokens = event.message.usage.cache_read_input_tokens ?? 0;
+            cacheCreationInputTokens = event.message.usage.cache_creation_input_tokens ?? 0;
+            break;
+          }
+        }
+      }
+      yield {
+        type: "stream_end",
+        stopReason,
+        usage: {
+          inputTokens,
+          outputTokens,
+          cacheReadInputTokens,
+          cacheCreationInputTokens
+        }
+      };
+    } catch (err) {
+      log.error({ err }, "llm operation failed");
+      throw classifyAnthropicError(err);
+    }
+  }
+};
+function markLastUserTailForCache(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role !== "user") {
+      continue;
+    }
+    let content = messages[i].content;
+    if (typeof content === "string" && content.length === 0 || Array.isArray(content) && content.length === 0) {
+      return;
+    }
+    if (typeof content === "string") {
+      content = messages[i].content = [
+        {
+          type: "text",
+          text: content
+        }
+      ];
+    }
+    let last = content[content.length - 1];
+    for (let j = content.length - 1; j >= 0; j--) {
+      if (content[j].type !== "image") {
+        last = content[j];
+        break;
+      }
+    }
+    Reflect.set(last, "cache_control", {
+      type: "ephemeral"
+    });
+    return;
+  }
+}
+function classifyAnthropicError(err) {
+  if (err instanceof Anthropic.APIError) {
+    if (err.status === 413 /* PromptTooLong */ || /prompts?\s+too\s+long/i.test(err.message)) {
+      return new ContextTooLongError(`Prompt too long: ${err.message}`);
+    }
+    if (err.status === 401 /* InvalidAPIKey */) {
+      return new AuthenticationError(`Invalid API key: ${err.message}`);
+    }
+    if (err.status === 429 /* RateLimitError */) {
+      const headers = err.headers;
+      const retryAfter = headers instanceof Headers ? headers.get("retry-after") : void 0;
+      let message = "Rate Limited";
+      if (retryAfter) {
+        const s = Number.parseInt(asString(retryAfter));
+        if (Number.isNaN(s)) {
+          message += ", please wait.";
+        } else {
+          message += `, retry after ${asString(s)}s.`;
+        }
+      } else {
+        message += ", please wait.";
+      }
+      return new RateLimitError(
+        message,
+        retryAfter ? asString(retryAfter) : void 0
+      );
+    }
+    return new LLMError(
+      `Anthropic API error (${asString(err.status)}): ${err.message}`
+    );
+  }
+  return new NetworkError(`Network error: ${asErrorString(err)}`);
+}
+
+export {
+  decideAndApply,
+  strategy_exports,
+  markToolsForCache,
+  needsToolSearchBeta,
+  fetchModelContextWindow,
+  buildAnthropicMessages,
+  AnthropicClient,
+  markLastUserTailForCache,
+  anthropic_exports
+};