@swifty.js/swifty 0.0.29 → 0.0.31

package/dist/lib/{chunk-3FBS5NB7.js → chunk-OEPCNATU.js}

@@ -4,12 +4,14 @@ import {
   LLMError,
   NetworkError,
   RateLimitError,
+  clampThinkingLevel,
   ensureToolPairing,
   getMaxOutputTokens,
+  getSupportedThinkingLevels,
   getThinkingLevel,
   resolveAPIKey,
   toReasoningEffort
-} from "./chunk-Z4CYHTII.js";
+} from "./chunk-OQIQOU5S.js";
 import {
   asRecord,
   asString,
@@ -22,12 +24,90 @@ import {
 // src/llm/openai.ts
 import OpenAI from "openai";
 var log = createChildLogger({ module: "llm" });
+function computerActionArguments(action) {
+  switch (action.type) {
+    case "scroll":
+      return {
+        type: "scroll",
+        x: action.x,
+        y: action.y,
+        scrollX: action.scroll_x,
+        scrollY: action.scroll_y,
+        ...action.keys?.length ? { keys: action.keys } : {}
+      };
+    case "click":
+    case "double_click":
+    case "drag":
+    case "move": {
+      const { keys, ...rest } = action;
+      return {
+        ...rest,
+        ...keys?.length ? { keys } : {}
+      };
+    }
+    default:
+      return { ...action };
+  }
+}
+function computerCallArguments(item) {
+  const actions = item.actions ?? (item.action ? [item.action] : []);
+  return {
+    actions: actions.map(computerActionArguments),
+    pendingSafetyChecks: item.pending_safety_checks.map((check) => ({
+      id: check.id,
+      ...check.code ? { code: check.code } : {},
+      ...check.message ? { message: check.message } : {}
+    })),
+    status: item.status
+  };
+}
+function toOpenAIResponsesTool(schema) {
+  if ("type" in schema && schema.type === "computer") {
+    return { ...schema };
+  }
+  if ("input_schema" in schema) {
+    const tool = schema;
+    return {
+      type: "function",
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.input_schema,
+      strict: tool.strict ?? false
+    };
+  }
+  if ("type" in schema && schema.type === "function" && "parameters" in schema) {
+    return { ...schema };
+  }
+  throw new Error("OpenAI Responses received a tool schema serialized for another protocol.");
+}
+function toOpenAICompatTool(schema) {
+  if ("input_schema" in schema) {
+    const tool = schema;
+    return {
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input_schema,
+        strict: tool.strict ?? false
+      }
+    };
+  }
+  if ("function" in schema) {
+    return { ...schema };
+  }
+  throw new Error(
+    "OpenAI Chat Completions received a tool schema serialized for another protocol."
+  );
+}
 var OpenAIClient = class {
+  protocol = "openai";
   client;
   model;
   systemPrompt;
   maxOutputTokens;
   thinkingLevel;
+  config;
   constructor(config, systemPrompt) {
     const apiKey = resolveAPIKey(config);
     if (!apiKey) {
@@ -42,6 +122,7 @@ var OpenAIClient = class {
     this.model = config.model;
     this.systemPrompt = systemPrompt;
     this.maxOutputTokens = getMaxOutputTokens(config);
+    this.config = { ...config };
     this.thinkingLevel = getThinkingLevel(config);
   }
   async *stream(conversation, toolSchemas, abortSignal) {
@@ -54,25 +135,17 @@ var OpenAIClient = class {
     for (const message of messages) {
       input.push(message);
     }
-    const tools = toolSchemas.map((s) => {
-      const schema = s.input_schema;
-      return {
-        type: "function",
-        name: s.name,
-        description: s.description,
-        parameters: schema,
-        strict: false
-      };
-    });
+    const tools = toolSchemas.map(toOpenAIResponsesTool);
+    const effort = toReasoningEffort(this.getThinkingLevel(), this.config);
     const params = {
       model: this.model,
       input,
       stream: true,
       max_output_tokens: this.maxOutputTokens,
       ...tools.length > 0 ? { tools } : {},
-      // PI-equivalent thinking level → Responses API reasoning effort. Omitted
-      // entirely when thinking is off so non-reasoning models are unaffected.
-      ...this.thinkingLevel !== "off" ? { reasoning: { effort: toReasoningEffort(this.thinkingLevel), summary: "auto" } } : {}
+      // Only explicit reasoning:false omits the field. Off sends none to defeat
+      // server-default reasoning; requesting a summary while off is unnecessary.
+      ...effort !== null ? { reasoning: { effort, ...effort !== "none" ? { summary: "auto" } : {} } } : {}
     };
     let inputTokens = 0;
     let outputTokens = 0;
@@ -119,6 +192,12 @@ var OpenAIClient = class {
               toolName: currentToolName,
               toolId: currentToolId
             };
+          } else if (event.item.type === "computer_call") {
+            yield {
+              type: "tool_call_start",
+              toolName: "ComputerUse",
+              toolId: event.item.call_id
+            };
           } else if (event.item.type === "reasoning") {
             reasoningId = event.item.id ?? "";
             reasoningText = "";
@@ -144,6 +223,14 @@ var OpenAIClient = class {
             currentToolName = "";
             currentToolId = "";
             jsonAccumulate = "";
+          } else if (event.item.type === "computer_call") {
+            yield {
+              type: "tool_call_complete",
+              toolId: event.item.call_id,
+              toolName: "ComputerUse",
+              arguments: computerCallArguments(event.item),
+              providerItemId: event.item.id
+            };
           }
         } else if (event.type === "response.completed" || event.type === "response.incomplete") {
           sawTerminalResponse = true;
@@ -198,11 +285,15 @@ var OpenAIClient = class {
     this.maxOutputTokens = maxTokens;
   }
   setThinkingLevel(level) {
-    this.thinkingLevel = level;
+    this.thinkingLevel = clampThinkingLevel(this.config, level);
+    return this.thinkingLevel;
   }
   getThinkingLevel() {
     return this.thinkingLevel;
   }
+  getSupportedThinkingLevels() {
+    return getSupportedThinkingLevels(this.config);
+  }
 };
 function imageDataUrl(block) {
   if (!isRecord(block) || block.type !== "image" || !isRecord(block.source)) {
@@ -283,6 +374,56 @@ function toolOutputForResponses(tr) {
   }
   return rich.length > 0 ? rich : tr.content;
 }
+function computerActionsForResponses(args) {
+  if (!Array.isArray(args.actions)) {
+    return [];
+  }
+  const actions = [];
+  for (const raw of args.actions) {
+    if (!isRecord(raw) || typeof raw.type !== "string") {
+      continue;
+    }
+    if (raw.type === "scroll") {
+      actions.push({
+        type: "scroll",
+        x: Number(raw.x),
+        y: Number(raw.y),
+        scroll_x: Number(raw.scrollX),
+        scroll_y: Number(raw.scrollY),
+        ...Array.isArray(raw.keys) ? { keys: raw.keys.map(String) } : {}
+      });
+      continue;
+    }
+    actions.push(raw);
+  }
+  return actions;
+}
+function safetyChecksForResponses(args) {
+  if (!Array.isArray(args.pendingSafetyChecks)) {
+    return [];
+  }
+  return args.pendingSafetyChecks.flatMap((raw) => {
+    if (!isRecord(raw) || typeof raw.id !== "string") {
+      return [];
+    }
+    return [
+      {
+        id: raw.id,
+        ...typeof raw.code === "string" ? { code: raw.code } : {},
+        ...typeof raw.message === "string" ? { message: raw.message } : {}
+      }
+    ];
+  });
+}
+function computerScreenshotUrl(tr) {
+  for (const block of tr.contentBlocks ?? []) {
+    const url = imageDataUrl(block);
+    if (url) {
+      return url;
+    }
+  }
+  return void 0;
+}
 function collectRichParts(tr) {
   if (!tr.contentBlocks?.length) {
     return [];
@@ -340,6 +481,14 @@ function userPartsFor(content) {
 }
 function buildOpenAIInput(messages) {
   const result = [];
+  const computerCalls = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    for (const toolUse of message.toolUses ?? []) {
+      if (toolUse.toolName === "ComputerUse") {
+        computerCalls.set(toolUse.toolUseId, toolUse);
+      }
+    }
+  }
   for (const m of messages) {
     if (m.thinkingBlocks) {
       for (const tb of m.thinkingBlocks) {
@@ -359,20 +508,49 @@ function buildOpenAIInput(messages) {
         });
       }
       for (const tu of m.toolUses) {
-        result.push({
-          type: "function_call",
-          name: tu.toolName,
-          call_id: tu.toolUseId,
-          arguments: JSON.stringify(tu.arguments)
-        });
+        if (tu.toolName === "ComputerUse") {
+          const status = tu.arguments.status;
+          result.push({
+            type: "computer_call",
+            id: tu.providerItemId ?? tu.toolUseId,
+            call_id: tu.toolUseId,
+            status: status === "in_progress" || status === "incomplete" ? status : "completed",
+            actions: computerActionsForResponses(tu.arguments),
+            pending_safety_checks: safetyChecksForResponses(tu.arguments)
+          });
+        } else {
+          result.push({
+            type: "function_call",
+            name: tu.toolName,
+            call_id: tu.toolUseId,
+            arguments: JSON.stringify(tu.arguments)
+          });
+        }
       }
     } else if (m.toolResults && m.toolResults.length > 0) {
       for (const tr of m.toolResults) {
-        result.push({
-          type: "function_call_output",
-          call_id: tr.toolUseId,
-          output: toolOutputForResponses(tr)
-        });
+        const computerCall = computerCalls.get(tr.toolUseId);
+        if (computerCall) {
+          const imageUrl = computerScreenshotUrl(tr);
+          result.push({
+            type: "computer_call_output",
+            call_id: tr.toolUseId,
+            output: {
+              type: "computer_screenshot",
+              ...imageUrl ? { image_url: imageUrl } : {}
+            },
+            acknowledged_safety_checks: safetyChecksForResponses(computerCall.arguments)
+          });
+          if (tr.isError || !imageUrl) {
+            result.push({ role: "user", content: tr.content });
+          }
+        } else {
+          result.push({
+            type: "function_call_output",
+            call_id: tr.toolUseId,
+            output: toolOutputForResponses(tr)
+          });
+        }
       }
       if (m.content.length > 0) {
         result.push({ role: "user", content: userContentsFor(m.content) });
@@ -395,11 +573,13 @@ function containsContextLengthError(msg) {
   return /context_length_exceeded/i.test(msg) || /maximum\scontext\slength/i.test(msg) || /prompts?\s+too\s+long/i.test(msg);
 }
 var OpenAICompatClient = class {
+  protocol = "openai-compat";
   client;
   model;
   systemPrompt;
   maxOutputTokens;
   thinkingLevel;
+  config;
   constructor(config, systemPrompt) {
     const apiKey = resolveAPIKey(config);
     if (!apiKey) {
@@ -411,6 +591,7 @@ var OpenAICompatClient = class {
     this.model = config.model;
     this.systemPrompt = systemPrompt;
     this.maxOutputTokens = getMaxOutputTokens(config);
+    this.config = { ...config };
     this.thinkingLevel = getThinkingLevel(config);
   }
   setSystemPrompt(prompt) {
@@ -420,11 +601,15 @@ var OpenAICompatClient = class {
     this.maxOutputTokens = maxTokens;
   }
   setThinkingLevel(level) {
-    this.thinkingLevel = 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 = [
       {
@@ -433,17 +618,8 @@ var OpenAICompatClient = class {
       },
       ...buildChatCompletionMessages(ensureToolPairing(conversation.getMessages()))
     ];
-    const tools = toolSchemas.map((ts) => ({
-      // name: ts.name,
-      // description: ts.description,
-      type: "function",
-      function: {
-        name: ts.name,
-        description: ts.description,
-        parameters: ts.input_schema,
-        strict: false
-      }
-    }));
+    const tools = toolSchemas.map(toOpenAICompatTool);
+    const effort = toReasoningEffort(this.getThinkingLevel(), this.config);
     const params = {
       model: this.model,
       messages,
@@ -451,9 +627,9 @@ var OpenAICompatClient = class {
       stream_options: { include_usage: true },
       max_tokens: this.maxOutputTokens,
       ...tools.length > 0 ? { tools } : {},
-      // PI-equivalent thinking level → Chat Completions reasoning_effort.
-      // Omitted when thinking is off so non-reasoning models are unaffected.
-      ...this.thinkingLevel !== "off" ? { reasoning_effort: toReasoningEffort(this.thinkingLevel) } : {}
+      // Configured non-reasoning providers omit the field; off otherwise sends
+      // none explicitly so a server default cannot silently enable reasoning.
+      ...effort !== null ? { reasoning_effort: effort } : {}
     };
     let inputTokens = 0;
     let outputTokens = 0;

package/dist/lib/{chunk-Z4CYHTII.js → chunk-OQIQOU5S.js}

@@ -40,7 +40,7 @@ var ContextTooLongError = class extends LLMError {
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-import { safeParse } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import { getParseErrorMessage, safeParse } from "@modelcontextprotocol/sdk/server/zod-compat.js";
 import yaml from "js-yaml";
 import { z } from "zod";
 var log = createChildLogger({ module: "config" });
@@ -63,8 +63,18 @@ function globalConfigPath() {
   return join(homedir(), ".swifty", "config.yaml");
 }
 var THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-var ThinkingConfigSchema = z.union([z.boolean(), z.enum(THINKING_LEVELS)]);
-var ProviderConfigSchema = z.object({
+var ReasoningEffortSchema = z.enum(["none", "minimal", "low", "medium", "high", "xhigh", "max"]);
+var AnthropicEffortSchema = z.enum(["low", "medium", "high", "xhigh", "max"]);
+var ThinkingLevelMapSchema = z.strictObject({
+  off: z.literal("none").nullable().optional(),
+  minimal: ReasoningEffortSchema.nullable().optional(),
+  low: ReasoningEffortSchema.nullable().optional(),
+  medium: ReasoningEffortSchema.nullable().optional(),
+  high: ReasoningEffortSchema.nullable().optional(),
+  xhigh: ReasoningEffortSchema.nullable().optional(),
+  max: ReasoningEffortSchema.nullable().optional()
+});
+var ProviderConfigSchema = z.looseObject({
   name: z.string(),
   /**
    * enum: ["anthropic", "openai", "openai-compat"]
@@ -73,7 +83,12 @@ var ProviderConfigSchema = z.object({
   base_url: z.string(),
   model: z.string(),
   api_key: z.string().optional(),
-  thinking: ThinkingConfigSchema.optional(),
+  thinking: z.enum(THINKING_LEVELS).optional(),
+  /** Explicit capability metadata, never inferred from model names. */
+  reasoning: z.boolean().optional(),
+  thinking_level_map: ThinkingLevelMapSchema.optional(),
+  /** Only Anthropic uses this mode; existing configurations use budgets. */
+  thinking_mode: z.enum(["budget", "adaptive"]).optional(),
   context_window: z.coerce.number().optional(),
   /**
    * The model's output ceiling (PI's `model.maxTokens`). Clamped to the
@@ -92,27 +107,69 @@ var THINKING_BUDGETS = {
   xhigh: 32768,
   max: 65536
 };
+var MIN_THINKING_BUDGET_TOKENS = 1024;
+var MIN_THINKING_ANSWER_TOKENS = 1024;
 function isValidThinkingLevel(value) {
-  return THINKING_LEVELS.includes(value);
-}
-function defaultThinkingLevelFor(protocol) {
-  return protocol === "anthropic" ? DEFAULT_THINKING_LEVEL : "off";
+  return THINKING_LEVELS.some((level) => level === value);
 }
 function getThinkingLevel(provider) {
-  const thinking = provider.thinking;
-  if (thinking === void 0) {
-    return defaultThinkingLevelFor(provider.protocol);
-  }
-  if (typeof thinking === "boolean") {
-    return thinking ? defaultThinkingLevelFor(provider.protocol) : "off";
-  }
-  return thinking;
+  return clampThinkingLevel(provider, provider.thinking ?? DEFAULT_THINKING_LEVEL);
 }
 function thinkingBudgetForLevel(level) {
   return level === "off" ? 0 : THINKING_BUDGETS[level];
 }
-function toReasoningEffort(level) {
-  return level === "off" ? "none" : level;
+function toReasoningEffort(level, provider) {
+  if (provider?.reasoning === false) {
+    return null;
+  }
+  if (level === "off") {
+    return "none";
+  }
+  const mapped = provider?.thinking_level_map?.[level];
+  if (mapped !== void 0) {
+    return mapped;
+  }
+  if (provider?.protocol === "anthropic" && provider.thinking_mode === "adaptive") {
+    if (level === "minimal") {
+      return "low";
+    }
+    if (level === "xhigh") {
+      return "high";
+    }
+  }
+  return level;
+}
+function toAnthropicThinkingEffort(level, provider) {
+  const parsed = AnthropicEffortSchema.safeParse(toReasoningEffort(level, provider));
+  return parsed.success ? parsed.data : null;
+}
+function getSupportedThinkingLevels(provider) {
+  if (provider.reasoning === false || provider.protocol === "anthropic" && provider.thinking_mode !== "adaptive" && getMaxOutputTokens(provider) < MIN_THINKING_BUDGET_TOKENS + MIN_THINKING_ANSWER_TOKENS) {
+    return ["off"];
+  }
+  return THINKING_LEVELS.filter((level) => {
+    if (level === "off") {
+      return true;
+    }
+    if (provider.protocol === "anthropic" && provider.thinking_mode === "adaptive") {
+      return toAnthropicThinkingEffort(level, provider) !== null;
+    }
+    const effort = toReasoningEffort(level, provider);
+    return effort !== null && effort !== "none";
+  });
+}
+function clampThinkingLevel(provider, level) {
+  const supported = getSupportedThinkingLevels(provider);
+  let effective = "off";
+  for (const candidate of THINKING_LEVELS) {
+    if (supported.includes(candidate)) {
+      effective = candidate;
+    }
+    if (candidate === level) {
+      break;
+    }
+  }
+  return effective;
 }
 function withProviderDefaults(provider) {
   return {
@@ -218,6 +275,10 @@ function loadSingleFile(path) {
     const parsed2 = safeParse(z.array(ProviderConfigSchema), raw.providers);
     if (parsed2.success) {
       providers = parsed2.data.map(withProviderDefaults);
+    } else {
+      throw new ConfigError(
+        `Invalid provider configuration in ${path}: ${getParseErrorMessage(parsed2.error)}`
+      );
     }
   }
   if ("permission_mode" in raw && typeof raw.permission_mode === "string") {
@@ -294,13 +355,7 @@ function loadConfig(path, options = {}) {
     if (options.allowEmptyProviders) {
       return { providers: [], mcp_servers: [], hooks: [] };
     }
-    const legacy = [
-      join(process.cwd(), ".swifty/config.yaml"),
-      join(process.cwd(), ".swifty/config.local.yaml")
-    ].filter((legacyPath) => existsSync(legacyPath)).join(", ");
-    throw new ConfigError(
-      `No config file found, expected ${candidate}.` + (legacy ? ` Found project config at ${legacy}; move it to ${candidate}.` : "")
-    );
+    throw new ConfigError(`No config file found, expected ${candidate}.`);
   }
   const config = loadSingleFile(candidate);
   if (!options.allowEmptyProviders || config.providers.length > 0) {
@@ -374,11 +429,15 @@ export {
   DEFAULT_CONTEXT_WINDOW,
   DEFAULT_MAX_OUTPUT_TOKENS,
   THINKING_BUDGETS,
+  MIN_THINKING_BUDGET_TOKENS,
+  MIN_THINKING_ANSWER_TOKENS,
   isValidThinkingLevel,
-  defaultThinkingLevelFor,
   getThinkingLevel,
   thinkingBudgetForLevel,
   toReasoningEffort,
+  toAnthropicThinkingEffort,
+  getSupportedThinkingLevels,
+  clampThinkingLevel,
   withProviderDefaults,
   getContextWindow,
   getMaxOutputTokens,

package/dist/lib/{chunk-PIL7M52F.js → chunk-XT67KGWE.js}

@@ -41,9 +41,17 @@ function normalizeDocumentBlock(value) {
   if (value.source.type === "url" && typeof value.source.url === "string") {
     source = { type: "url", url: value.source.url };
   } else if (value.source.type === "base64" && value.source.media_type === "application/pdf" && typeof value.source.data === "string") {
-    source = { type: "base64", media_type: "application/pdf", data: value.source.data };
+    source = {
+      type: "base64",
+      media_type: "application/pdf",
+      data: value.source.data
+    };
   } else if (value.source.type === "text" && value.source.media_type === "text/plain" && typeof value.source.data === "string") {
-    source = { type: "text", media_type: "text/plain", data: value.source.data };
+    source = {
+      type: "text",
+      media_type: "text/plain",
+      data: value.source.data
+    };
   } else if (value.source.type === "content") {
     if (typeof value.source.content === "string") {
       source = { type: "content", content: value.source.content };
@@ -93,7 +101,12 @@ function normalizeToolResultContentBlock(value) {
       }
       content.push(block);
     }
-    return { type: "search_result", source: value.source, title: value.title, content };
+    return {
+      type: "search_result",
+      source: value.source,
+      title: value.title,
+      content
+    };
   }
   return normalizeDocumentBlock(value);
 }