rosetta-ai 1.6.1 → 1.6.2

package/dist/index.cjs

@@ -509,12 +509,11 @@ const AnthropicSpecification = {
     messageSchema: AnthropicMessageSchema,
     systemSchema: AnthropicSystemSchema,
     toGenAI({ messages, system, direction }) {
-        // Handle string input
+        // Handle string input - wrap in Anthropic format then fall through
+        // (avoids skipping system instruction handling below)
         if (typeof messages === "string") {
             const role = direction === "input" ? "user" : "assistant";
-            return {
-                messages: [{ role, parts: [{ type: "text", content: messages }] }],
-            };
+            messages = [{ role, content: messages }];
         }
         // Validate with schema
         const parsedMessages = AnthropicMessageSchema.array().parse(messages);
@@ -947,12 +946,11 @@ const CompatSpecification = {
     messageSchema: CompatMessageSchema,
     systemSchema: CompatSystemSchema,
     toGenAI({ messages, system, direction }) {
-        // Handle string input
+        // Handle string input - wrap in compat format then fall through
+        // (avoids skipping system instruction handling below)
         if (typeof messages === "string") {
             const role = direction === "input" ? "user" : "assistant";
-            return {
-                messages: [{ role, parts: [{ type: "text", content: messages }] }],
-            };
+            messages = [{ role, content: messages }];
         }
         // Validate with permissive schema
         const parsedMessages = CompatMessageSchema.array().parse(messages);
@@ -1090,7 +1088,7 @@ function convertMessage(message, direction) {
     }
     // Handle tool response message (role: tool with tool_call_id)
     if ((role === "tool" || role === "function") && parts.length > 0) {
-        const toolCallId = getProperty(normalized, "toolCallId") ?? getProperty(normalized, "toolUseId") ?? null;
+        const toolCallId = getProperty(normalized, "toolCallId") ?? getProperty(normalized, "toolUseId") ?? getProperty(normalized, "toolId") ?? null;
         const toolName = getProperty(normalized, "name") ?? getProperty(normalized, "toolName");
         // Check if we already have tool_call_response parts from content
         const hasToolResponse = parts.some((p) => p.type === "tool_call_response");
@@ -1202,6 +1200,11 @@ function convertTypedPart(part, type) {
             if (url) {
                 return [convertImageUrl(url)];
             }
+            // Handle image_url as a direct string (data URI or URL)
+            const imageUrlStr = getStringProperty(part, "imageUrl");
+            if (imageUrlStr) {
+                return [convertImageUrl(imageUrlStr)];
+            }
             return [];
         }
         case "image": {
@@ -1215,6 +1218,21 @@ function convertTypedPart(part, type) {
             if (image) {
                 return [convertImageUrl(image)];
             }
+            // Fallback: check url or data fields
+            const imageUri = getStringProperty(part, "url") ?? getStringProperty(part, "uri");
+            if (imageUri) {
+                return [convertImageUrl(imageUri)];
+            }
+            const imageData = getStringProperty(part, "data");
+            const imageMime = getStringProperty(part, "mediaType") ?? getStringProperty(part, "mimeType");
+            if (imageData) {
+                if (imageData.startsWith("data:")) {
+                    return [convertImageUrl(imageData)];
+                }
+                return [
+                    { type: "blob", modality: "image", content: imageData, ...(imageMime ? { mime_type: imageMime } : {}) },
+                ];
+            }
             return [];
         }
         case "input_audio":
@@ -1248,6 +1266,25 @@ function convertTypedPart(part, type) {
                     return [{ type: "blob", modality, content: fileData, ...(mimeType ? { mime_type: mimeType } : {}) }];
                 }
             }
+            // Handle file field as string (data URI, URL, or filename)
+            const fileStr = getStringProperty(part, "file");
+            if (fileStr) {
+                const mimeType = getStringProperty(part, "mediaType") ?? getStringProperty(part, "mimeType");
+                const modality = inferModality(mimeType);
+                if (fileStr.startsWith("data:")) {
+                    const match = fileStr.match(/^data:([^;,]+)?(?:;base64)?,(.*)$/);
+                    if (match) {
+                        const parsedMime = match[1] || mimeType || "application/octet-stream";
+                        const data = match[2] || "";
+                        return [{ type: "blob", modality: inferModality(parsedMime), mime_type: parsedMime, content: data }];
+                    }
+                }
+                if (isUrlString(fileStr)) {
+                    return [{ type: "uri", modality, uri: fileStr, ...(mimeType ? { mime_type: mimeType } : {}) }];
+                }
+                // Treat as file ID
+                return [{ type: "file", modality, file_id: fileStr, ...(mimeType ? { mime_type: mimeType } : {}) }];
+            }
             if (source) {
                 return [convertAnthropicDocumentSource(source)];
             }
@@ -1888,14 +1925,14 @@ function groupPartsByMessageIndex(parts) {
 /** Inline blob data (images, audio, etc.) */
 const GoogleBlobSchema = zod.z
     .object({
-    data: zod.z.string().optional(),
-    mimeType: zod.z.string().optional(),
+    data: zod.z.string(),
+    mimeType: zod.z.string(),
 })
     .passthrough();
 /** File reference by URI */
 const GoogleFileDataSchema = zod.z
     .object({
-    fileUri: zod.z.string().optional(),
+    fileUri: zod.z.string(),
     mimeType: zod.z.string().optional(),
 })
     .passthrough();
@@ -1903,29 +1940,29 @@ const GoogleFileDataSchema = zod.z
 const GoogleFunctionCallSchema = zod.z
     .object({
     id: zod.z.string().optional(),
-    name: zod.z.string().optional(),
-    args: zod.z.unknown().optional(),
+    name: zod.z.string(),
+    args: zod.z.object({}).passthrough().optional(),
 })
     .passthrough();
 /** Function response provided to the model */
 const GoogleFunctionResponseSchema = zod.z
     .object({
     id: zod.z.string().optional(),
-    name: zod.z.string().optional(),
-    response: zod.z.unknown().optional(),
+    name: zod.z.string(),
+    response: zod.z.object({}).passthrough(),
 })
     .passthrough();
 /** Executable code generated by the model */
 const GoogleExecutableCodeSchema = zod.z
     .object({
-    code: zod.z.string().optional(),
-    language: zod.z.string().optional(),
+    code: zod.z.string(),
+    language: zod.z.string(),
 })
     .passthrough();
 /** Code execution result */
 const GoogleCodeExecutionResultSchema = zod.z
     .object({
-    outcome: zod.z.string().optional(),
+    outcome: zod.z.string(),
     output: zod.z.string().optional(),
 })
     .passthrough();
@@ -1969,13 +2006,13 @@ const GooglePartSchema = zod.z
 /**
  * Content (message) schema.
  *
- * The role is optional and can be 'user' or 'model'.
- * Parts is an array of Part objects.
+ * Parts is a required array of Part objects.
+ * Role is optional and can be 'user' or 'model'.
  */
 const GoogleContentSchema = zod.z
     .object({
     role: zod.z.string().optional(),
-    parts: zod.z.array(GooglePartSchema).optional(),
+    parts: zod.z.array(GooglePartSchema),
 })
     .passthrough();
 /** System instruction - uses the same Content/Part structure */
@@ -2007,12 +2044,11 @@ const GoogleSpecification = {
     messageSchema: GoogleContentSchema,
     systemSchema: GoogleSystemSchema,
     toGenAI({ messages, system, direction }) {
-        // Handle string input
+        // Handle string input - wrap in Google format (role: "user"/"model", parts with text)
+        // then fall through to the normal conversion pipeline
         if (typeof messages === "string") {
             const role = direction === "input" ? "user" : "model";
-            return {
-                messages: [{ role, parts: [{ type: "text", content: messages }] }],
-            };
+            messages = [{ role, parts: [{ text: messages }] }];
         }
         // Validate with schema
         const parsedMessages = GoogleContentSchema.array().parse(messages);
@@ -2067,7 +2103,7 @@ function googleContentToGenAI(content, direction) {
     const existingMetadata = readMetadata(content);
     const parts = [];
     // Convert each part
-    for (const part of content.parts ?? []) {
+    for (const part of content.parts) {
         parts.push(...convertPart(part));
     }
     // Map role: 'model' -> 'assistant', otherwise keep as-is
@@ -2138,8 +2174,8 @@ function convertPart(part) {
             {
                 type: "blob",
                 modality,
-                mime_type: blob.mimeType ?? null,
-                content: blob.data ?? "",
+                mime_type: blob.mimeType,
+                content: blob.data,
                 ...(metadata ? { _provider_metadata: metadata } : {}),
             },
         ];
@@ -2155,7 +2191,7 @@ function convertPart(part) {
                 type: "uri",
                 modality,
                 mime_type: file.mimeType ?? null,
-                uri: file.fileUri ?? "",
+                uri: file.fileUri,
                 ...(metadata ? { _provider_metadata: metadata } : {}),
             },
         ];
@@ -2169,7 +2205,7 @@ function convertPart(part) {
             {
                 type: "tool_call",
                 id: fc.id ?? null,
-                name: fc.name ?? "",
+                name: fc.name,
                 arguments: fc.args,
                 ...(metadata ? { _provider_metadata: metadata } : {}),
             },
@@ -2179,8 +2215,12 @@ function convertPart(part) {
     if (part.functionResponse !== undefined) {
         const fr = part.functionResponse;
         const frExtra = extractExtraFields(fr, ["id", "name", "response"]);
-        // Store toolName in known fields
-        const metadata = storeMetadata(existingMetadata, { ...extraFields, ...frExtra }, fr.name ? { toolName: fr.name } : {});
+        // Detect error: per Gemini docs, a failed function call has an "error" key in the response
+        const isError = "error" in fr.response;
+        const metadata = storeMetadata(existingMetadata, { ...extraFields, ...frExtra }, {
+            toolName: fr.name,
+            ...(isError ? { isError: true } : {}),
+        });
         return [
             {
                 type: "tool_call_response",
@@ -2198,7 +2238,7 @@ function convertPart(part) {
         return [
             {
                 type: "executable_code",
-                code: code.code ?? "",
+                code: code.code,
                 language: code.language,
                 ...(metadata ? { _provider_metadata: metadata } : {}),
             },
@@ -2410,12 +2450,10 @@ const OpenAICompletionsSpecification = {
     name: "OpenAI Completions",
     messageSchema: OpenAICompletionsMessageSchema,
     toGenAI({ messages, direction }) {
-        // Handle string input
+        // Handle string input - wrap in OpenAI Completions format then fall through
         if (typeof messages === "string") {
             const role = direction === "input" ? "user" : "assistant";
-            return {
-                messages: [{ role, parts: [{ type: "text", content: messages }] }],
-            };
+            messages = [{ role, content: messages }];
         }
         // Validate with schema
         const parsedMessages = OpenAICompletionsMessageSchema.array().parse(messages);
@@ -2853,12 +2891,10 @@ const OpenAIResponsesSpecification = {
     name: "OpenAI Responses",
     messageSchema: OpenAIResponsesItemSchema,
     toGenAI({ messages, direction }) {
-        // Handle string input
+        // Handle string input - wrap in OpenAI Responses format then fall through
         if (typeof messages === "string") {
             const role = direction === "input" ? "user" : "assistant";
-            return {
-                messages: [{ role, parts: [{ type: "text", content: messages }] }],
-            };
+            messages = [{ role, content: messages }];
         }
         // Validate with schema
         const parsedItems = OpenAIResponsesItemSchema.array().parse(messages);