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

package/dist/esm/521.js

@@ -0,0 +1,230 @@
+import { toOpenAIModelMessages, isScreenshotResult } from "./594.js";
+import { numberType, booleanType, enumType, arrayType, recordType, stringType, unknownType } from "./392.js";
+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: toOpenAIModelMessages
+    };
+}
+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 (!isScreenshotResult(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 (isScreenshotResult(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 enumType(schema.enum);
+    switch(schema.type){
+        case "number":
+            {
+                const numberSchema = numberType();
+                return "number" == typeof schema.minimum ? numberSchema.min(schema.minimum) : numberSchema;
+            }
+        case "integer":
+            {
+                const numberSchema = numberType().int();
+                return "number" == typeof schema.minimum ? numberSchema.min(schema.minimum) : numberSchema;
+            }
+        case "boolean":
+            return booleanType();
+        case "array":
+            return arrayType(unknownType());
+        case "object":
+            return recordType(unknownType());
+        default:
+            return stringType();
+    }
+}
+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);
+}
+export { toClaudeAgentSdkTool, toOpenAIAgentsTool, toOpenAISdkTool };

package/dist/esm/594.js

@@ -0,0 +1,67 @@
+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)
+            ]
+        }
+    ];
+}
+export { isScreenshotResult, toImageUrlContent, toOpenAIModelMessages };