@swifty.js/swifty 0.0.30 → 0.0.31

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

@@ -24,7 +24,84 @@ 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;
@@ -58,16 +135,7 @@ 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: s.strict ?? false
-      };
-    });
+    const tools = toolSchemas.map(toOpenAIResponsesTool);
     const effort = toReasoningEffort(this.getThinkingLevel(), this.config);
     const params = {
       model: this.model,
@@ -124,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 = "";
@@ -149,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;
@@ -292,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 [];
@@ -349,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) {
@@ -368,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) });
@@ -404,6 +573,7 @@ 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;
@@ -448,17 +618,7 @@ 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: ts.strict ?? false
-      }
-    }));
+    const tools = toolSchemas.map(toOpenAICompatTool);
     const effort = toReasoningEffort(this.getThinkingLevel(), this.config);
     const params = {
       model: this.model,

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);
 }