@swifty.js/swifty 0.0.21 → 0.0.22

package/dist/lib/chunk-LUEP4JMF.js

@@ -0,0 +1,549 @@
+import {
+  computeCompactThreshold
+} from "./chunk-C7IHCJZ3.js";
+import {
+  getContextWindow,
+  getMaxOutputTokens,
+  resolveAPIKey
+} from "./chunk-6GOWRPYS.js";
+import {
+  AuthenticationError,
+  ContextTooLongError,
+  LLMError,
+  NetworkError,
+  RateLimitError,
+  ensureToolPairing
+} from "./chunk-UMFNTXKA.js";
+import {
+  MCP_TOOL_PREFIX,
+  isMcpToolLike
+} from "./chunk-GNBXECZN.js";
+import {
+  DANGEROUSLY_JSON,
+  asErrorString,
+  asRecord,
+  asString,
+  contentToText,
+  createChildLogger,
+  isRecord
+} from "./chunk-EJLGB2EJ.js";
+
+// src/llm/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { safeParseAsync, z } from "zod";
+
+// src/mcp/strategy.ts
+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 = "SWIFTY_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((s) => s.defer_loading);
+}
+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 supportsAdaptiveThinking() {
+  return true;
+}
+function userBlocksFor(content) {
+  if (typeof content === "string") {
+    return [{ type: "text", text: content }];
+  }
+  return content;
+}
+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,
+            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,
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          content: tr.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 {
+  client;
+  model;
+  /**
+   * Whether supports/enable thinking, default false
+   */
+  thinking;
+  systemPrompt;
+  maxOutputTokens;
+  /** Currently not used */
+  contextWindow;
+  constructor(config, systemPrompt) {
+    const apiKey = resolveAPIKey(config);
+    if (!apiKey) {
+      throw new AuthenticationError(
+        "Anthropic API key not found, set ANTHROPIC_API_KEY in .swifty/config.y(a)ml, or via ANTHROPIC_API_KEY env variable."
+      );
+    }
+    this.client = new Anthropic({
+      apiKey,
+      baseURL: config.base_url
+    });
+    this.model = config.model;
+    this.thinking = config.thinking ?? true;
+    this.systemPrompt = systemPrompt;
+    this.maxOutputTokens = getMaxOutputTokens(config);
+    this.contextWindow = getContextWindow(config);
+  }
+  setSystemPrompt(prompt) {
+    this.systemPrompt = prompt;
+  }
+  setMaxOutputTokens(maxTokens) {
+    this.maxOutputTokens = maxTokens;
+  }
+  async *stream(conversation, toolSchemas, abortSignal) {
+    const messages = buildAnthropicMessages(ensureToolPairing(conversation.getMessages()));
+    const sendToolSearchBeta = needsToolSearchBeta(toolSchemas);
+    const antToolSchemas = toolSchemas.map((s) => {
+      const inputSchema = s.input_schema;
+      const tool = {
+        name: s.name,
+        description: s.description,
+        input_schema: {
+          type: "object",
+          properties: inputSchema.properties,
+          required: inputSchema.required ?? []
+        }
+      };
+      if (s.defer_loading === true) {
+        tool.defer_loading = true;
+      }
+      return tool;
+    });
+    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 ? { tools: antToolSchemas } : {}
+    };
+    if (this.thinking) {
+      if (supportsAdaptiveThinking()) {
+        params.thinking = {
+          type: "enabled",
+          budget_tokens: computeCompactThreshold(this.contextWindow, this.maxOutputTokens)
+        };
+      }
+    } else {
+      params.thinking = {
+        type: "enabled",
+        budget_tokens: computeCompactThreshold(this.contextWindow, this.maxOutputTokens)
+      };
+    }
+    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 response = this.client.messages.stream(params, {
+        ...abortSignal ? { signal: abortSignal } : {},
+        // If any tool uses defer_loading this beta header is required, otherwise the server does not recognize the field.
+        // Only the official endpoint reaches this code path (see mcp/strategy).
+        ...sendToolSearchBeta ? { headers: { "anthropic-beta": NATIVE_TOOL_USE_BETA } } : {}
+      });
+      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;
+              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) : { [DANGEROUSLY_JSON]: jsonAccumulate };
+                } catch (err) {
+                  log.error({ err }, "llm operation failed");
+                  args = {
+                    [DANGEROUSLY_JSON]: jsonAccumulate
+                  };
+                }
+              }
+              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"
+    });
+  }
+}
+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 retryAfter = asRecord(err.headers)["retry-after"];
+      let message = "Rate Limited";
+      if (retryAfter) {
+        const s = Number.parseInt(asString(retryAfter));
+        if (Number.isNaN(s)) {
+          message += ", please wait.";
+        }
+        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 {
+  DEFAULT_EAGER_THRESHOLD_PERCENT,
+  CHARS_PER_TOKEN,
+  NATIVE_TOOL_USE_BETA,
+  isOfficialAnthropicEndpoint,
+  estimateSchemaTokens,
+  decideMode,
+  measureSchemaChars,
+  applyMode,
+  decideAndApply,
+  markToolsForCache,
+  needsToolSearchBeta,
+  fetchModelContextWindow,
+  buildAnthropicMessages,
+  AnthropicClient,
+  markLastUserTailForCache
+};

package/dist/lib/chunk-ORSYNBMM.js

@@ -0,0 +1,38 @@
+// src/sandbox/bwrap.ts
+import { execSync } from "child_process";
+var BwrapSandbox = class {
+  available() {
+    try {
+      execSync("which bwrap", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  wrap(command, config) {
+    const args = [];
+    args.push("bwrap", "--unshare-user", "--unshare-pid");
+    args.push("--ro-bind", "/", "/");
+    for (const path of config.allowWrite) {
+      args.push("--bind", path, path);
+    }
+    for (const path of config.denyWrite) {
+      args.push("--ro-bind", path, path);
+    }
+    if (!config.networkEnabled) {
+      args.push("--unshare-net");
+    }
+    args.push("--proc", "/proc");
+    args.push("--", "bash", "-c", command);
+    return args.map((arg) => {
+      if (/[ \t\n"'\\$`!]/.test(arg)) {
+        return `'${arg.replace(/'/g, "'\\''")}'`;
+      }
+      return arg;
+    }).join(" ");
+  }
+};
+
+export {
+  BwrapSandbox
+};