@byteplus-iga-pages/agent 0.0.0-stage → 1.0.3

package/dist/cjs/521.js

@@ -0,0 +1,242 @@
+"use strict";
+exports.ids = [
+    "521"
+];
+exports.modules = {
+    "../tools/src/adapters.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            Kv: ()=>toOpenAIAgentsTool,
+            dF: ()=>toClaudeAgentSdkTool,
+            iE: ()=>toOpenAISdkTool
+        });
+        var zod__rspack_import_1 = __webpack_require__("../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/types.js");
+        var _model_output_js__rspack_import_0 = __webpack_require__("../tools/src/model-output.ts");
+        function toClaudeAgentSdkTool(source) {
+            return {
+                ...toClaudeMcpTool(source),
+                execute: source.definition.execute
+            };
+        }
+        function toOpenAISdkTool(source) {
+            return {
+                type: "function",
+                function: {
+                    name: source.definition.name,
+                    description: source.definition.description,
+                    parameters: source.definition.inputSchema
+                },
+                execute: source.definition.execute,
+                toModelMessages: _model_output_js__rspack_import_0.LW
+            };
+        }
+        function toOpenAIAgentsTool(source) {
+            const execute = (input, options)=>source.definition.execute(stripNullishObject(input), options);
+            return {
+                type: "function",
+                name: source.definition.name,
+                description: source.definition.description,
+                strict: true,
+                parameters: toOpenAIStrictSchema(source.definition.inputSchema),
+                execute,
+                invoke: async (contextOrInput, input, details)=>{
+                    const result = await execute(parseToolInput(void 0 === input ? contextOrInput : input), {
+                        abortSignal: details?.signal
+                    });
+                    if (!(0, _model_output_js__rspack_import_0.eA)(result)) return result;
+                    const { base64Image, mimeType, base64ImageLength } = result.data;
+                    return [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                status: "success",
+                                data: {
+                                    mimeType,
+                                    base64ImageLength
+                                }
+                            })
+                        },
+                        {
+                            type: "image",
+                            image: `data:${mimeType};base64,${base64Image}`
+                        }
+                    ];
+                },
+                needsApproval: async ()=>false,
+                isEnabled: async ()=>true
+            };
+        }
+        function toClaudeMcpTool(source, options) {
+            const tool = {
+                name: source.definition.name,
+                description: source.definition.description,
+                inputSchema: toClaudeInputShape(source.definition.inputSchema),
+                async handler (input, extra) {
+                    const signal = extra && "object" == typeof extra && "signal" in extra ? extra.signal : void 0;
+                    const result = await source.definition.execute(input, {
+                        abortSignal: signal instanceof AbortSignal ? signal : void 0
+                    });
+                    if ("error" === result.status) return {
+                        content: [
+                            {
+                                type: "text",
+                                text: stringify(result)
+                            }
+                        ],
+                        isError: true
+                    };
+                    if ((0, _model_output_js__rspack_import_0.eA)(result)) {
+                        const { base64Image, mimeType, base64ImageLength } = result.data;
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: JSON.stringify({
+                                        status: "success",
+                                        data: {
+                                            mimeType,
+                                            base64ImageLength
+                                        }
+                                    })
+                                },
+                                {
+                                    type: "image",
+                                    data: base64Image,
+                                    mimeType
+                                }
+                            ]
+                        };
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: stringify(result)
+                            }
+                        ]
+                    };
+                }
+            };
+            if (options?.alwaysLoad ?? true) return {
+                ...tool,
+                _meta: {
+                    "anthropic/alwaysLoad": true
+                }
+            };
+            return tool;
+        }
+        function toOpenAIStrictSchema(schema) {
+            const required = new Set(schema.required ?? []);
+            return {
+                type: "object",
+                properties: Object.fromEntries(Object.entries(schema.properties).map(([name, property])=>[
+                        name,
+                        {
+                            ...required.has(name) ? toOpenAIPropertySchema(property) : {
+                                anyOf: [
+                                    toOpenAIPropertySchema(property),
+                                    {
+                                        type: "null"
+                                    }
+                                ]
+                            },
+                            ...propertyDescription(property)
+                        }
+                    ])),
+                required: Object.keys(schema.properties),
+                additionalProperties: false
+            };
+        }
+        function toOpenAIPropertySchema(property) {
+            const schema = property;
+            if (Array.isArray(schema.enum) && schema.enum.every((value)=>"string" == typeof value)) return {
+                type: "string",
+                enum: schema.enum
+            };
+            switch(schema.type){
+                case "number":
+                case "integer":
+                    return {
+                        type: "number",
+                        ..."number" == typeof schema.minimum ? {
+                            minimum: schema.minimum
+                        } : {}
+                    };
+                case "boolean":
+                    return {
+                        type: "boolean"
+                    };
+                case "object":
+                    return {
+                        type: "object",
+                        additionalProperties: {}
+                    };
+                case "array":
+                    return {
+                        type: "array",
+                        items: {}
+                    };
+                default:
+                    return {
+                        type: "string"
+                    };
+            }
+        }
+        function toClaudeInputShape(schema) {
+            const required = new Set(schema.required ?? []);
+            return Object.fromEntries(Object.entries(schema.properties).map(([name, property])=>{
+                const base = toZodSchema(property);
+                const field = required.has(name) ? base : base.optional();
+                const { description } = propertyDescription(property);
+                return [
+                    name,
+                    void 0 === description ? field : field.describe(description)
+                ];
+            }));
+        }
+        function propertyDescription(property) {
+            const { description } = property;
+            return "string" == typeof description ? {
+                description
+            } : {};
+        }
+        function toZodSchema(property) {
+            const schema = property;
+            if (Array.isArray(schema.enum) && schema.enum.every((value)=>"string" == typeof value)) return zod__rspack_import_1.k5(schema.enum);
+            switch(schema.type){
+                case "number":
+                    {
+                        const numberSchema = zod__rspack_import_1.ai();
+                        return "number" == typeof schema.minimum ? numberSchema.min(schema.minimum) : numberSchema;
+                    }
+                case "integer":
+                    {
+                        const numberSchema = zod__rspack_import_1.ai().int();
+                        return "number" == typeof schema.minimum ? numberSchema.min(schema.minimum) : numberSchema;
+                    }
+                case "boolean":
+                    return zod__rspack_import_1.zM();
+                case "array":
+                    return zod__rspack_import_1.YO(zod__rspack_import_1.L5());
+                case "object":
+                    return zod__rspack_import_1.g1(zod__rspack_import_1.L5());
+                default:
+                    return zod__rspack_import_1.Yj();
+            }
+        }
+        function parseToolInput(input) {
+            if ("string" == typeof input) try {
+                return stripNullishObject(JSON.parse(input));
+            } catch  {
+                return {};
+            }
+            return stripNullishObject(input);
+        }
+        function stripNullishObject(input) {
+            if (null === input || "object" != typeof input || Array.isArray(input)) return {};
+            return Object.fromEntries(Object.entries(input).filter(([, value])=>null != value));
+        }
+        function stringify(result) {
+            return JSON.stringify(result);
+        }
+    }
+};

package/dist/cjs/594.js

@@ -0,0 +1,79 @@
+"use strict";
+exports.ids = [
+    "594"
+];
+exports.modules = {
+    "../tools/src/model-output.ts" (__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+        __webpack_require__.d(__webpack_exports__, {
+            LW: ()=>toOpenAIModelMessages,
+            LY: ()=>toImageUrlContent,
+            eA: ()=>isScreenshotResult
+        });
+        function isScreenshotResult(result) {
+            if ("error" === result.status || !result.data || "object" != typeof result.data) return false;
+            const data = result.data;
+            return "string" == typeof data.base64Image && data.base64Image.length > 0 && "string" == typeof data.mimeType && /^image\/(png|jpeg|webp|gif)$/.test(data.mimeType) && "number" == typeof data.base64ImageLength;
+        }
+        function toImageUrlContent(result) {
+            if (!isScreenshotResult(result)) return [
+                {
+                    type: "text",
+                    text: JSON.stringify(result)
+                }
+            ];
+            const { base64Image, mimeType, base64ImageLength } = result.data;
+            return [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "success",
+                        data: {
+                            mimeType,
+                            base64ImageLength
+                        }
+                    })
+                },
+                {
+                    type: "image_url",
+                    image_url: {
+                        url: `data:${mimeType};base64,${base64Image}`
+                    }
+                }
+            ];
+        }
+        function toOpenAIModelMessages(result, toolCallId) {
+            if (!isScreenshotResult(result)) return [
+                {
+                    role: "tool",
+                    tool_call_id: toolCallId,
+                    content: JSON.stringify(result)
+                }
+            ];
+            const content = toImageUrlContent(result);
+            return [
+                {
+                    role: "tool",
+                    tool_call_id: toolCallId,
+                    content: JSON.stringify({
+                        status: "success",
+                        data: {
+                            mimeType: result.data.mimeType,
+                            base64ImageLength: result.data.base64ImageLength
+                        },
+                        message: "Screenshot is attached in a following user image message."
+                    })
+                },
+                {
+                    role: "user",
+                    content: [
+                        {
+                            type: "text",
+                            text: `Screenshot from tool call ${toolCallId}.`
+                        },
+                        ...content.filter((part)=>"image_url" === part.type)
+                    ]
+                }
+            ];
+        }
+    }
+};