@bedrockio/ai 0.9.7 → 0.10.0

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.10.0
+
+- Allow file input.
+
 ## 0.9.5
 
 - Export all clients.

package/README.md

@@ -6,6 +6,7 @@ usage.
 
 - [Install](#install)
 - [Usage](#usage)
+- [Files](#files)
 - [Streaming](#stream)
 - [Templates](#templates)
 - [Platforms](#platforms)
@@ -54,6 +55,43 @@ const response = await client.prompt({
 });
 ```
 
+## Files
+
+Files can be passed directly in the options object and follow the same input
+type as the Anthropic API:
+
+```js
+await client.prompt({
+  files: [
+    // By URL
+    {
+      type: 'document',
+      source: {
+        type: 'url',
+        url: 'https://example.com/my-file.pdf',
+      },
+    },
+    // By base64
+    {
+      type: 'document',
+      source: {
+        type: 'base64',
+        media_type: 'application/pdf',
+        data: 'bXl1cmw=',
+      },
+    },
+    // By uploaded ID
+    {
+      type: 'document',
+      source: {
+        type: 'file',
+        file_id: 'file_01',
+      },
+    },
+  ],
+});
+```
+
 ## Streaming
 
 Responses may be streamed:

package/dist/cjs/BaseClient.js

@@ -117,11 +117,44 @@ class BaseClient {
     }
     getFilteredMessages(options) {
         const { messages = [] } = options;
-        return messages.filter((message) => {
-            const trimmed = message.content.trim();
-            return trimmed && trimmed !== '.';
+        return messages
+            .map((message) => {
+            const { content } = message;
+            return {
+                ...message,
+                content: this.getFilteredContent(content),
+            };
+        })
+            .filter((message) => {
+            const { content } = message;
+            if (typeof content === 'string') {
+                return !!content;
+            }
+            else {
+                return content.length > 0;
+            }
         });
     }
+    getFilteredContent(content) {
+        if (typeof content === 'string') {
+            return this.isEmptyContent(content) ? '' : content;
+        }
+        else {
+            return content.filter((block) => {
+                const { type, text } = block;
+                if (type === 'text') {
+                    return !this.isEmptyContent(text);
+                }
+                else {
+                    return true;
+                }
+            });
+        }
+    }
+    isEmptyContent(str) {
+        str = str.trim();
+        return !str || str === '.';
+    }
     // Protected
     runPrompt(options) {
         void options;
@@ -158,6 +191,14 @@ class BaseClient {
         void options;
         throw new Error('Method not implemented.');
     }
+    normalizeContentBlock(block) {
+        void block;
+        throw new Error('Method not implemented.');
+    }
+    normalizeFileBlock(block) {
+        void block;
+        throw new Error('Method not implemented.');
+    }
     // Private
     /**
      * @returns {Object}
@@ -224,18 +265,13 @@ class BaseClient {
         };
     }
     normalizeMessages(options) {
-        let input = options.input || options.messages;
-        // Empty array is equivalent to no input.
-        if (Array.isArray(input) && !input.length) {
-            input = '';
-        }
-        let result = [];
+        const { files = [] } = options;
+        let { input, messages = [] } = options;
         if (Array.isArray(input)) {
-            result = input;
+            messages = input;
         }
-        else {
-            const { messages = [] } = options;
-            result = [
+        else if (typeof input === 'string') {
+            messages = [
                 ...messages,
                 {
                     role: 'user',
@@ -243,18 +279,55 @@ class BaseClient {
                 },
             ];
         }
-        if (result.length === 1 && !result[0].content) {
-            // If a single user input is passed and is nullish, coerce it to a
-            // single period. Combined with getFilteredMessages below this allows
-            // a chatbot the ability to "speak first" by prompting it with empty
-            // content. The empty message will be filtered out of the final result
-            // appearing as if the chatbot went first.
-            // Note that:
-            // GPT will fail on an empty string but on whitespace
-            // Anthropic will fail on all whitespace
-            result[0].content = '.';
+        else if (!input && !messages.length) {
+            messages = [
+                {
+                    role: 'user',
+                },
+            ];
+        }
+        return messages.map((message) => {
+            let { content } = message;
+            if (files.length) {
+                content = [
+                    ...this.expandContentBlocks(content),
+                    ...files.map((block) => {
+                        return this.normalizeFileBlock(block);
+                    }),
+                ];
+            }
+            else if (!content) {
+                // If no user input is passed, coerce it to a single period.
+                // Combined with getFilteredMessages below this allows
+                // a chatbot the ability to "speak first" by prompting it with empty
+                // content. The empty message will be filtered out of the final result
+                // appearing as if the chatbot went first.
+                // Note that:
+                // GPT will fail on an empty string but on whitespace
+                // Anthropic will fail on all whitespace
+                content = '.';
+            }
+            return {
+                ...message,
+                content,
+            };
+        });
+    }
+    expandContentBlocks(content) {
+        if (typeof content === 'string') {
+            content = [
+                {
+                    type: 'text',
+                    text: content,
+                },
+            ];
         }
-        return result;
+        else if (!content) {
+            content = [];
+        }
+        return content.map((block) => {
+            return this.normalizeContentBlock(block);
+        });
     }
     normalizeSchema(options) {
         let { schema } = options;

package/dist/cjs/anthropic.js

@@ -56,6 +56,12 @@ class AnthropicClient extends BaseClient_js_1.default {
         });
         return toolBlock?.input || null;
     }
+    normalizeContentBlock(block) {
+        return block;
+    }
+    normalizeFileBlock(block) {
+        return block;
+    }
     normalizeResponse(response, options) {
         return {
             messages: [

package/dist/cjs/openai.js

@@ -90,6 +90,55 @@ class OpenAiClient extends BaseClient_js_1.default {
         const last = outputs[outputs.length - 1];
         return JSON.parse(last.text);
     }
+    normalizeContentBlock(block) {
+        const { type, text } = block;
+        if (type === 'text') {
+            block = {
+                type: 'input_text',
+                text,
+            };
+        }
+        return block;
+    }
+    normalizeFileBlock(block) {
+        const { type, source } = block;
+        if (type === 'image') {
+            block = {
+                type: 'input_image',
+                ...this.normalizeSourceParams(source, 'image'),
+            };
+        }
+        else if (type === 'document') {
+            block = {
+                type: 'input_file',
+                ...this.normalizeSourceParams(source, 'file'),
+            };
+        }
+        return block;
+    }
+    normalizeSourceParams(source, prefix) {
+        const { type } = source;
+        if (type === 'url') {
+            return {
+                [`${prefix}_url`]: source.url,
+            };
+        }
+        else if (type === 'base64') {
+            const { filename, data } = source;
+            const mimeType = source.mimeType || source.media_type;
+            return {
+                file_data: `data:${mimeType};base64,${data}`,
+                ...(filename && {
+                    filename,
+                }),
+            };
+        }
+        else if (type === 'file') {
+            return {
+                file_id: source.id || source.file_id,
+            };
+        }
+    }
     normalizeResponse(response, options) {
         return {
             messages: [

package/dist/esm/BaseClient.js

@@ -115,11 +115,44 @@ export default class BaseClient {
     }
     getFilteredMessages(options) {
         const { messages = [] } = options;
-        return messages.filter((message) => {
-            const trimmed = message.content.trim();
-            return trimmed && trimmed !== '.';
+        return messages
+            .map((message) => {
+            const { content } = message;
+            return {
+                ...message,
+                content: this.getFilteredContent(content),
+            };
+        })
+            .filter((message) => {
+            const { content } = message;
+            if (typeof content === 'string') {
+                return !!content;
+            }
+            else {
+                return content.length > 0;
+            }
         });
     }
+    getFilteredContent(content) {
+        if (typeof content === 'string') {
+            return this.isEmptyContent(content) ? '' : content;
+        }
+        else {
+            return content.filter((block) => {
+                const { type, text } = block;
+                if (type === 'text') {
+                    return !this.isEmptyContent(text);
+                }
+                else {
+                    return true;
+                }
+            });
+        }
+    }
+    isEmptyContent(str) {
+        str = str.trim();
+        return !str || str === '.';
+    }
     // Protected
     runPrompt(options) {
         void options;
@@ -156,6 +189,14 @@ export default class BaseClient {
         void options;
         throw new Error('Method not implemented.');
     }
+    normalizeContentBlock(block) {
+        void block;
+        throw new Error('Method not implemented.');
+    }
+    normalizeFileBlock(block) {
+        void block;
+        throw new Error('Method not implemented.');
+    }
     // Private
     /**
      * @returns {Object}
@@ -222,18 +263,13 @@ export default class BaseClient {
         };
     }
     normalizeMessages(options) {
-        let input = options.input || options.messages;
-        // Empty array is equivalent to no input.
-        if (Array.isArray(input) && !input.length) {
-            input = '';
-        }
-        let result = [];
+        const { files = [] } = options;
+        let { input, messages = [] } = options;
         if (Array.isArray(input)) {
-            result = input;
+            messages = input;
         }
-        else {
-            const { messages = [] } = options;
-            result = [
+        else if (typeof input === 'string') {
+            messages = [
                 ...messages,
                 {
                     role: 'user',
@@ -241,18 +277,55 @@ export default class BaseClient {
                 },
             ];
         }
-        if (result.length === 1 && !result[0].content) {
-            // If a single user input is passed and is nullish, coerce it to a
-            // single period. Combined with getFilteredMessages below this allows
-            // a chatbot the ability to "speak first" by prompting it with empty
-            // content. The empty message will be filtered out of the final result
-            // appearing as if the chatbot went first.
-            // Note that:
-            // GPT will fail on an empty string but on whitespace
-            // Anthropic will fail on all whitespace
-            result[0].content = '.';
+        else if (!input && !messages.length) {
+            messages = [
+                {
+                    role: 'user',
+                },
+            ];
+        }
+        return messages.map((message) => {
+            let { content } = message;
+            if (files.length) {
+                content = [
+                    ...this.expandContentBlocks(content),
+                    ...files.map((block) => {
+                        return this.normalizeFileBlock(block);
+                    }),
+                ];
+            }
+            else if (!content) {
+                // If no user input is passed, coerce it to a single period.
+                // Combined with getFilteredMessages below this allows
+                // a chatbot the ability to "speak first" by prompting it with empty
+                // content. The empty message will be filtered out of the final result
+                // appearing as if the chatbot went first.
+                // Note that:
+                // GPT will fail on an empty string but on whitespace
+                // Anthropic will fail on all whitespace
+                content = '.';
+            }
+            return {
+                ...message,
+                content,
+            };
+        });
+    }
+    expandContentBlocks(content) {
+        if (typeof content === 'string') {
+            content = [
+                {
+                    type: 'text',
+                    text: content,
+                },
+            ];
         }
-        return result;
+        else if (!content) {
+            content = [];
+        }
+        return content.map((block) => {
+            return this.normalizeContentBlock(block);
+        });
     }
     normalizeSchema(options) {
         let { schema } = options;

package/dist/esm/anthropic.js

@@ -50,6 +50,12 @@ export class AnthropicClient extends BaseClient {
         });
         return toolBlock?.input || null;
     }
+    normalizeContentBlock(block) {
+        return block;
+    }
+    normalizeFileBlock(block) {
+        return block;
+    }
     normalizeResponse(response, options) {
         return {
             messages: [

package/dist/esm/openai.js

@@ -84,6 +84,55 @@ export class OpenAiClient extends BaseClient {
         const last = outputs[outputs.length - 1];
         return JSON.parse(last.text);
     }
+    normalizeContentBlock(block) {
+        const { type, text } = block;
+        if (type === 'text') {
+            block = {
+                type: 'input_text',
+                text,
+            };
+        }
+        return block;
+    }
+    normalizeFileBlock(block) {
+        const { type, source } = block;
+        if (type === 'image') {
+            block = {
+                type: 'input_image',
+                ...this.normalizeSourceParams(source, 'image'),
+            };
+        }
+        else if (type === 'document') {
+            block = {
+                type: 'input_file',
+                ...this.normalizeSourceParams(source, 'file'),
+            };
+        }
+        return block;
+    }
+    normalizeSourceParams(source, prefix) {
+        const { type } = source;
+        if (type === 'url') {
+            return {
+                [`${prefix}_url`]: source.url,
+            };
+        }
+        else if (type === 'base64') {
+            const { filename, data } = source;
+            const mimeType = source.mimeType || source.media_type;
+            return {
+                file_data: `data:${mimeType};base64,${data}`,
+                ...(filename && {
+                    filename,
+                }),
+            };
+        }
+        else if (type === 'file') {
+            return {
+                file_id: source.id || source.file_id,
+            };
+        }
+    }
     normalizeResponse(response, options) {
         return {
             messages: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/ai",
-  "version": "0.9.7",
+  "version": "0.10.0",
   "description": "Bedrock wrapper for common AI chatbots.",
   "type": "module",
   "scripts": {

package/types/BaseClient.d.ts

@@ -24,6 +24,8 @@ export default class BaseClient {
      */
     getTemplateSource(name: string): any;
     getFilteredMessages(options: any): any;
+    getFilteredContent(content: any): any;
+    isEmptyContent(str: any): boolean;
     runPrompt(options: any): void;
     runStream(options: any): void;
     getTextResponse(response: any): void;
@@ -39,16 +41,19 @@ export default class BaseClient {
      * @returns {Object}
      */
     normalizeStreamEvent(event: any, options: any): any;
+    normalizeContentBlock(block: any): void;
+    normalizeFileBlock(block: any): void;
     /**
      * @returns {Object}
      */
     normalizeOptions(options: any): any;
     normalizeInputs(options: any): {
-        messages: any[];
+        messages: any;
         instructions: any;
     };
     normalizeTemplateOptions(options: any): any;
-    normalizeMessages(options: any): any[];
+    normalizeMessages(options: any): any;
+    expandContentBlocks(content: any): any;
     normalizeSchema(options: any): {
         schema: any;
         hasWrappedSchema: boolean;

package/types/BaseClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../src/BaseClient.js"],"names":[],"mappings":"AAOA;IACE,0BAUC;IATC,aAIC;IACD,2BAEE;IAIJ,2BAKC;IAID;;;;;OAKG;IACH,gBAFW,aAAa,gBAiCvB;IAED;;;;;OAKG;IACH,gBAHW,aAAa,GAAG,aAAa,gCAsDvC;IAED;;;;OAIG;IACH,wBAFW,MAAM,OAIhB;IAED,uCAMC;IAID,8BAGC;IAED,8BAGC;IAED,qCAGC;IAED;;OAEG;IACH,0CAGC;IAED;;OAEG;IACH,oDAIC;IAED;;OAEG;IACH,oDAIC;IAID;;OAEG;IACH,oCAOC;IAED;;;MAeC;IAED,4CAiDC;IAED,uCAoCC;IAED;;;MA4BC;IAED,uDAWC;IAED,kDAMC;CACF;;;;;WAIa,MAAM;kBACN,MAAM;;;;cACN,aAAa,EAAE;;;;YACf,MAAM;;;;YACN,OAAO;;;;;;;;aAEP,MAAM,GAAG,MAAM;;;;;;;;;;;sBAOf,MAAM;;;UAKN,QAAQ,GAAG,MAAM,GAAG,WAAW;aAC/B,MAAM;;iCA1Xa,sBAAsB"}
+{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../src/BaseClient.js"],"names":[],"mappings":"AAOA;IACE,0BAUC;IATC,aAIC;IACD,2BAEE;IAIJ,2BAKC;IAID;;;;;OAKG;IACH,gBAFW,aAAa,gBAiCvB;IAED;;;;;OAKG;IACH,gBAHW,aAAa,GAAG,aAAa,gCAsDvC;IAED;;;;OAIG;IACH,wBAFW,MAAM,OAIhB;IAED,uCAkBC;IAED,sCAaC;IAED,kCAGC;IAID,8BAGC;IAED,8BAGC;IAED,qCAGC;IAED;;OAEG;IACH,0CAGC;IAED;;OAEG;IACH,oDAIC;IAED;;OAEG;IACH,oDAIC;IAED,wCAGC;IAED,qCAGC;IAID;;OAEG;IACH,oCAOC;IAED;;;MAeC;IAED,4CAiDC;IAED,qCAkDC;IAED,uCAcC;IAED;;;MA4BC;IAED,uDAWC;IAED,kDAMC;CACF;;;;;WAIa,MAAM;kBACN,MAAM;;;;cACN,aAAa,EAAE;;;;YACf,MAAM;;;;YACN,OAAO;;;;;;;;aAEP,MAAM,GAAG,MAAM;;;;;;;;;;;sBAOf,MAAM;;;UAKN,QAAQ,GAAG,MAAM,GAAG,WAAW;aAC/B,MAAM;;iCAlca,sBAAsB"}

package/types/anthropic.d.ts

@@ -13,6 +13,8 @@ export class AnthropicClient extends BaseClient {
         _request_id?: string | null;
     } & import("@anthropic-ai/sdk/core/streaming.js").Stream<Anthropic.Messages.RawMessageStreamEvent>>;
     getTextResponse(response: any): any;
+    normalizeContentBlock(block: any): any;
+    normalizeFileBlock(block: any): any;
     normalizeResponse(response: any, options: any): {
         messages: any[];
         usage: {

package/types/anthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../src/anthropic.js"],"names":[],"mappings":"AAMA;IACE,6BAA2C;IAIzC,kBAAoC;IAGtC;;;OAGG;IACH,4BAGC;IAED;;wGA2BC;IAED;;wGAKC;IAED,oCAKC;IASD;;;;;;MAiBC;IAED;;;MAKC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuCC;IAID;;;;;;;;;;MA0CC;IAED,oCAKC;IAUD;;;;MAOC;IAID;;;;MAOC;IAED;;;;MAQC;CACF;uBApOsB,iBAAiB;sBAFlB,mBAAmB"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../src/anthropic.js"],"names":[],"mappings":"AAMA;IACE,6BAA2C;IAIzC,kBAAoC;IAGtC;;;OAGG;IACH,4BAGC;IAED;;wGA2BC;IAED;;wGAKC;IAED,oCAKC;IASD,uCAEC;IAED,oCAEC;IAED;;;;;;MAiBC;IAED;;;MAKC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAuCC;IAID;;;;;;;;;;MA0CC;IAED,oCAKC;IAUD;;;;MAOC;IAID;;;;MAOC;IAED;;;;MAQC;CACF;uBA5OsB,iBAAiB;sBAFlB,mBAAmB"}

package/types/openai.d.ts

@@ -14,6 +14,18 @@ export class OpenAiClient extends BaseClient {
         _request_id?: string | null;
     } & import("openai/core/streaming.js").Stream<OpenAI.Responses.ResponseStreamEvent>>;
     getTextResponse(response: any): any;
+    normalizeContentBlock(block: any): any;
+    normalizeFileBlock(block: any): any;
+    normalizeSourceParams(source: any, prefix: any): {
+        [x: string]: any;
+        file_id?: undefined;
+    } | {
+        filename: any;
+        file_data: string;
+        file_id?: undefined;
+    } | {
+        file_id: any;
+    };
     normalizeResponse(response: any, options: any): {
         messages: any[];
         prevResponseId: any;

package/types/openai.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.js"],"names":[],"mappings":"AAIA;IACE,6BAAoC;IAIlC,eAAiC;IAGnC;;;;OAIG;IACH,kBAHW,cAAc,qBAgCxB;IAED;;yFAiCC;IAED;;yFAKC;IAED,oCAEC;IAwBD;;;;;;;MAcC;IAED;;;MAKC;IAID;;;;;;;;;;MAmBC;CA2CF;6BAQA,GAAC,GAAK,KAAK,GACL,SAAS,GACT,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,QAAQ,GACR,OAAO,GACP,OAAO,GACP,MAAM,GACN,QAAQ;uBA3NQ,iBAAiB;mBAFrB,QAAQ"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.js"],"names":[],"mappings":"AAIA;IACE,6BAAoC;IAIlC,eAAiC;IAGnC;;;;OAIG;IACH,kBAHW,cAAc,qBAgCxB;IAED;;yFAiCC;IAED;;yFAKC;IAED,oCAEC;IAwBD,uCAUC;IAED,oCAgBC;IAED;;;;;;;;;MAoBC;IAED;;;;;;;MAcC;IAED;;;MAKC;IAID;;;;;;;;;;MAmBC;CA2CF;6BAQA,GAAC,GAAK,KAAK,GACL,SAAS,GACT,WAAW,GACX,aAAa,GACb,YAAY,GACZ,WAAW,GACX,QAAQ,GACR,OAAO,GACP,OAAO,GACP,MAAM,GACN,QAAQ;uBA/QQ,iBAAiB;mBAFrB,QAAQ"}