supercompat 4.2.2 → 4.2.3

package/dist/openai/index.js

@@ -2678,7 +2678,7 @@ var post5 = function(param) {
                         stream = new ReadableStream({
                             start: function start(controller) {
                                 return _async_to_generator(function() {
-                                    var blockIndexToToolUseId, toolUseIdToIndex, toolUseIdArgumentBuffer, computerToolUseIds, normalizedComputerCalls, nextToolCallIndex, parseJson3, getOrCreateIndexForToolUseId, assignBlockToToolUse, markComputerToolUse, getToolUseIdFromBlock, emitNormalizedToolCall, getOrCreateIndexForBlock, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, toolUseId, _toolUseIdArgumentBuffer_get, buffered, parsed, normalized, toolCallIndex, chunkIndex, _toolUseIdArgumentBuffer_get1, buffered1, toolCallIndex1, chunkIndex1, messageDelta, delta, toolUseId1, _toolUseIdArgumentBuffer_get2, _chunk_delta_partial_json, existing, updated, parsed1, normalized1, toolCallIndex2, chunkIndex2, _toolUseIdArgumentBuffer_get3, _chunk_delta_partial_json1, existing1, index, messageDelta1, delta1, toolName, normalizedToolName, index1, index2, _chunk_content_block_content, _getToolUseIdFromBlock, outputPayload, toolCallId, index3, _getToolUseIdFromBlock1, _chunk_content_block_content1, toolCallId1, _chunk_content_block, _toolUseId, _type, _id, rest, index4, outputPayload1, messageDelta2, messageDelta3, err;
+                                    var blockIndexToToolUseId, toolUseIdToIndex, toolUseIdArgumentBuffer, computerToolUseIds, normalizedComputerCalls, nextToolCallIndex, parseJson4, getOrCreateIndexForToolUseId, assignBlockToToolUse, markComputerToolUse, getToolUseIdFromBlock, emitNormalizedToolCall, getOrCreateIndexForBlock, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, toolUseId, _toolUseIdArgumentBuffer_get, buffered, parsed, normalized, toolCallIndex, chunkIndex, _toolUseIdArgumentBuffer_get1, buffered1, toolCallIndex1, chunkIndex1, messageDelta, delta, toolUseId1, _toolUseIdArgumentBuffer_get2, _chunk_delta_partial_json, existing, updated, parsed1, normalized1, toolCallIndex2, chunkIndex2, _toolUseIdArgumentBuffer_get3, _chunk_delta_partial_json1, existing1, index, messageDelta1, delta1, toolName, normalizedToolName, index1, index2, _chunk_content_block_content, _getToolUseIdFromBlock, outputPayload, toolCallId, index3, _getToolUseIdFromBlock1, _chunk_content_block_content1, toolCallId1, _chunk_content_block, _toolUseId, _type, _id, rest, index4, outputPayload1, messageDelta2, messageDelta3, err;
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
                                             case 0:
@@ -2688,7 +2688,7 @@ var post5 = function(param) {
                                                 computerToolUseIds = /* @__PURE__ */ new Set();
                                                 normalizedComputerCalls = /* @__PURE__ */ new Set();
                                                 nextToolCallIndex = 0;
-                                                parseJson3 = function(value) {
+                                                parseJson4 = function(value) {
                                                     try {
                                                         return JSON.parse(value);
                                                     } catch (unused) {
@@ -2785,7 +2785,7 @@ var post5 = function(param) {
                                                     if (toolUseId && computerToolUseIds.has(toolUseId) && !normalizedComputerCalls.has(toolUseId)) {
                                                         ;
                                                         buffered = (_toolUseIdArgumentBuffer_get = toolUseIdArgumentBuffer.get(toolUseId)) !== null && _toolUseIdArgumentBuffer_get !== void 0 ? _toolUseIdArgumentBuffer_get : "";
-                                                        parsed = buffered ? parseJson3(buffered) : void 0;
+                                                        parsed = buffered ? parseJson4(buffered) : void 0;
                                                         if (parsed !== void 0) {
                                                             normalized = normalizeComputerToolCallPayload(parsed);
                                                             toolCallIndex = getOrCreateIndexForToolUseId(toolUseId);
@@ -2850,7 +2850,7 @@ var post5 = function(param) {
                                                             updated = "".concat(existing).concat((_chunk_delta_partial_json = chunk.delta.partial_json) !== null && _chunk_delta_partial_json !== void 0 ? _chunk_delta_partial_json : "");
                                                             toolUseIdArgumentBuffer.set(toolUseId1, updated);
                                                             if (!normalizedComputerCalls.has(toolUseId1)) {
-                                                                parsed1 = parseJson3(updated);
+                                                                parsed1 = parseJson4(updated);
                                                                 if (parsed1 !== void 0) {
                                                                     normalized1 = normalizeComputerToolCallPayload(parsed1);
                                                                     toolCallIndex2 = getOrCreateIndexForToolUseId(toolUseId1);
@@ -5074,34 +5074,849 @@ var models12 = function(param) {
         })
     };
 };
+// src/adapters/client/ollamaClientAdapter/completions/normalizeComputerCall.ts
+var MODEL_QUIRKS = {
+    "gemma4": {
+        normalizedCoords: true,
+        fuzzyFallback: true
+    },
+    "gemma3": {
+        normalizedCoords: true,
+        fuzzyFallback: true
+    },
+    "glm-4.6v": {
+        normalizedCoords: true,
+        cleanArtifacts: true
+    },
+    "glm4.6v": {
+        normalizedCoords: true,
+        cleanArtifacts: true
+    },
+    "qwen": {
+        fuzzyFallback: true
+    },
+    "kimi-k2.5": {
+        relativeCoords: {
+            referenceWidth: 1920,
+            referenceHeight: 1080
+        }
+    },
+    "kimi2.5": {
+        relativeCoords: {
+            referenceWidth: 1920,
+            referenceHeight: 1080
+        }
+    }
+};
+var getQuirks = function(model) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.entries(MODEL_QUIRKS)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), prefix = _step_value[0], quirks = _step_value[1];
+            if (model.startsWith(prefix)) return quirks;
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {};
+};
+var cleanTextArtifacts = function(text) {
+    return text.replace(/<\|begin_of_box\|>/g, "").replace(/<\|end_of_box\|>/g, "").replace(/<arg_key>[^<]*<\/arg_key>/g, "").replace(/<\/arg_value>/g, "").trim();
+};
+var KNOWN_ACTION_TYPES = [
+    "double_click",
+    "screenshot",
+    "keypress",
+    "scroll",
+    "click",
+    "move",
+    "type",
+    "drag",
+    "wait"
+];
+var splitCoordDigits = function(numStr) {
+    for(var i = 1; i < numStr.length; i++){
+        var x = parseInt(numStr.slice(0, i));
+        var y = parseInt(numStr.slice(i));
+        if (x >= 0 && x <= 1e3 && y >= 0 && y <= 1e3) {
+            return {
+                x: x,
+                y: y
+            };
+        }
+    }
+    return null;
+};
+var cleanGlmAction = function(action) {
+    var typeVal = action.type;
+    if (typeof typeVal !== "string") return action;
+    var argValueMatch = typeVal.match(/<arg_value>\s*(\{[\s\S]*\})\s*$/);
+    if (argValueMatch) {
+        var inner = parseJson2(argValueMatch[1]);
+        if (inner && (typeof inner === "undefined" ? "undefined" : _type_of(inner)) === "object") {
+            return inner;
+        }
+    }
+    var cleanedType = typeVal.replace(/<\/?[^>]+>/g, "").replace(/\n/g, "").trim();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = KNOWN_ACTION_TYPES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var actionType = _step.value;
+            if (cleanedType.startsWith(actionType) && cleanedType !== actionType) {
+                var rest = cleanedType.slice(actionType.length);
+                var nums = rest.match(/\d+/g);
+                if (nums && nums.length >= 2) {
+                    return _object_spread_props(_object_spread({}, action), {
+                        type: actionType,
+                        x: parseInt(nums[0]),
+                        y: parseInt(nums[1])
+                    });
+                }
+                if (nums && nums.length === 1 && nums[0].length >= 2) {
+                    var coords = splitCoordDigits(nums[0]);
+                    if (coords) {
+                        return _object_spread(_object_spread_props(_object_spread({}, action), {
+                            type: actionType
+                        }), coords);
+                    }
+                }
+                return _object_spread_props(_object_spread({}, action), {
+                    type: actionType
+                });
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (cleanedType === typeVal) return action;
+    return _object_spread_props(_object_spread({}, action), {
+        type: cleanedType
+    });
+};
+var cleanGlmFields = function(action) {
+    var result = _object_spread({}, action);
+    if (typeof result.x === "string") {
+        var nums = result.x.match(/\d+/g);
+        if (nums && nums.length >= 2) {
+            result.x = parseInt(nums[0]);
+            if (result.y === void 0 || typeof result.y === "string") {
+                result.y = parseInt(nums[1]);
+            }
+        } else if (nums && nums.length === 1) {
+            result.x = parseInt(nums[0]);
+        }
+    }
+    if (typeof result.y === "string") {
+        var nums1 = result.y.match(/\d+/g);
+        if (nums1 && nums1.length >= 1) {
+            result.y = parseInt(nums1[0]);
+        }
+    }
+    for(var _i = 0, _iter = [
+        "scroll_x",
+        "scroll_y"
+    ]; _i < _iter.length; _i++){
+        var key = _iter[_i];
+        if (typeof result[key] === "string") {
+            var nums2 = result[key].match(/\d+/g);
+            if (nums2) result[key] = parseInt(nums2[0]);
+        }
+    }
+    if (typeof result.type === "string") {
+        result.type = result.type.replace(/<[^>]*>/g, "").replace(/^\{|\}$/g, "").replace(/\n/g, "").trim();
+    }
+    return result;
+};
+var applyArtifactCleanup = function(action) {
+    return cleanGlmFields(cleanGlmAction(action));
+};
+var parseJson2 = function(text) {
+    try {
+        return JSON.parse(text);
+    } catch (unused) {
+        return void 0;
+    }
+};
+var extractJson = function(text) {
+    var direct = parseJson2(text);
+    if (direct) return direct;
+    var codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (codeBlockMatch) {
+        var parsed = parseJson2(codeBlockMatch[1].trim());
+        if (parsed) return parsed;
+    }
+    var jsonMatch = text.match(/(\{[\s\S]*\})\s*$/);
+    if (jsonMatch) {
+        var parsed1 = parseJson2(jsonMatch[1].trim());
+        if (parsed1) return parsed1;
+    }
+    return void 0;
+};
+var fuzzyExtractJson = function(text) {
+    var clickMatch = text.match(/"action"\s*:\s*"click"\s*,\s*"x"\s*:\s*\[?\s*(\d+)\s*,\s*(\d+)/);
+    if (clickMatch) {
+        return {
+            action: {
+                type: "click",
+                x: parseInt(clickMatch[1]),
+                y: parseInt(clickMatch[2])
+            }
+        };
+    }
+    var actionTypeMatch = text.match(/"type"\s*:\s*"(\w+)"/);
+    if (actionTypeMatch) {
+        var result = {
+            type: actionTypeMatch[1]
+        };
+        var xMatch = text.match(/"x"\s*:\s*\[?\s*(\d+)/);
+        var yMatch = text.match(/"y"\s*:\s*(\d+)/);
+        if (xMatch) result.x = parseInt(xMatch[1]);
+        if (yMatch) {
+            result.y = parseInt(yMatch[1]);
+        } else if (xMatch) {
+            var _xMatch_index;
+            var afterX = text.slice(((_xMatch_index = xMatch.index) !== null && _xMatch_index !== void 0 ? _xMatch_index : 0) + xMatch[0].length);
+            var nextNum = afterX.match(/\s*,?\s*(\d+)/);
+            if (nextNum) result.y = parseInt(nextNum[1]);
+        }
+        var textMatch = text.match(/"text"\s*:\s*"([^"]*)"/);
+        if (textMatch) result.text = textMatch[1];
+        return {
+            action: result
+        };
+    }
+    var boxMatch = text.match(/"box_2d"\s*:\s*\[\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\]/);
+    if (boxMatch) {
+        var y1 = parseInt(boxMatch[1]);
+        var x1 = parseInt(boxMatch[2]);
+        var y2 = parseInt(boxMatch[3]);
+        var x2 = parseInt(boxMatch[4]);
+        return {
+            action: {
+                type: "click",
+                x: Math.round((x1 + x2) / 2),
+                y: Math.round((y1 + y2) / 2)
+            }
+        };
+    }
+    return void 0;
+};
+var denormalize = function(value, dimension) {
+    return Math.round(value / 1e3 * dimension);
+};
+var denormalizeAction = function(action, displayWidth, displayHeight) {
+    var result = _object_spread({}, action);
+    if (typeof result.x === "number") {
+        result.x = denormalize(result.x, displayWidth);
+    }
+    if (typeof result.y === "number") {
+        result.y = denormalize(result.y, displayHeight);
+    }
+    if (Array.isArray(result.path)) {
+        result.path = result.path.map(function(point) {
+            if (point && (typeof point === "undefined" ? "undefined" : _type_of(point)) === "object") {
+                return _object_spread({}, point, typeof point.x === "number" ? {
+                    x: denormalize(point.x, displayWidth)
+                } : {}, typeof point.y === "number" ? {
+                    y: denormalize(point.y, displayHeight)
+                } : {});
+            }
+            return point;
+        });
+    }
+    return result;
+};
+var rescaleCoord = function(value, displayDim, referenceDim) {
+    if (value <= 1) return Math.round(value * displayDim);
+    return Math.round(value / referenceDim * displayDim);
+};
+var rescaleRelativeAction = function(action, displayWidth, displayHeight, referenceWidth, referenceHeight) {
+    var result = _object_spread({}, action);
+    if (typeof result.x === "number") {
+        result.x = rescaleCoord(result.x, displayWidth, referenceWidth);
+    }
+    if (typeof result.y === "number") {
+        result.y = rescaleCoord(result.y, displayHeight, referenceHeight);
+    }
+    if (Array.isArray(result.path)) {
+        result.path = result.path.map(function(point) {
+            if (point && (typeof point === "undefined" ? "undefined" : _type_of(point)) === "object") {
+                return _object_spread({}, point, typeof point.x === "number" ? {
+                    x: rescaleCoord(point.x, displayWidth, referenceWidth)
+                } : {}, typeof point.y === "number" ? {
+                    y: rescaleCoord(point.y, displayHeight, referenceHeight)
+                } : {});
+            }
+            return point;
+        });
+    }
+    return result;
+};
+var COORD_FIELDS = [
+    "x",
+    "y",
+    "text",
+    "keys",
+    "button",
+    "direction",
+    "scroll_x",
+    "scroll_y",
+    "path"
+];
+var normalizeStructure = function(parsed, shouldCleanArtifacts) {
+    var clean = shouldCleanArtifacts ? function(action) {
+        return applyArtifactCleanup(action);
+    } : function(action) {
+        return action;
+    };
+    if (parsed.action && _type_of(parsed.action) === "object") {
+        return _object_spread_props(_object_spread({}, parsed), {
+            action: clean(parsed.action)
+        });
+    }
+    if (typeof parsed.action === "string") {
+        var actionObj = {
+            type: parsed.action
+        };
+        var rest = {};
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = Object.entries(parsed)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
+                if (key === "action") continue;
+                if (COORD_FIELDS.includes(key)) {
+                    actionObj[key] = value;
+                } else {
+                    rest[key] = value;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        return _object_spread_props(_object_spread({}, rest), {
+            action: clean(actionObj)
+        });
+    }
+    if (typeof parsed.type === "string") {
+        var actionObj1 = {};
+        var rest1 = {};
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = Object.entries(parsed)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var _step_value1 = _sliced_to_array(_step1.value, 2), key1 = _step_value1[0], value1 = _step_value1[1];
+                if (key1 === "type" || COORD_FIELDS.includes(key1)) {
+                    actionObj1[key1] = value1;
+                } else {
+                    rest1[key1] = value1;
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+        return _object_spread_props(_object_spread({}, rest1), {
+            action: clean(actionObj1)
+        });
+    }
+    return parsed;
+};
+var denormalizeComputerCallArguments = function(param) {
+    var argumentsText = param.argumentsText, displayWidth = param.displayWidth, displayHeight = param.displayHeight, model = param.model;
+    if ((typeof argumentsText === "undefined" ? "undefined" : _type_of(argumentsText)) === "object" && argumentsText !== null) {
+        argumentsText = JSON.stringify(argumentsText);
+    }
+    var quirks = getQuirks(model);
+    var text = argumentsText;
+    if (quirks.cleanArtifacts) {
+        text = cleanTextArtifacts(text);
+    }
+    var parsed = extractJson(text);
+    if (!parsed && (quirks.cleanArtifacts || quirks.fuzzyFallback)) {
+        parsed = fuzzyExtractJson(text);
+    }
+    if (!parsed || (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) !== "object") {
+        return argumentsText;
+    }
+    var normalized = normalizeStructure(parsed, !!quirks.cleanArtifacts);
+    if (quirks.normalizedCoords && normalized.action && _type_of(normalized.action) === "object") {
+        return JSON.stringify(_object_spread_props(_object_spread({}, normalized), {
+            action: denormalizeAction(normalized.action, displayWidth, displayHeight)
+        }));
+    }
+    if (quirks.relativeCoords && normalized.action && _type_of(normalized.action) === "object") {
+        return JSON.stringify(_object_spread_props(_object_spread({}, normalized), {
+            action: rescaleRelativeAction(normalized.action, displayWidth, displayHeight, quirks.relativeCoords.referenceWidth, quirks.relativeCoords.referenceHeight)
+        }));
+    }
+    return JSON.stringify(normalized);
+};
+// src/adapters/client/ollamaClientAdapter/completions/computerUseTool.ts
+var buildComputerCallFunction = function(model, displayWidth, displayHeight) {
+    var quirks = getQuirks(model);
+    var coordDesc = quirks.normalizedCoords ? "Coordinates use 0-1000 normalized scale (0,0=top-left, 1000,1000=bottom-right)." : quirks.relativeCoords ? "Coordinates are relative (0.0-1.0) where 0.0,0.0 is top-left and 1.0,1.0 is bottom-right. Screen is ".concat(displayWidth, "x").concat(displayHeight, ".") : "Coordinates are in pixels (screen is ".concat(displayWidth, "x").concat(displayHeight, ").");
+    var xDesc = quirks.normalizedCoords ? "X coordinate (0-1000 normalized)" : quirks.relativeCoords ? "X coordinate (0.0-1.0 relative, where 0.0=left edge, 1.0=right edge)" : "X coordinate in pixels (0-".concat(displayWidth, ")");
+    var yDesc = quirks.normalizedCoords ? "Y coordinate (0-1000 normalized)" : quirks.relativeCoords ? "Y coordinate (0.0-1.0 relative, where 0.0=top edge, 1.0=bottom edge)" : "Y coordinate in pixels (0-".concat(displayHeight, ")");
+    return {
+        name: "computer_call",
+        description: "Perform a computer action. ".concat(coordDesc),
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "object",
+                    description: "The action to perform",
+                    properties: {
+                        type: {
+                            type: "string",
+                            enum: [
+                                "screenshot",
+                                "click",
+                                "double_click",
+                                "type",
+                                "keypress",
+                                "scroll",
+                                "move",
+                                "drag",
+                                "wait"
+                            ]
+                        },
+                        x: {
+                            type: "number",
+                            description: xDesc
+                        },
+                        y: {
+                            type: "number",
+                            description: yDesc
+                        },
+                        text: {
+                            type: "string",
+                            description: "Text to type"
+                        },
+                        keys: {
+                            type: "array",
+                            items: {
+                                type: "string"
+                            },
+                            description: "Keys to press"
+                        },
+                        button: {
+                            type: "string",
+                            enum: [
+                                "left",
+                                "right",
+                                "wheel"
+                            ]
+                        },
+                        direction: {
+                            type: "string",
+                            enum: [
+                                "up",
+                                "down",
+                                "left",
+                                "right"
+                            ]
+                        },
+                        scroll_x: {
+                            type: "number"
+                        },
+                        scroll_y: {
+                            type: "number"
+                        },
+                        path: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    x: {
+                                        type: "number"
+                                    },
+                                    y: {
+                                        type: "number"
+                                    }
+                                }
+                            },
+                            description: "Path for drag action"
+                        }
+                    },
+                    required: [
+                        "type"
+                    ]
+                },
+                pending_safety_checks: {
+                    type: "array",
+                    items: {
+                        type: "object"
+                    }
+                }
+            },
+            required: [
+                "action"
+            ]
+        }
+    };
+};
+var transformTools = function(tools, model) {
+    if (!tools || tools.length === 0) {
+        return {
+            tools: tools !== null && tools !== void 0 ? tools : [],
+            computerUseConfig: null
+        };
+    }
+    var computerUseConfig = null;
+    var transformed = tools.map(function(tool) {
+        if (tool.type === "computer_use_preview") {
+            var _tool_computer_use_preview, _ref, _config_display_width, _ref1, _config_display_height;
+            var config = (_tool_computer_use_preview = tool.computer_use_preview) !== null && _tool_computer_use_preview !== void 0 ? _tool_computer_use_preview : tool;
+            computerUseConfig = {
+                displayWidth: (_ref = (_config_display_width = config.display_width) !== null && _config_display_width !== void 0 ? _config_display_width : config.display_width_px) !== null && _ref !== void 0 ? _ref : 1280,
+                displayHeight: (_ref1 = (_config_display_height = config.display_height) !== null && _config_display_height !== void 0 ? _config_display_height : config.display_height_px) !== null && _ref1 !== void 0 ? _ref1 : 720
+            };
+            return {
+                type: "function",
+                function: buildComputerCallFunction(model, computerUseConfig.displayWidth, computerUseConfig.displayHeight)
+            };
+        }
+        return tool;
+    });
+    return {
+        tools: transformed,
+        computerUseConfig: computerUseConfig
+    };
+};
 // src/adapters/client/ollamaClientAdapter/completions/post.ts
 var encoder9 = new TextEncoder();
+var ARTIFACT_TAGS = /<\|begin_of_box\|>|<\|end_of_box\|>/g;
+var sanitizeContent = function(content) {
+    if (!content) return content;
+    return content.replace(ARTIFACT_TAGS, "").trim();
+};
+var convertScreenshotToolMessages = function(messages6) {
+    return messages6.flatMap(function(msg) {
+        if (msg.role !== "tool" || typeof msg.content !== "string") return [
+            msg
+        ];
+        try {
+            var parsed = JSON.parse(msg.content);
+            if (parsed.type === "computer_screenshot" && parsed.image_url) {
+                return [
+                    _object_spread_props(_object_spread({}, msg), {
+                        content: ""
+                    }),
+                    {
+                        role: "user",
+                        content: [
+                            {
+                                type: "image_url",
+                                image_url: {
+                                    url: parsed.image_url
+                                }
+                            }
+                        ]
+                    }
+                ];
+            }
+        } catch (unused) {}
+        return [
+            msg
+        ];
+    });
+};
 var post9 = function(param) {
     var ollama = param.ollama;
     return function(_url, options) {
         return _async_to_generator(function() {
-            var body, response, stream, data, error;
+            var body, model, _transformTools, transformedTools, computerUseConfig, resultOptions, response, shouldCleanArtifacts, stream2, stream21, displayWidth, displayHeight, stream, data, _data_choices, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, choice, _ref, message5, toolCalls, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tc, fn, _data_choices1, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, choice1, message51, error;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         body = JSON.parse(options.body);
+                        model = body.model;
+                        _transformTools = transformTools(body.tools, model), transformedTools = _transformTools.tools, computerUseConfig = _transformTools.computerUseConfig;
+                        resultOptions = _object_spread({}, body, computerUseConfig && body.messages ? {
+                            messages: convertScreenshotToolMessages(body.messages)
+                        } : {}, transformedTools.length > 0 ? {
+                            tools: transformedTools
+                        } : {});
                         if (!body.stream) return [
                             3,
                             2
                         ];
                         return [
                             4,
-                            ollama.chat.completions.create(body)
+                            ollama.chat.completions.create(resultOptions)
                         ];
                     case 1:
                         response = _state.sent();
+                        shouldCleanArtifacts = !!getQuirks(model).cleanArtifacts;
+                        if (!computerUseConfig && !shouldCleanArtifacts) {
+                            stream2 = new ReadableStream({
+                                start: function start(controller) {
+                                    return _async_to_generator(function() {
+                                        var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, err;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    _iteratorAbruptCompletion = false, _didIteratorError = false;
+                                                    _state.label = 1;
+                                                case 1:
+                                                    _state.trys.push([
+                                                        1,
+                                                        6,
+                                                        7,
+                                                        12
+                                                    ]);
+                                                    _iterator = _async_iterator(response);
+                                                    _state.label = 2;
+                                                case 2:
+                                                    return [
+                                                        4,
+                                                        _iterator.next()
+                                                    ];
+                                                case 3:
+                                                    if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                                                        3,
+                                                        5
+                                                    ];
+                                                    _value = _step.value;
+                                                    chunk = _value;
+                                                    controller.enqueue(encoder9.encode("data: ".concat(JSON.stringify(chunk), "\n\n")));
+                                                    _state.label = 4;
+                                                case 4:
+                                                    _iteratorAbruptCompletion = false;
+                                                    return [
+                                                        3,
+                                                        2
+                                                    ];
+                                                case 5:
+                                                    return [
+                                                        3,
+                                                        12
+                                                    ];
+                                                case 6:
+                                                    err = _state.sent();
+                                                    _didIteratorError = true;
+                                                    _iteratorError = err;
+                                                    return [
+                                                        3,
+                                                        12
+                                                    ];
+                                                case 7:
+                                                    _state.trys.push([
+                                                        7,
+                                                        ,
+                                                        10,
+                                                        11
+                                                    ]);
+                                                    if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                                                        3,
+                                                        9
+                                                    ];
+                                                    return [
+                                                        4,
+                                                        _iterator.return()
+                                                    ];
+                                                case 8:
+                                                    _state.sent();
+                                                    _state.label = 9;
+                                                case 9:
+                                                    return [
+                                                        3,
+                                                        11
+                                                    ];
+                                                case 10:
+                                                    if (_didIteratorError) {
+                                                        throw _iteratorError;
+                                                    }
+                                                    return [
+                                                        7
+                                                    ];
+                                                case 11:
+                                                    return [
+                                                        7
+                                                    ];
+                                                case 12:
+                                                    controller.close();
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    })();
+                                }
+                            });
+                            return [
+                                2,
+                                new Response(stream2, {
+                                    headers: {
+                                        "Content-Type": "text/event-stream"
+                                    }
+                                })
+                            ];
+                        }
+                        if (!computerUseConfig) {
+                            stream21 = new ReadableStream({
+                                start: function start(controller) {
+                                    return _async_to_generator(function() {
+                                        var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, _chunk_choices, _choices_, choices, delta, err;
+                                        return _ts_generator(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    _iteratorAbruptCompletion = false, _didIteratorError = false;
+                                                    _state.label = 1;
+                                                case 1:
+                                                    _state.trys.push([
+                                                        1,
+                                                        6,
+                                                        7,
+                                                        12
+                                                    ]);
+                                                    _iterator = _async_iterator(response);
+                                                    _state.label = 2;
+                                                case 2:
+                                                    return [
+                                                        4,
+                                                        _iterator.next()
+                                                    ];
+                                                case 3:
+                                                    if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                                                        3,
+                                                        5
+                                                    ];
+                                                    _value = _step.value;
+                                                    chunk = _value;
+                                                    choices = (_chunk_choices = chunk.choices) !== null && _chunk_choices !== void 0 ? _chunk_choices : [];
+                                                    delta = (_choices_ = choices[0]) === null || _choices_ === void 0 ? void 0 : _choices_.delta;
+                                                    if ((delta === null || delta === void 0 ? void 0 : delta.content) && typeof delta.content === "string") {
+                                                        delta.content = sanitizeContent(delta.content);
+                                                    }
+                                                    controller.enqueue(encoder9.encode("data: ".concat(JSON.stringify(chunk), "\n\n")));
+                                                    _state.label = 4;
+                                                case 4:
+                                                    _iteratorAbruptCompletion = false;
+                                                    return [
+                                                        3,
+                                                        2
+                                                    ];
+                                                case 5:
+                                                    return [
+                                                        3,
+                                                        12
+                                                    ];
+                                                case 6:
+                                                    err = _state.sent();
+                                                    _didIteratorError = true;
+                                                    _iteratorError = err;
+                                                    return [
+                                                        3,
+                                                        12
+                                                    ];
+                                                case 7:
+                                                    _state.trys.push([
+                                                        7,
+                                                        ,
+                                                        10,
+                                                        11
+                                                    ]);
+                                                    if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                                                        3,
+                                                        9
+                                                    ];
+                                                    return [
+                                                        4,
+                                                        _iterator.return()
+                                                    ];
+                                                case 8:
+                                                    _state.sent();
+                                                    _state.label = 9;
+                                                case 9:
+                                                    return [
+                                                        3,
+                                                        11
+                                                    ];
+                                                case 10:
+                                                    if (_didIteratorError) {
+                                                        throw _iteratorError;
+                                                    }
+                                                    return [
+                                                        7
+                                                    ];
+                                                case 11:
+                                                    return [
+                                                        7
+                                                    ];
+                                                case 12:
+                                                    controller.close();
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    })();
+                                }
+                            });
+                            return [
+                                2,
+                                new Response(stream21, {
+                                    headers: {
+                                        "Content-Type": "text/event-stream"
+                                    }
+                                })
+                            ];
+                        }
+                        displayWidth = computerUseConfig.displayWidth, displayHeight = computerUseConfig.displayHeight;
                         stream = new ReadableStream({
                             start: function start(controller) {
                                 return _async_to_generator(function() {
-                                    var _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, err;
+                                    var computerCallIndices, argumentBuffers, emittedIndices, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, _chunk_choices, choices, choice, delta, toolCalls, passThrough, _iteratorNormalCompletion, _didIteratorError1, _iteratorError1, _iterator1, _step1, tc, fn, _ref, initialArgs, denormalized, _argumentBuffers_get, _ref1, buf, denormalized1, modifiedChunk, err1, _iteratorNormalCompletion1, _didIteratorError2, _iteratorError2, _iterator2, _step2, _step_value, index, buf1, denormalized2, flushChunk;
                                     return _ts_generator(this, function(_state) {
                                         switch(_state.label){
                                             case 0:
+                                                computerCallIndices = /* @__PURE__ */ new Set();
+                                                argumentBuffers = /* @__PURE__ */ new Map();
+                                                emittedIndices = /* @__PURE__ */ new Set();
                                                 _iteratorAbruptCompletion = false, _didIteratorError = false;
                                                 _state.label = 1;
                                             case 1:
@@ -5125,7 +5940,105 @@ var post9 = function(param) {
                                                 ];
                                                 _value = _step.value;
                                                 chunk = _value;
-                                                controller.enqueue(encoder9.encode("data: ".concat(JSON.stringify(chunk), "\n\n")));
+                                                choices = (_chunk_choices = chunk.choices) !== null && _chunk_choices !== void 0 ? _chunk_choices : [];
+                                                choice = choices[0];
+                                                delta = choice === null || choice === void 0 ? void 0 : choice.delta;
+                                                toolCalls = delta === null || delta === void 0 ? void 0 : delta.tool_calls;
+                                                if (!toolCalls) {
+                                                    controller.enqueue(encoder9.encode("data: ".concat(JSON.stringify(chunk), "\n\n")));
+                                                    return [
+                                                        3,
+                                                        4
+                                                    ];
+                                                }
+                                                passThrough = [];
+                                                _iteratorNormalCompletion = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                                try {
+                                                    for(_iterator1 = toolCalls[Symbol.iterator](); !(_iteratorNormalCompletion = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion = true){
+                                                        tc = _step1.value;
+                                                        fn = tc.function;
+                                                        if ((fn === null || fn === void 0 ? void 0 : fn.name) === "computer_call") {
+                                                            ;
+                                                            computerCallIndices.add(tc.index);
+                                                            initialArgs = (_ref = fn === null || fn === void 0 ? void 0 : fn.arguments) !== null && _ref !== void 0 ? _ref : "";
+                                                            argumentBuffers.set(tc.index, initialArgs);
+                                                            if (initialArgs) {
+                                                                try {
+                                                                    JSON.parse(initialArgs);
+                                                                    denormalized = denormalizeComputerCallArguments({
+                                                                        argumentsText: initialArgs,
+                                                                        displayWidth: displayWidth,
+                                                                        displayHeight: displayHeight,
+                                                                        model: model
+                                                                    });
+                                                                    passThrough.push(_object_spread_props(_object_spread({}, tc), {
+                                                                        function: _object_spread_props(_object_spread({}, fn), {
+                                                                            arguments: denormalized
+                                                                        })
+                                                                    }));
+                                                                    emittedIndices.add(tc.index);
+                                                                    continue;
+                                                                } catch (unused) {}
+                                                            }
+                                                            passThrough.push(_object_spread_props(_object_spread({}, tc), {
+                                                                function: _object_spread_props(_object_spread({}, fn), {
+                                                                    arguments: ""
+                                                                })
+                                                            }));
+                                                            continue;
+                                                        }
+                                                        if (computerCallIndices.has(tc.index)) {
+                                                            ;
+                                                            buf = ((_argumentBuffers_get = argumentBuffers.get(tc.index)) !== null && _argumentBuffers_get !== void 0 ? _argumentBuffers_get : "") + ((_ref1 = fn === null || fn === void 0 ? void 0 : fn.arguments) !== null && _ref1 !== void 0 ? _ref1 : "");
+                                                            argumentBuffers.set(tc.index, buf);
+                                                            if (!emittedIndices.has(tc.index)) {
+                                                                try {
+                                                                    JSON.parse(buf);
+                                                                    denormalized1 = denormalizeComputerCallArguments({
+                                                                        argumentsText: buf,
+                                                                        displayWidth: displayWidth,
+                                                                        displayHeight: displayHeight,
+                                                                        model: model
+                                                                    });
+                                                                    passThrough.push({
+                                                                        index: tc.index,
+                                                                        function: {
+                                                                            arguments: denormalized1
+                                                                        }
+                                                                    });
+                                                                    emittedIndices.add(tc.index);
+                                                                } catch (unused) {}
+                                                            }
+                                                            continue;
+                                                        }
+                                                        passThrough.push(tc);
+                                                    }
+                                                } catch (err) {
+                                                    _didIteratorError1 = true;
+                                                    _iteratorError1 = err;
+                                                } finally{
+                                                    try {
+                                                        if (!_iteratorNormalCompletion && _iterator1.return != null) {
+                                                            _iterator1.return();
+                                                        }
+                                                    } finally{
+                                                        if (_didIteratorError1) {
+                                                            throw _iteratorError1;
+                                                        }
+                                                    }
+                                                }
+                                                if (passThrough.length > 0) {
+                                                    modifiedChunk = _object_spread_props(_object_spread({}, chunk), {
+                                                        choices: [
+                                                            _object_spread_props(_object_spread({}, choice), {
+                                                                delta: _object_spread_props(_object_spread({}, delta), {
+                                                                    tool_calls: passThrough
+                                                                })
+                                                            })
+                                                        ]
+                                                    });
+                                                    controller.enqueue(encoder9.encode("data: ".concat(JSON.stringify(modifiedChunk), "\n\n")));
+                                                }
                                                 _state.label = 4;
                                             case 4:
                                                 _iteratorAbruptCompletion = false;
@@ -5139,9 +6052,9 @@ var post9 = function(param) {
                                                     12
                                                 ];
                                             case 6:
-                                                err = _state.sent();
+                                                err1 = _state.sent();
                                                 _didIteratorError = true;
-                                                _iteratorError = err;
+                                                _iteratorError = err1;
                                                 return [
                                                     3,
                                                     12
@@ -5181,6 +6094,52 @@ var post9 = function(param) {
                                                     7
                                                 ];
                                             case 12:
+                                                _iteratorNormalCompletion1 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                                                try {
+                                                    for(_iterator2 = Array.from(argumentBuffers)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion1 = true){
+                                                        _step_value = _sliced_to_array(_step2.value, 2), index = _step_value[0], buf1 = _step_value[1];
+                                                        if (!emittedIndices.has(index) && buf1) {
+                                                            denormalized2 = denormalizeComputerCallArguments({
+                                                                argumentsText: buf1,
+                                                                displayWidth: displayWidth,
+                                                                displayHeight: displayHeight,
+                                                                model: model
+                                                            });
+                                                            flushChunk = {
+                                                                object: "chat.completion.chunk",
+                                                                choices: [
+                                                                    {
+                                                                        index: 0,
+                                                                        delta: {
+                                                                            tool_calls: [
+                                                                                {
+                                                                                    index: index,
+                                                                                    function: {
+                                                                                        arguments: denormalized2
+                                                                                    }
+                                                                                }
+                                                                            ]
+                                                                        }
+                                                                    }
+                                                                ]
+                                                            };
+                                                            controller.enqueue(encoder9.encode("data: ".concat(JSON.stringify(flushChunk), "\n\n")));
+                                                        }
+                                                    }
+                                                } catch (err) {
+                                                    _didIteratorError2 = true;
+                                                    _iteratorError2 = err;
+                                                } finally{
+                                                    try {
+                                                        if (!_iteratorNormalCompletion1 && _iterator2.return != null) {
+                                                            _iterator2.return();
+                                                        }
+                                                    } finally{
+                                                        if (_didIteratorError2) {
+                                                            throw _iteratorError2;
+                                                        }
+                                                    }
+                                                }
                                                 controller.close();
                                                 return [
                                                     2
@@ -5207,15 +6166,92 @@ var post9 = function(param) {
                         ]);
                         return [
                             4,
-                            ollama.chat.completions.create(body)
+                            ollama.chat.completions.create(resultOptions)
                         ];
                     case 3:
                         data = _state.sent();
+                        if (computerUseConfig) {
+                            ;
+                            _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                            try {
+                                for(_iterator = ((_data_choices = data.choices) !== null && _data_choices !== void 0 ? _data_choices : [])[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                                    choice = _step.value;
+                                    ;
+                                    message5 = choice.message;
+                                    toolCalls = (_ref = message5 === null || message5 === void 0 ? void 0 : message5.tool_calls) !== null && _ref !== void 0 ? _ref : [];
+                                    _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                                    try {
+                                        for(_iterator1 = toolCalls[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                                            tc = _step1.value;
+                                            fn = tc.function;
+                                            if ((fn === null || fn === void 0 ? void 0 : fn.name) === "computer_call") {
+                                                fn.arguments = denormalizeComputerCallArguments({
+                                                    argumentsText: fn.arguments,
+                                                    displayWidth: computerUseConfig.displayWidth,
+                                                    displayHeight: computerUseConfig.displayHeight,
+                                                    model: model
+                                                });
+                                            }
+                                        }
+                                    } catch (err) {
+                                        _didIteratorError1 = true;
+                                        _iteratorError1 = err;
+                                    } finally{
+                                        try {
+                                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                                _iterator1.return();
+                                            }
+                                        } finally{
+                                            if (_didIteratorError1) {
+                                                throw _iteratorError1;
+                                            }
+                                        }
+                                    }
+                                }
+                            } catch (err) {
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                            }
+                        }
+                        if (getQuirks(model).cleanArtifacts) {
+                            ;
+                            _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
+                            try {
+                                for(_iterator2 = ((_data_choices1 = data.choices) !== null && _data_choices1 !== void 0 ? _data_choices1 : [])[Symbol.iterator](); !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true){
+                                    choice1 = _step2.value;
+                                    message51 = choice1.message;
+                                    if ((message51 === null || message51 === void 0 ? void 0 : message51.content) && typeof message51.content === "string") {
+                                        message51.content = sanitizeContent(message51.content);
+                                    }
+                                }
+                            } catch (err) {
+                                _didIteratorError2 = true;
+                                _iteratorError2 = err;
+                            } finally{
+                                try {
+                                    if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+                                        _iterator2.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError2) {
+                                        throw _iteratorError2;
+                                    }
+                                }
+                            }
+                        }
                         return [
                             2,
-                            new Response(JSON.stringify({
-                                data: data
-                            }), {
+                            new Response(JSON.stringify(data), {
                                 status: 200,
                                 headers: {
                                     "Content-Type": "application/json"
@@ -5341,7 +6377,7 @@ var models13 = function(param) {
     };
 };
 // src/adapters/client/openRouterClientAdapter/completions/normalizeComputerCall.ts
-var MODEL_QUIRKS = {
+var MODEL_QUIRKS2 = {
     "z-ai/glm-4.6v": {
         normalizedCoords: true,
         cleanArtifacts: true
@@ -5354,12 +6390,20 @@ var MODEL_QUIRKS = {
             referenceWidth: 1920,
             referenceHeight: 1080
         }
+    },
+    "google/gemma-4": {
+        normalizedCoords: true,
+        fuzzyFallback: true
+    },
+    "google/gemma-3": {
+        normalizedCoords: true,
+        fuzzyFallback: true
     }
 };
-var getQuirks = function(model) {
+var getQuirks2 = function(model) {
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = Object.entries(MODEL_QUIRKS)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+        for(var _iterator = Object.entries(MODEL_QUIRKS2)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var _step_value = _sliced_to_array(_step.value, 2), prefix = _step_value[0], quirks = _step_value[1];
             if (model.startsWith(prefix)) return quirks;
         }
@@ -5379,10 +6423,10 @@ var getQuirks = function(model) {
     }
     return {};
 };
-var cleanTextArtifacts = function(text) {
+var cleanTextArtifacts2 = function(text) {
     return text.replace(/<\|begin_of_box\|>/g, "").replace(/<\|end_of_box\|>/g, "").replace(/<arg_key>[^<]*<\/arg_key>/g, "").replace(/<\/arg_value>/g, "").trim();
 };
-var KNOWN_ACTION_TYPES = [
+var KNOWN_ACTION_TYPES2 = [
     "double_click",
     "screenshot",
     "keypress",
@@ -5393,7 +6437,7 @@ var KNOWN_ACTION_TYPES = [
     "drag",
     "wait"
 ];
-var splitCoordDigits = function(numStr) {
+var splitCoordDigits2 = function(numStr) {
     for(var i = 1; i < numStr.length; i++){
         var x = parseInt(numStr.slice(0, i));
         var y = parseInt(numStr.slice(i));
@@ -5406,12 +6450,12 @@ var splitCoordDigits = function(numStr) {
     }
     return null;
 };
-var cleanGlmAction = function(action) {
+var cleanGlmAction2 = function(action) {
     var typeVal = action.type;
     if (typeof typeVal !== "string") return action;
     var argValueMatch = typeVal.match(/<arg_value>\s*(\{[\s\S]*\})\s*$/);
     if (argValueMatch) {
-        var inner = parseJson2(argValueMatch[1]);
+        var inner = parseJson3(argValueMatch[1]);
         if (inner && (typeof inner === "undefined" ? "undefined" : _type_of(inner)) === "object") {
             return inner;
         }
@@ -5419,7 +6463,7 @@ var cleanGlmAction = function(action) {
     var cleanedType = typeVal.replace(/<\/?[^>]+>/g, "").replace(/\n/g, "").trim();
     var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
     try {
-        for(var _iterator = KNOWN_ACTION_TYPES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+        for(var _iterator = KNOWN_ACTION_TYPES2[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
             var actionType = _step.value;
             if (cleanedType.startsWith(actionType) && cleanedType !== actionType) {
                 var rest = cleanedType.slice(actionType.length);
@@ -5432,7 +6476,7 @@ var cleanGlmAction = function(action) {
                     });
                 }
                 if (nums && nums.length === 1 && nums[0].length >= 2) {
-                    var coords = splitCoordDigits(nums[0]);
+                    var coords = splitCoordDigits2(nums[0]);
                     if (coords) {
                         return _object_spread(_object_spread_props(_object_spread({}, action), {
                             type: actionType
@@ -5463,7 +6507,7 @@ var cleanGlmAction = function(action) {
         type: cleanedType
     });
 };
-var cleanGlmFields = function(action) {
+var cleanGlmFields2 = function(action) {
     var result = _object_spread({}, action);
     if (typeof result.x === "string") {
         var nums = result.x.match(/\d+/g);
@@ -5497,32 +6541,32 @@ var cleanGlmFields = function(action) {
     }
     return result;
 };
-var applyArtifactCleanup = function(action) {
-    return cleanGlmFields(cleanGlmAction(action));
+var applyArtifactCleanup2 = function(action) {
+    return cleanGlmFields2(cleanGlmAction2(action));
 };
-var parseJson2 = function(text) {
+var parseJson3 = function(text) {
     try {
         return JSON.parse(text);
     } catch (unused) {
         return void 0;
     }
 };
-var extractJson = function(text) {
-    var direct = parseJson2(text);
+var extractJson2 = function(text) {
+    var direct = parseJson3(text);
     if (direct) return direct;
     var codeBlockMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
     if (codeBlockMatch) {
-        var parsed = parseJson2(codeBlockMatch[1].trim());
+        var parsed = parseJson3(codeBlockMatch[1].trim());
         if (parsed) return parsed;
     }
     var jsonMatch = text.match(/(\{[\s\S]*\})\s*$/);
     if (jsonMatch) {
-        var parsed1 = parseJson2(jsonMatch[1].trim());
+        var parsed1 = parseJson3(jsonMatch[1].trim());
         if (parsed1) return parsed1;
     }
     return void 0;
 };
-var fuzzyExtractJson = function(text) {
+var fuzzyExtractJson2 = function(text) {
     var clickMatch = text.match(/"action"\s*:\s*"click"\s*,\s*"x"\s*:\s*\[?\s*(\d+)\s*,\s*(\d+)/);
     if (clickMatch) {
         return {
@@ -5557,24 +6601,24 @@ var fuzzyExtractJson = function(text) {
     }
     return void 0;
 };
-var denormalize = function(value, dimension) {
+var denormalize2 = function(value, dimension) {
     return Math.round(value / 1e3 * dimension);
 };
-var denormalizeAction = function(action, displayWidth, displayHeight) {
+var denormalizeAction2 = function(action, displayWidth, displayHeight) {
     var result = _object_spread({}, action);
     if (typeof result.x === "number") {
-        result.x = denormalize(result.x, displayWidth);
+        result.x = denormalize2(result.x, displayWidth);
     }
     if (typeof result.y === "number") {
-        result.y = denormalize(result.y, displayHeight);
+        result.y = denormalize2(result.y, displayHeight);
     }
     if (Array.isArray(result.path)) {
         result.path = result.path.map(function(point) {
             if (point && (typeof point === "undefined" ? "undefined" : _type_of(point)) === "object") {
                 return _object_spread({}, point, typeof point.x === "number" ? {
-                    x: denormalize(point.x, displayWidth)
+                    x: denormalize2(point.x, displayWidth)
                 } : {}, typeof point.y === "number" ? {
-                    y: denormalize(point.y, displayHeight)
+                    y: denormalize2(point.y, displayHeight)
                 } : {});
             }
             return point;
@@ -5582,25 +6626,25 @@ var denormalizeAction = function(action, displayWidth, displayHeight) {
     }
     return result;
 };
-var rescaleCoord = function(value, displayDim, referenceDim) {
+var rescaleCoord2 = function(value, displayDim, referenceDim) {
     if (value <= 1) return Math.round(value * displayDim);
     return Math.round(value / referenceDim * displayDim);
 };
-var rescaleRelativeAction = function(action, displayWidth, displayHeight, referenceWidth, referenceHeight) {
+var rescaleRelativeAction2 = function(action, displayWidth, displayHeight, referenceWidth, referenceHeight) {
     var result = _object_spread({}, action);
     if (typeof result.x === "number") {
-        result.x = rescaleCoord(result.x, displayWidth, referenceWidth);
+        result.x = rescaleCoord2(result.x, displayWidth, referenceWidth);
     }
     if (typeof result.y === "number") {
-        result.y = rescaleCoord(result.y, displayHeight, referenceHeight);
+        result.y = rescaleCoord2(result.y, displayHeight, referenceHeight);
     }
     if (Array.isArray(result.path)) {
         result.path = result.path.map(function(point) {
             if (point && (typeof point === "undefined" ? "undefined" : _type_of(point)) === "object") {
                 return _object_spread({}, point, typeof point.x === "number" ? {
-                    x: rescaleCoord(point.x, displayWidth, referenceWidth)
+                    x: rescaleCoord2(point.x, displayWidth, referenceWidth)
                 } : {}, typeof point.y === "number" ? {
-                    y: rescaleCoord(point.y, displayHeight, referenceHeight)
+                    y: rescaleCoord2(point.y, displayHeight, referenceHeight)
                 } : {});
             }
             return point;
@@ -5608,7 +6652,7 @@ var rescaleRelativeAction = function(action, displayWidth, displayHeight, refere
     }
     return result;
 };
-var COORD_FIELDS = [
+var COORD_FIELDS2 = [
     "x",
     "y",
     "text",
@@ -5619,9 +6663,9 @@ var COORD_FIELDS = [
     "scroll_y",
     "path"
 ];
-var normalizeStructure = function(parsed, shouldCleanArtifacts) {
+var normalizeStructure2 = function(parsed, shouldCleanArtifacts) {
     var clean = shouldCleanArtifacts ? function(action) {
-        return applyArtifactCleanup(action);
+        return applyArtifactCleanup2(action);
     } : function(action) {
         return action;
     };
@@ -5640,7 +6684,7 @@ var normalizeStructure = function(parsed, shouldCleanArtifacts) {
             for(var _iterator = Object.entries(parsed)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
                 var _step_value = _sliced_to_array(_step.value, 2), key = _step_value[0], value = _step_value[1];
                 if (key === "action") continue;
-                if (COORD_FIELDS.includes(key)) {
+                if (COORD_FIELDS2.includes(key)) {
                     actionObj[key] = value;
                 } else {
                     rest[key] = value;
@@ -5671,7 +6715,7 @@ var normalizeStructure = function(parsed, shouldCleanArtifacts) {
         try {
             for(var _iterator1 = Object.entries(parsed)[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
                 var _step_value1 = _sliced_to_array(_step1.value, 2), key1 = _step_value1[0], value1 = _step_value1[1];
-                if (key1 === "type" || COORD_FIELDS.includes(key1)) {
+                if (key1 === "type" || COORD_FIELDS2.includes(key1)) {
                     actionObj1[key1] = value1;
                 } else {
                     rest1[key1] = value1;
@@ -5697,39 +6741,39 @@ var normalizeStructure = function(parsed, shouldCleanArtifacts) {
     }
     return parsed;
 };
-var denormalizeComputerCallArguments = function(param) {
+var denormalizeComputerCallArguments2 = function(param) {
     var argumentsText = param.argumentsText, displayWidth = param.displayWidth, displayHeight = param.displayHeight, model = param.model;
     if ((typeof argumentsText === "undefined" ? "undefined" : _type_of(argumentsText)) === "object" && argumentsText !== null) {
         argumentsText = JSON.stringify(argumentsText);
     }
-    var quirks = getQuirks(model);
+    var quirks = getQuirks2(model);
     var text = argumentsText;
     if (quirks.cleanArtifacts) {
-        text = cleanTextArtifacts(text);
+        text = cleanTextArtifacts2(text);
     }
-    var parsed = extractJson(text);
+    var parsed = extractJson2(text);
     if (!parsed && (quirks.cleanArtifacts || quirks.fuzzyFallback)) {
-        parsed = fuzzyExtractJson(text);
+        parsed = fuzzyExtractJson2(text);
     }
     if (!parsed || (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) !== "object") {
         return argumentsText;
     }
-    var normalized = normalizeStructure(parsed, !!quirks.cleanArtifacts);
+    var normalized = normalizeStructure2(parsed, !!quirks.cleanArtifacts);
     if (quirks.normalizedCoords && normalized.action && _type_of(normalized.action) === "object") {
         return JSON.stringify(_object_spread_props(_object_spread({}, normalized), {
-            action: denormalizeAction(normalized.action, displayWidth, displayHeight)
+            action: denormalizeAction2(normalized.action, displayWidth, displayHeight)
         }));
     }
     if (quirks.relativeCoords && normalized.action && _type_of(normalized.action) === "object") {
         return JSON.stringify(_object_spread_props(_object_spread({}, normalized), {
-            action: rescaleRelativeAction(normalized.action, displayWidth, displayHeight, quirks.relativeCoords.referenceWidth, quirks.relativeCoords.referenceHeight)
+            action: rescaleRelativeAction2(normalized.action, displayWidth, displayHeight, quirks.relativeCoords.referenceWidth, quirks.relativeCoords.referenceHeight)
         }));
     }
     return JSON.stringify(normalized);
 };
 // src/adapters/client/openRouterClientAdapter/completions/computerUseTool.ts
-var buildComputerCallFunction = function(model, displayWidth, displayHeight) {
-    var quirks = getQuirks(model);
+var buildComputerCallFunction2 = function(model, displayWidth, displayHeight) {
+    var quirks = getQuirks2(model);
     var coordDesc = quirks.normalizedCoords ? "Coordinates use 0-1000 normalized scale (0,0=top-left, 1000,1000=bottom-right)." : quirks.relativeCoords ? "Coordinates are relative (0.0-1.0) where 0.0,0.0 is top-left and 1.0,1.0 is bottom-right. Screen is ".concat(displayWidth, "x").concat(displayHeight, ".") : "Coordinates are in pixels (screen is ".concat(displayWidth, "x").concat(displayHeight, ").");
     var xDesc = quirks.normalizedCoords ? "X coordinate (0-1000 normalized)" : quirks.relativeCoords ? "X coordinate (0.0-1.0 relative, where 0.0=left edge, 1.0=right edge)" : "X coordinate in pixels (0-".concat(displayWidth, ")");
     var yDesc = quirks.normalizedCoords ? "Y coordinate (0-1000 normalized)" : quirks.relativeCoords ? "Y coordinate (0.0-1.0 relative, where 0.0=top edge, 1.0=bottom edge)" : "Y coordinate in pixels (0-".concat(displayHeight, ")");
@@ -5832,7 +6876,7 @@ var buildComputerCallFunction = function(model, displayWidth, displayHeight) {
         }
     };
 };
-var transformTools = function(tools, model) {
+var transformTools2 = function(tools, model) {
     if (!tools || tools.length === 0) {
         return {
             tools: tools !== null && tools !== void 0 ? tools : [],
@@ -5850,7 +6894,7 @@ var transformTools = function(tools, model) {
             };
             return {
                 type: "function",
-                function: buildComputerCallFunction(model, computerUseConfig.displayWidth, computerUseConfig.displayHeight)
+                function: buildComputerCallFunction2(model, computerUseConfig.displayWidth, computerUseConfig.displayHeight)
             };
         }
         return tool;
@@ -5862,12 +6906,12 @@ var transformTools = function(tools, model) {
 };
 // src/adapters/client/openRouterClientAdapter/completions/post.ts
 var encoder10 = new TextEncoder();
-var ARTIFACT_TAGS = /<\|begin_of_box\|>|<\|end_of_box\|>/g;
-var sanitizeContent = function(content) {
+var ARTIFACT_TAGS2 = /<\|begin_of_box\|>|<\|end_of_box\|>/g;
+var sanitizeContent2 = function(content) {
     if (!content) return content;
-    return content.replace(ARTIFACT_TAGS, "").trim();
+    return content.replace(ARTIFACT_TAGS2, "").trim();
 };
-var convertScreenshotToolMessages = function(messages6) {
+var convertScreenshotToolMessages2 = function(messages6) {
     return messages6.map(function(msg) {
         if (msg.role !== "tool" || typeof msg.content !== "string") return msg;
         try {
@@ -6111,17 +7155,17 @@ var post10 = function(param) {
     var openRouter = param.openRouter, provider = param.provider;
     return function(_url, options) {
         return _async_to_generator(function() {
-            var body, model, _transformTools, transformedTools, computerUseConfig, resultOptions, response, _response_headers_get, shouldCleanArtifacts, readableStream2, displayWidth, displayHeight, readableStream, response1, _response_headers_get1, data, _data_choices, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, choice, _ref, message5, toolCalls, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tc, fn, _data_choices1, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, choice1, message51, error;
+            var body, model, _transformTools2, transformedTools, computerUseConfig, resultOptions, response, _response_headers_get, shouldCleanArtifacts, readableStream2, displayWidth, displayHeight, readableStream, response1, _response_headers_get1, data, _data_choices, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, choice, _ref, message5, toolCalls, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, tc, fn, _data_choices1, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, choice1, message51, error;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         body = JSON.parse(options.body);
                         model = body.model;
-                        _transformTools = transformTools(body.tools, model), transformedTools = _transformTools.tools, computerUseConfig = _transformTools.computerUseConfig;
+                        _transformTools2 = transformTools2(body.tools, model), transformedTools = _transformTools2.tools, computerUseConfig = _transformTools2.computerUseConfig;
                         resultOptions = _object_spread({}, body, provider && !body.provider ? {
                             provider: provider
                         } : {}, computerUseConfig && body.messages ? {
-                            messages: convertScreenshotToolMessages(body.messages)
+                            messages: convertScreenshotToolMessages2(body.messages)
                         } : {}, transformedTools.length > 0 ? {
                             tools: transformedTools
                         } : {});
@@ -6147,7 +7191,7 @@ var post10 = function(param) {
                                 })
                             ];
                         }
-                        shouldCleanArtifacts = getQuirks(model).cleanArtifacts;
+                        shouldCleanArtifacts = getQuirks2(model).cleanArtifacts;
                         if (!computerUseConfig && !shouldCleanArtifacts) {
                             return [
                                 2,
@@ -6193,7 +7237,7 @@ var post10 = function(param) {
                                                     delta = (_chunk_choices = chunk.choices) === null || _chunk_choices === void 0 ? void 0 : _chunk_choices[0];
                                                     d = delta === null || delta === void 0 ? void 0 : delta.delta;
                                                     if ((d === null || d === void 0 ? void 0 : d.content) && typeof d.content === "string") {
-                                                        d.content = sanitizeContent(d.content);
+                                                        d.content = sanitizeContent2(d.content);
                                                     }
                                                     controller.enqueue(encoder10.encode("data: ".concat(JSON.stringify(chunk), "\n\n")));
                                                     _state.label = 4;
@@ -6328,7 +7372,7 @@ var post10 = function(param) {
                                                             if (initialArgs) {
                                                                 try {
                                                                     JSON.parse(initialArgs);
-                                                                    denormalized = denormalizeComputerCallArguments({
+                                                                    denormalized = denormalizeComputerCallArguments2({
                                                                         argumentsText: initialArgs,
                                                                         displayWidth: displayWidth,
                                                                         displayHeight: displayHeight,
@@ -6357,7 +7401,7 @@ var post10 = function(param) {
                                                             if (!emittedIndices.has(tc.index)) {
                                                                 try {
                                                                     JSON.parse(buf);
-                                                                    denormalized1 = denormalizeComputerCallArguments({
+                                                                    denormalized1 = denormalizeComputerCallArguments2({
                                                                         argumentsText: buf,
                                                                         displayWidth: displayWidth,
                                                                         displayHeight: displayHeight,
@@ -6462,7 +7506,7 @@ var post10 = function(param) {
                                                     for(_iterator2 = Array.from(argumentBuffers)[Symbol.iterator](); !(_iteratorNormalCompletion1 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion1 = true){
                                                         _step_value = _sliced_to_array(_step2.value, 2), index = _step_value[0], buf1 = _step_value[1];
                                                         if (!emittedIndices.has(index) && buf1) {
-                                                            denormalized2 = denormalizeComputerCallArguments({
+                                                            denormalized2 = denormalizeComputerCallArguments2({
                                                                 argumentsText: buf1,
                                                                 displayWidth: displayWidth,
                                                                 displayHeight: displayHeight,
@@ -6566,7 +7610,7 @@ var post10 = function(param) {
                                             tc = _step1.value;
                                             fn = tc.function;
                                             if ((fn === null || fn === void 0 ? void 0 : fn.name) === "computer_call") {
-                                                fn.arguments = denormalizeComputerCallArguments({
+                                                fn.arguments = denormalizeComputerCallArguments2({
                                                     argumentsText: fn.arguments,
                                                     displayWidth: computerUseConfig.displayWidth,
                                                     displayHeight: computerUseConfig.displayHeight,
@@ -6604,7 +7648,7 @@ var post10 = function(param) {
                                 }
                             }
                         }
-                        if (getQuirks(model).cleanArtifacts) {
+                        if (getQuirks2(model).cleanArtifacts) {
                             ;
                             _iteratorNormalCompletion2 = true, _didIteratorError2 = false, _iteratorError2 = undefined;
                             try {
@@ -6612,7 +7656,7 @@ var post10 = function(param) {
                                     choice1 = _step2.value;
                                     message51 = choice1.message;
                                     if ((message51 === null || message51 === void 0 ? void 0 : message51.content) && typeof message51.content === "string") {
-                                        message51.content = sanitizeContent(message51.content);
+                                        message51.content = sanitizeContent2(message51.content);
                                     }
                                 }
                             } catch (err) {