cloudassist-ai-provider 0.0.1

package/dist/convert-to-google-generative-ai-messages.js

@@ -0,0 +1,195 @@
+import { UnsupportedFunctionalityError, } from '@ai-sdk/provider';
+import { convertToBase64 } from '@ai-sdk/provider-utils';
+import { isClaudeModel } from './google-prepare-tools';
+export function convertToGoogleGenerativeAIMessages(prompt, options) {
+    var _a, _b;
+    const systemInstructionParts = [];
+    const contents = [];
+    let systemMessagesAllowed = true;
+    const isGemmaModel = (_a = options === null || options === void 0 ? void 0 : options.isGemmaModel) !== null && _a !== void 0 ? _a : false;
+    const modelId = (_b = options === null || options === void 0 ? void 0 : options.modelId) !== null && _b !== void 0 ? _b : '';
+    const includeToolCallId = isClaudeModel(modelId);
+    for (const { role, content } of prompt) {
+        switch (role) {
+            case 'system': {
+                if (!systemMessagesAllowed) {
+                    throw new UnsupportedFunctionalityError({
+                        functionality: 'system messages are only supported at the beginning of the conversation',
+                    });
+                }
+                systemInstructionParts.push({ text: content });
+                break;
+            }
+            case 'user': {
+                systemMessagesAllowed = false;
+                const parts = [];
+                for (const part of content) {
+                    switch (part.type) {
+                        case 'text': {
+                            parts.push({ text: part.text });
+                            break;
+                        }
+                        case 'file': {
+                            // default to image/jpeg for unknown image/* types
+                            const mediaType = part.mediaType === 'image/*' ? 'image/jpeg' : part.mediaType;
+                            parts.push(part.data instanceof URL
+                                ? {
+                                    fileData: {
+                                        mimeType: mediaType,
+                                        fileUri: part.data.toString(),
+                                    },
+                                }
+                                : {
+                                    inlineData: {
+                                        mimeType: mediaType,
+                                        data: convertToBase64(part.data),
+                                    },
+                                });
+                            break;
+                        }
+                    }
+                }
+                contents.push({ role: 'user', parts });
+                break;
+            }
+            case 'assistant': {
+                systemMessagesAllowed = false;
+                contents.push({
+                    role: 'model',
+                    parts: content
+                        .map(part => {
+                        var _a, _b, _c;
+                        const thoughtSignature = ((_b = (_a = part.providerOptions) === null || _a === void 0 ? void 0 : _a.google) === null || _b === void 0 ? void 0 : _b.thoughtSignature) != null
+                            ? String((_c = part.providerOptions.google) === null || _c === void 0 ? void 0 : _c.thoughtSignature)
+                            : undefined;
+                        switch (part.type) {
+                            case 'text': {
+                                return part.text.length === 0
+                                    ? undefined
+                                    : {
+                                        text: part.text,
+                                        thoughtSignature,
+                                    };
+                            }
+                            case 'reasoning': {
+                                return part.text.length === 0
+                                    ? undefined
+                                    : {
+                                        text: part.text,
+                                        thought: true,
+                                        thoughtSignature,
+                                    };
+                            }
+                            case 'file': {
+                                if (part.mediaType !== 'image/png') {
+                                    throw new UnsupportedFunctionalityError({
+                                        functionality: 'Only PNG images are supported in assistant messages',
+                                    });
+                                }
+                                if (part.data instanceof URL) {
+                                    throw new UnsupportedFunctionalityError({
+                                        functionality: 'File data URLs in assistant messages are not supported',
+                                    });
+                                }
+                                return {
+                                    inlineData: {
+                                        mimeType: part.mediaType,
+                                        data: convertToBase64(part.data),
+                                    },
+                                };
+                            }
+                            case 'tool-call': {
+                                return {
+                                    functionCall: {
+                                        name: part.toolName,
+                                        args: part.input,
+                                        ...(includeToolCallId && part.toolCallId
+                                            ? { id: part.toolCallId }
+                                            : {}),
+                                    },
+                                    thoughtSignature,
+                                };
+                            }
+                        }
+                    })
+                        .filter(part => part !== undefined),
+                });
+                break;
+            }
+            case 'tool': {
+                systemMessagesAllowed = false;
+                const parts = [];
+                for (const part of content) {
+                    const output = part.output;
+                    if (output.type === 'content') {
+                        for (const contentPart of output.value) {
+                            switch (contentPart.type) {
+                                case 'text':
+                                    parts.push({
+                                        functionResponse: {
+                                            name: part.toolName,
+                                            response: {
+                                                name: part.toolName,
+                                                content: contentPart.text,
+                                            },
+                                            ...(includeToolCallId && part.toolCallId
+                                                ? { id: part.toolCallId }
+                                                : {}),
+                                        },
+                                    });
+                                    break;
+                                case 'media':
+                                    parts.push({
+                                        inlineData: {
+                                            mimeType: contentPart.mediaType,
+                                            data: contentPart.data,
+                                        },
+                                    }, {
+                                        text: 'Tool executed successfully and returned this image as a response',
+                                    });
+                                    break;
+                                default:
+                                    parts.push({ text: JSON.stringify(contentPart) });
+                                    break;
+                            }
+                        }
+                    }
+                    else {
+                        parts.push({
+                            functionResponse: {
+                                name: part.toolName,
+                                response: {
+                                    name: part.toolName,
+                                    content: output.value,
+                                },
+                                ...(includeToolCallId && part.toolCallId
+                                    ? { id: part.toolCallId }
+                                    : {}),
+                            },
+                        });
+                    }
+                }
+                contents.push({
+                    role: 'user',
+                    parts,
+                });
+                break;
+            }
+        }
+    }
+    if (isGemmaModel &&
+        systemInstructionParts.length > 0 &&
+        contents.length > 0 &&
+        contents[0].role === 'user') {
+        const systemText = systemInstructionParts
+            .map(part => part.text)
+            .join('\n\n');
+        contents[0].parts.unshift({ text: systemText + '\n\n' });
+    }
+    return {
+        systemInstruction: systemInstructionParts.length > 0 && !isGemmaModel
+            ? { parts: systemInstructionParts }
+            : undefined,
+        contents,
+    };
+}

package/dist/convert-to-google-generative-ai-messages.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=convert-to-google-generative-ai-messages.test.d.ts.map

package/dist/convert-to-google-generative-ai-messages.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-to-google-generative-ai-messages.test.d.ts","sourceRoot":"","sources":["../src/convert-to-google-generative-ai-messages.test.ts"],"names":[],"mappings":""}

package/dist/convert-to-google-generative-ai-messages.test.js

@@ -0,0 +1,456 @@
+import { convertToGoogleGenerativeAIMessages } from './convert-to-google-generative-ai-messages';
+import { describe, it, expect } from 'vitest';
+describe('system messages', () => {
+    it('should store system message in system instruction', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            { role: 'system', content: 'Test' },
+        ]);
+        expect(result).toEqual({
+            systemInstruction: { parts: [{ text: 'Test' }] },
+            contents: [],
+        });
+    });
+    it('should throw error when there was already a user message', async () => {
+        expect(() => convertToGoogleGenerativeAIMessages([
+            { role: 'user', content: [{ type: 'text', text: 'Test' }] },
+            { role: 'system', content: 'Test' },
+        ])).toThrow('system messages are only supported at the beginning of the conversation');
+    });
+});
+describe('thought signatures', () => {
+    it('should preserve thought signatures in assistant messages', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'text',
+                        text: 'Regular text',
+                        providerOptions: { google: { thoughtSignature: 'sig1' } },
+                    },
+                    {
+                        type: 'reasoning',
+                        text: 'Reasoning text',
+                        providerOptions: { google: { thoughtSignature: 'sig2' } },
+                    },
+                    {
+                        type: 'tool-call',
+                        toolCallId: 'call1',
+                        toolName: 'test',
+                        input: { value: 'test' },
+                        providerOptions: { google: { thoughtSignature: 'sig3' } },
+                    },
+                ],
+            },
+        ]);
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "contents": [
+          {
+            "parts": [
+              {
+                "text": "Regular text",
+                "thoughtSignature": "sig1",
+              },
+              {
+                "text": "Reasoning text",
+                "thought": true,
+                "thoughtSignature": "sig2",
+              },
+              {
+                "functionCall": {
+                  "args": {
+                    "value": "test",
+                  },
+                  "name": "test",
+                },
+                "thoughtSignature": "sig3",
+              },
+            ],
+            "role": "model",
+          },
+        ],
+        "systemInstruction": undefined,
+      }
+    `);
+    });
+});
+describe('Gemma model system instructions', () => {
+    it('should prepend system instruction to first user message for Gemma models', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            { role: 'system', content: 'You are a helpful assistant.' },
+            { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+        ], { isGemmaModel: true });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "contents": [
+          {
+            "parts": [
+              {
+                "text": "You are a helpful assistant.
+
+      ",
+              },
+              {
+                "text": "Hello",
+              },
+            ],
+            "role": "user",
+          },
+        ],
+        "systemInstruction": undefined,
+      }
+    `);
+    });
+    it('should handle multiple system messages for Gemma models', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            { role: 'system', content: 'You are helpful.' },
+            { role: 'system', content: 'Be concise.' },
+            { role: 'user', content: [{ type: 'text', text: 'Hi' }] },
+        ], { isGemmaModel: true });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "contents": [
+          {
+            "parts": [
+              {
+                "text": "You are helpful.
+
+      Be concise.
+
+      ",
+              },
+              {
+                "text": "Hi",
+              },
+            ],
+            "role": "user",
+          },
+        ],
+        "systemInstruction": undefined,
+      }
+    `);
+    });
+    it('should not affect non-Gemma models', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            { role: 'system', content: 'You are helpful.' },
+            { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+        ], { isGemmaModel: false });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "contents": [
+          {
+            "parts": [
+              {
+                "text": "Hello",
+              },
+            ],
+            "role": "user",
+          },
+        ],
+        "systemInstruction": {
+          "parts": [
+            {
+              "text": "You are helpful.",
+            },
+          ],
+        },
+      }
+    `);
+    });
+    it('should handle Gemma model with system instruction but no user messages', async () => {
+        const result = convertToGoogleGenerativeAIMessages([{ role: 'system', content: 'You are helpful.' }], { isGemmaModel: true });
+        expect(result).toMatchInlineSnapshot(`
+      {
+        "contents": [],
+        "systemInstruction": undefined,
+      }
+    `);
+    });
+});
+describe('user messages', () => {
+    it('should add image parts', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'user',
+                content: [
+                    {
+                        type: 'file',
+                        data: 'AAECAw==',
+                        mediaType: 'image/png',
+                    },
+                ],
+            },
+        ]);
+        expect(result).toEqual({
+            systemInstruction: undefined,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            inlineData: {
+                                data: 'AAECAw==',
+                                mimeType: 'image/png',
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    it('should add file parts for base64 encoded files', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'user',
+                content: [{ type: 'file', data: 'AAECAw==', mediaType: 'image/png' }],
+            },
+        ]);
+        expect(result).toEqual({
+            systemInstruction: undefined,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            inlineData: {
+                                data: 'AAECAw==',
+                                mimeType: 'image/png',
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+});
+describe('tool messages', () => {
+    it('should convert tool result messages to function responses', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolName: 'testFunction',
+                        toolCallId: 'testCallId',
+                        output: { type: 'json', value: { someData: 'test result' } },
+                    },
+                ],
+            },
+        ]);
+        expect(result).toEqual({
+            systemInstruction: undefined,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: 'testFunction',
+                                response: {
+                                    name: 'testFunction',
+                                    content: { someData: 'test result' },
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+});
+describe('assistant messages', () => {
+    it('should add PNG image parts for base64 encoded files', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'assistant',
+                content: [{ type: 'file', data: 'AAECAw==', mediaType: 'image/png' }],
+            },
+        ]);
+        expect(result).toEqual({
+            systemInstruction: undefined,
+            contents: [
+                {
+                    role: 'model',
+                    parts: [
+                        {
+                            inlineData: {
+                                data: 'AAECAw==',
+                                mimeType: 'image/png',
+                            },
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+    it('should throw error for non-PNG images in assistant messages', async () => {
+        expect(() => convertToGoogleGenerativeAIMessages([
+            {
+                role: 'assistant',
+                content: [
+                    { type: 'file', data: 'AAECAw==', mediaType: 'image/jpeg' },
+                ],
+            },
+        ])).toThrow('Only PNG images are supported in assistant messages');
+    });
+    it('should throw error for URL file data in assistant messages', async () => {
+        expect(() => convertToGoogleGenerativeAIMessages([
+            {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'file',
+                        data: new URL('https://example.com/image.png'),
+                        mediaType: 'image/png',
+                    },
+                ],
+            },
+        ])).toThrow('File data URLs in assistant messages are not supported');
+    });
+    it('should convert tool result messages with content type (multipart with images)', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolName: 'imageGenerator',
+                        toolCallId: 'testCallId',
+                        output: {
+                            type: 'content',
+                            value: [
+                                {
+                                    type: 'text',
+                                    text: 'Here is the generated image:',
+                                },
+                                {
+                                    type: 'media',
+                                    data: 'base64encodedimagedata',
+                                    mediaType: 'image/jpeg',
+                                },
+                            ],
+                        },
+                    },
+                ],
+            },
+        ]);
+        expect(result).toEqual({
+            systemInstruction: undefined,
+            contents: [
+                {
+                    role: 'user',
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: 'imageGenerator',
+                                response: {
+                                    name: 'imageGenerator',
+                                    content: 'Here is the generated image:',
+                                },
+                            },
+                        },
+                        {
+                            inlineData: {
+                                mimeType: 'image/jpeg',
+                                data: 'base64encodedimagedata',
+                            },
+                        },
+                        {
+                            text: 'Tool executed successfully and returned this image as a response',
+                        },
+                    ],
+                },
+            ],
+        });
+    });
+});
+describe('parallel tool calls', () => {
+    it('should include thought signature on functionCall when provided', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'tool-call',
+                        toolCallId: 'call1',
+                        toolName: 'checkweather',
+                        input: { city: 'paris' },
+                        providerOptions: { google: { thoughtSignature: 'sig_parallel' } },
+                    },
+                    {
+                        type: 'tool-call',
+                        toolCallId: 'call2',
+                        toolName: 'checkweather',
+                        input: { city: 'london' },
+                    },
+                ],
+            },
+        ]);
+        expect(result.contents[0].parts[0]).toEqual({
+            functionCall: {
+                args: { city: 'paris' },
+                name: 'checkweather',
+            },
+            thoughtSignature: 'sig_parallel',
+        });
+        expect(result.contents[0].parts[1]).toEqual({
+            functionCall: {
+                args: { city: 'london' },
+                name: 'checkweather',
+            },
+            thoughtSignature: undefined,
+        });
+    });
+});
+describe('tool results with thought signatures', () => {
+    it('should include thought signature on functionCall but not on functionResponse', async () => {
+        const result = convertToGoogleGenerativeAIMessages([
+            {
+                role: 'assistant',
+                content: [
+                    {
+                        type: 'tool-call',
+                        toolCallId: 'call1',
+                        toolName: 'readdata',
+                        input: { userId: '123' },
+                        providerOptions: { google: { thoughtSignature: 'sig_original' } },
+                    },
+                ],
+            },
+            {
+                role: 'tool',
+                content: [
+                    {
+                        type: 'tool-result',
+                        toolCallId: 'call1',
+                        toolName: 'readdata',
+                        output: {
+                            type: 'error-text',
+                            value: 'file not found',
+                        },
+                        providerOptions: { google: { thoughtSignature: 'sig_original' } },
+                    },
+                ],
+            },
+        ]);
+        expect(result.contents[0].parts[0]).toEqual({
+            functionCall: {
+                args: { userId: '123' },
+                name: 'readdata',
+            },
+            thoughtSignature: 'sig_original',
+        });
+        expect(result.contents[1].parts[0]).toEqual({
+            functionResponse: {
+                name: 'readdata',
+                response: {
+                    content: 'file not found',
+                    name: 'readdata',
+                },
+            },
+        });
+        expect(result.contents[1].parts[0]).not.toHaveProperty('thoughtSignature');
+    });
+});

package/dist/get-model-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getModelPath(modelId: string): string;
+//# sourceMappingURL=get-model-path.d.ts.map

package/dist/get-model-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-model-path.d.ts","sourceRoot":"","sources":["../src/get-model-path.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpD"}

package/dist/get-model-path.js

@@ -0,0 +1,3 @@
+export function getModelPath(modelId) {
+    return modelId.includes('/') ? modelId : `models/${modelId}`;
+}

package/dist/get-model-path.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=get-model-path.test.d.ts.map

package/dist/get-model-path.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-model-path.test.d.ts","sourceRoot":"","sources":["../src/get-model-path.test.ts"],"names":[],"mappings":""}

package/dist/get-model-path.test.js

@@ -0,0 +1,11 @@
+import { getModelPath } from './get-model-path';
+import { it, expect } from 'vitest';
+it('should pass through model path for models/*', async () => {
+    expect(getModelPath('models/some-model')).toEqual('models/some-model');
+});
+it('should pass through model path for tunedModels/*', async () => {
+    expect(getModelPath('tunedModels/some-model')).toEqual('tunedModels/some-model');
+});
+it('should add model path prefix to models without slash', async () => {
+    expect(getModelPath('some-model')).toEqual('models/some-model');
+});