@bedrockio/ai 0.5.1 → 0.6.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.6.0
+
+- Moved template rendering out to external package.
+- Normalized messages input.
+- MCP use with Anthropic.
+
 ## 0.5.1
 
 - Added basic api key authorization.

package/dist/cjs/BaseClient.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const templates_1 = require("@bedrockio/templates");
 const code_js_1 = require("./utils/code.js");
 const json_js_1 = require("./utils/json.js");
-const templates_js_1 = require("./utils/templates.js");
 class BaseClient {
     constructor(options) {
         this.options = {
@@ -10,7 +10,9 @@ class BaseClient {
             model: this.constructor.DEFAULT_MODEL,
             ...options,
         };
-        this.templates = null;
+        this.renderer = new templates_1.TemplateRenderer({
+            dir: options.templates,
+        });
     }
     // Public
     /**
@@ -20,8 +22,8 @@ class BaseClient {
      * @param {PromptOptions} options
      */
     async prompt(options) {
-        options = await this.normalizeOptions(options);
-        const { input, output, stream, schema } = options;
+        options = this.normalizeOptions(options);
+        const { output, stream, schema } = options;
         const response = await this.runPrompt(options);
         if (!stream) {
             this.debug('Response:', response);
@@ -46,7 +48,7 @@ class BaseClient {
         if (output === 'messages') {
             return {
                 result,
-                ...this.getMessagesResponse(input, response),
+                ...this.getMessagesResponse(response, options),
             };
         }
         else {
@@ -60,7 +62,7 @@ class BaseClient {
      * @returns {AsyncIterator}
      */
     async *stream(options) {
-        options = await this.normalizeOptions(options);
+        options = this.normalizeOptions(options);
         const extractor = this.getMessageExtractor(options);
         try {
             const stream = await this.runStream(options);
@@ -103,10 +105,6 @@ class BaseClient {
             };
         }
     }
-    async buildTemplate(options) {
-        const template = await this.resolveTemplate(options);
-        return (0, templates_js_1.renderTemplate)(template, options);
-    }
     // Protected
     runPrompt(options) {
         void options;
@@ -142,24 +140,56 @@ class BaseClient {
         throw new Error('Method not implemented.');
     }
     // Private
-    async normalizeOptions(options) {
-        options = {
-            input: '',
-            output: 'text',
+    /**
+     * @returns {Object}
+     */
+    normalizeOptions(options) {
+        return {
             ...this.options,
             ...options,
+            ...this.normalizeInputs(options),
+            ...this.normalizeSchema(options),
         };
-        options.input = this.normalizeInput(options);
-        options.schema = this.normalizeSchema(options);
-        options.instructions ||= await this.resolveInstructions(options);
-        return options;
     }
-    normalizeInput(options) {
-        let { input = '', output } = options;
-        if (typeof input === 'string') {
-            if (output === 'json') {
-                input += '\nOutput only valid JSON.';
+    normalizeInputs(options) {
+        const { template, params, output = 'text' } = options;
+        const { sections } = this.renderer.run({
+            params,
+            template,
+        });
+        let system = '';
+        let messages = [];
+        for (let section of sections) {
+            const { title = 'system', content } = section;
+            const role = title.toLowerCase();
+            if (role === 'system') {
+                system += [system, content].join('\n');
             }
+            else {
+                messages = [
+                    ...messages,
+                    {
+                        role,
+                        content,
+                    },
+                ];
+            }
+        }
+        messages = [...messages, ...this.normalizeInput(options)];
+        if (output === 'json') {
+            system = [system, 'Output only valid JSON.'].join('\n\n');
+        }
+        return {
+            system,
+            messages,
+        };
+    }
+    normalizeInput(options) {
+        let { input = '' } = options;
+        if (!input) {
+            input = [];
+        }
+        else if (typeof input === 'string') {
             input = [
                 {
                     role: 'user',
@@ -174,6 +204,7 @@ class BaseClient {
         if (!schema) {
             return;
         }
+        let hasWrappedSchema = false;
         // Convert to JSON schema.
         schema = schema.toJSON?.() || schema;
         if (schema?.type === 'array') {
@@ -185,9 +216,12 @@ class BaseClient {
                 required: ['items'],
                 additionalProperties: false,
             };
-            options.hasWrappedSchema = true;
+            hasWrappedSchema = true;
         }
-        return schema;
+        return {
+            schema,
+            hasWrappedSchema,
+        };
     }
     getMessageExtractor(options) {
         const { extractMessages } = options;
@@ -208,21 +242,6 @@ class BaseClient {
             console.debug(`${message}\n${JSON.stringify(arg, null, 2)}\n`);
         }
     }
-    async resolveInstructions(options) {
-        if (options.template) {
-            const template = await this.resolveTemplate(options);
-            return (0, templates_js_1.renderTemplate)(template, options);
-        }
-    }
-    async resolveTemplate(options) {
-        const { template } = options;
-        await this.loadTemplates();
-        return this.templates[template] || template;
-    }
-    async loadTemplates() {
-        const { templates } = this.options;
-        this.templates ||= await (0, templates_js_1.loadTemplates)(templates);
-    }
 }
 exports.default = BaseClient;
 /**

package/dist/cjs/anthropic.js

@@ -23,16 +23,20 @@ class AnthropicClient extends BaseClient_js_1.default {
     }
     async runPrompt(options) {
         const { input, model, temperature, instructions, stream = false, tokens = DEFAULT_TOKENS, } = options;
-        // @ts-ignore
-        return await this.client.messages.create({
+        const params = {
             model,
             stream,
             temperature,
             max_tokens: tokens,
             system: instructions,
-            ...this.getSchemaOptions(options),
             messages: input,
-        });
+            ...this.getToolOptions(options),
+        };
+        const clientOptions = this.getClientOptions(params);
+        this.debug('Params:', params);
+        this.debug('Options:', options);
+        // @ts-ignore
+        return await this.client.messages.create(params, clientOptions);
     }
     async runStream(options) {
         return await this.runPrompt({
@@ -53,10 +57,11 @@ class AnthropicClient extends BaseClient_js_1.default {
         });
         return toolBlock?.input || null;
     }
-    getMessagesResponse(input, response) {
+    getMessagesResponse(response, options) {
+        const { messages } = options;
         return {
             messages: [
-                ...input,
+                ...messages,
                 ...response.content
                     .filter((item) => {
                     return item.type === 'text';
@@ -90,31 +95,57 @@ class AnthropicClient extends BaseClient_js_1.default {
         }
     }
     // Private
-    getSchemaOptions(options) {
-        const { output } = options;
-        if (output?.type) {
-            let schema = output;
-            if (schema.type === 'array') {
-                schema = {
-                    type: 'object',
-                    properties: {
-                        items: schema,
-                    },
-                    required: ['items'],
-                    additionalProperties: false,
-                };
-            }
+    getToolOptions(options) {
+        let { tools = [], schema } = options;
+        let toolChoice;
+        if (schema) {
+            tools.push({
+                name: 'schema',
+                description: 'Follow the schema for JSON output.',
+                input_schema: schema,
+            });
+            toolChoice = {
+                type: 'tool',
+                name: 'schema',
+            };
+        }
+        else {
+            // The default.
+            toolChoice = {
+                type: 'auto',
+            };
+        }
+        const mcpServers = tools
+            .filter((tool) => {
+            return tool.type === 'mcp';
+        })
+            .map((tool) => {
+            return this.mapMcpTool(tool);
+        });
+        tools = tools.filter((tool) => {
+            return tool.type !== 'mcp';
+        });
+        return {
+            tools,
+            mcp_servers: mcpServers,
+            tool_choice: toolChoice,
+        };
+    }
+    // Map OpenAI-like input of MCP servers as "tools" to
+    // Anthropic's mcp_servers.
+    mapMcpTool(tool) {
+        const { server_label, server_url } = tool;
+        return {
+            type: 'url',
+            name: server_label,
+            url: server_url,
+        };
+    }
+    getClientOptions(params) {
+        if (params.mcp_servers) {
             return {
-                tools: [
-                    {
-                        name: 'schema',
-                        description: 'Follow the schema for JSON output.',
-                        input_schema: schema,
-                    },
-                ],
-                tool_choice: {
-                    type: 'tool',
-                    name: 'schema',
+                headers: {
+                    'anthropic-beta': 'mcp-client-2025-04-04',
                 },
             };
         }

package/dist/cjs/openai.js

@@ -21,11 +21,11 @@ class OpenAiClient extends BaseClient_js_1.default {
         return data.map((o) => o.id);
     }
     async runPrompt(options) {
-        const { input, model, tools, verbosity, temperature, instructions, prevResponseId, stream = false, } = options;
+        const { model, tools, verbosity, temperature, prevResponseId, messages: input, system: instructions, stream = false, } = options;
         const params = {
             model,
-            input,
             tools,
+            input,
             stream,
             temperature,
             instructions,
@@ -67,10 +67,11 @@ class OpenAiClient extends BaseClient_js_1.default {
         const last = outputs[outputs.length - 1];
         return JSON.parse(last.text);
     }
-    getMessagesResponse(input, response) {
+    getMessagesResponse(response, options) {
+        const { messages } = options;
         return {
             messages: [
-                ...input,
+                ...messages,
                 {
                     role: 'assistant',
                     content: response.output_text,

package/dist/esm/BaseClient.js

@@ -1,6 +1,6 @@
+import { TemplateRenderer } from '@bedrockio/templates';
 import { parseCode } from './utils/code.js';
 import { createMessageExtractor } from './utils/json.js';
-import { loadTemplates, renderTemplate } from './utils/templates.js';
 export default class BaseClient {
     constructor(options) {
         this.options = {
@@ -8,7 +8,9 @@ export default class BaseClient {
             model: this.constructor.DEFAULT_MODEL,
             ...options,
         };
-        this.templates = null;
+        this.renderer = new TemplateRenderer({
+            dir: options.templates,
+        });
     }
     // Public
     /**
@@ -18,8 +20,8 @@ export default class BaseClient {
      * @param {PromptOptions} options
      */
     async prompt(options) {
-        options = await this.normalizeOptions(options);
-        const { input, output, stream, schema } = options;
+        options = this.normalizeOptions(options);
+        const { output, stream, schema } = options;
         const response = await this.runPrompt(options);
         if (!stream) {
             this.debug('Response:', response);
@@ -44,7 +46,7 @@ export default class BaseClient {
         if (output === 'messages') {
             return {
                 result,
-                ...this.getMessagesResponse(input, response),
+                ...this.getMessagesResponse(response, options),
             };
         }
         else {
@@ -58,7 +60,7 @@ export default class BaseClient {
      * @returns {AsyncIterator}
      */
     async *stream(options) {
-        options = await this.normalizeOptions(options);
+        options = this.normalizeOptions(options);
         const extractor = this.getMessageExtractor(options);
         try {
             const stream = await this.runStream(options);
@@ -101,10 +103,6 @@ export default class BaseClient {
             };
         }
     }
-    async buildTemplate(options) {
-        const template = await this.resolveTemplate(options);
-        return renderTemplate(template, options);
-    }
     // Protected
     runPrompt(options) {
         void options;
@@ -140,24 +138,56 @@ export default class BaseClient {
         throw new Error('Method not implemented.');
     }
     // Private
-    async normalizeOptions(options) {
-        options = {
-            input: '',
-            output: 'text',
+    /**
+     * @returns {Object}
+     */
+    normalizeOptions(options) {
+        return {
             ...this.options,
             ...options,
+            ...this.normalizeInputs(options),
+            ...this.normalizeSchema(options),
         };
-        options.input = this.normalizeInput(options);
-        options.schema = this.normalizeSchema(options);
-        options.instructions ||= await this.resolveInstructions(options);
-        return options;
     }
-    normalizeInput(options) {
-        let { input = '', output } = options;
-        if (typeof input === 'string') {
-            if (output === 'json') {
-                input += '\nOutput only valid JSON.';
+    normalizeInputs(options) {
+        const { template, params, output = 'text' } = options;
+        const { sections } = this.renderer.run({
+            params,
+            template,
+        });
+        let system = '';
+        let messages = [];
+        for (let section of sections) {
+            const { title = 'system', content } = section;
+            const role = title.toLowerCase();
+            if (role === 'system') {
+                system += [system, content].join('\n');
             }
+            else {
+                messages = [
+                    ...messages,
+                    {
+                        role,
+                        content,
+                    },
+                ];
+            }
+        }
+        messages = [...messages, ...this.normalizeInput(options)];
+        if (output === 'json') {
+            system = [system, 'Output only valid JSON.'].join('\n\n');
+        }
+        return {
+            system,
+            messages,
+        };
+    }
+    normalizeInput(options) {
+        let { input = '' } = options;
+        if (!input) {
+            input = [];
+        }
+        else if (typeof input === 'string') {
             input = [
                 {
                     role: 'user',
@@ -172,6 +202,7 @@ export default class BaseClient {
         if (!schema) {
             return;
         }
+        let hasWrappedSchema = false;
         // Convert to JSON schema.
         schema = schema.toJSON?.() || schema;
         if (schema?.type === 'array') {
@@ -183,9 +214,12 @@ export default class BaseClient {
                 required: ['items'],
                 additionalProperties: false,
             };
-            options.hasWrappedSchema = true;
+            hasWrappedSchema = true;
         }
-        return schema;
+        return {
+            schema,
+            hasWrappedSchema,
+        };
     }
     getMessageExtractor(options) {
         const { extractMessages } = options;
@@ -206,21 +240,6 @@ export default class BaseClient {
             console.debug(`${message}\n${JSON.stringify(arg, null, 2)}\n`);
         }
     }
-    async resolveInstructions(options) {
-        if (options.template) {
-            const template = await this.resolveTemplate(options);
-            return renderTemplate(template, options);
-        }
-    }
-    async resolveTemplate(options) {
-        const { template } = options;
-        await this.loadTemplates();
-        return this.templates[template] || template;
-    }
-    async loadTemplates() {
-        const { templates } = this.options;
-        this.templates ||= await loadTemplates(templates);
-    }
 }
 /**
  * @typedef {Object} PromptOptions

package/dist/esm/anthropic.js

@@ -17,16 +17,20 @@ export class AnthropicClient extends BaseClient {
     }
     async runPrompt(options) {
         const { input, model, temperature, instructions, stream = false, tokens = DEFAULT_TOKENS, } = options;
-        // @ts-ignore
-        return await this.client.messages.create({
+        const params = {
             model,
             stream,
             temperature,
             max_tokens: tokens,
             system: instructions,
-            ...this.getSchemaOptions(options),
             messages: input,
-        });
+            ...this.getToolOptions(options),
+        };
+        const clientOptions = this.getClientOptions(params);
+        this.debug('Params:', params);
+        this.debug('Options:', options);
+        // @ts-ignore
+        return await this.client.messages.create(params, clientOptions);
     }
     async runStream(options) {
         return await this.runPrompt({
@@ -47,10 +51,11 @@ export class AnthropicClient extends BaseClient {
         });
         return toolBlock?.input || null;
     }
-    getMessagesResponse(input, response) {
+    getMessagesResponse(response, options) {
+        const { messages } = options;
         return {
             messages: [
-                ...input,
+                ...messages,
                 ...response.content
                     .filter((item) => {
                     return item.type === 'text';
@@ -84,31 +89,57 @@ export class AnthropicClient extends BaseClient {
         }
     }
     // Private
-    getSchemaOptions(options) {
-        const { output } = options;
-        if (output?.type) {
-            let schema = output;
-            if (schema.type === 'array') {
-                schema = {
-                    type: 'object',
-                    properties: {
-                        items: schema,
-                    },
-                    required: ['items'],
-                    additionalProperties: false,
-                };
-            }
+    getToolOptions(options) {
+        let { tools = [], schema } = options;
+        let toolChoice;
+        if (schema) {
+            tools.push({
+                name: 'schema',
+                description: 'Follow the schema for JSON output.',
+                input_schema: schema,
+            });
+            toolChoice = {
+                type: 'tool',
+                name: 'schema',
+            };
+        }
+        else {
+            // The default.
+            toolChoice = {
+                type: 'auto',
+            };
+        }
+        const mcpServers = tools
+            .filter((tool) => {
+            return tool.type === 'mcp';
+        })
+            .map((tool) => {
+            return this.mapMcpTool(tool);
+        });
+        tools = tools.filter((tool) => {
+            return tool.type !== 'mcp';
+        });
+        return {
+            tools,
+            mcp_servers: mcpServers,
+            tool_choice: toolChoice,
+        };
+    }
+    // Map OpenAI-like input of MCP servers as "tools" to
+    // Anthropic's mcp_servers.
+    mapMcpTool(tool) {
+        const { server_label, server_url } = tool;
+        return {
+            type: 'url',
+            name: server_label,
+            url: server_url,
+        };
+    }
+    getClientOptions(params) {
+        if (params.mcp_servers) {
             return {
-                tools: [
-                    {
-                        name: 'schema',
-                        description: 'Follow the schema for JSON output.',
-                        input_schema: schema,
-                    },
-                ],
-                tool_choice: {
-                    type: 'tool',
-                    name: 'schema',
+                headers: {
+                    'anthropic-beta': 'mcp-client-2025-04-04',
                 },
             };
         }

package/dist/esm/openai.js

@@ -15,11 +15,11 @@ export class OpenAiClient extends BaseClient {
         return data.map((o) => o.id);
     }
     async runPrompt(options) {
-        const { input, model, tools, verbosity, temperature, instructions, prevResponseId, stream = false, } = options;
+        const { model, tools, verbosity, temperature, prevResponseId, messages: input, system: instructions, stream = false, } = options;
         const params = {
             model,
-            input,
             tools,
+            input,
             stream,
             temperature,
             instructions,
@@ -61,10 +61,11 @@ export class OpenAiClient extends BaseClient {
         const last = outputs[outputs.length - 1];
         return JSON.parse(last.text);
     }
-    getMessagesResponse(input, response) {
+    getMessagesResponse(response, options) {
+        const { messages } = options;
         return {
             messages: [
-                ...input,
+                ...messages,
                 {
                     role: 'assistant',
                     content: response.output_text,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/ai",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "description": "Bedrock wrapper for common AI chatbots.",
   "type": "module",
   "scripts": {
@@ -35,11 +35,10 @@
     "url": "https://github.com/bedrockio/router"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.65.0",
+    "@anthropic-ai/sdk": "^0.66.0",
+    "@bedrockio/templates": "^0.1.0",
     "@google/generative-ai": "^0.21.0",
-    "glob": "^11.0.1",
-    "mustache": "^4.2.0",
-    "openai": "^6.1.0",
+    "openai": "^6.3.0",
     "partial-json": "^0.1.7"
   },
   "devDependencies": {

package/types/BaseClient.d.ts

@@ -1,7 +1,7 @@
 export default class BaseClient {
     constructor(options: any);
     options: any;
-    templates: any;
+    renderer: TemplateRenderer;
     /**
      * Interpolates vars into the provided template as instructions and runs the
      * prompt.
@@ -16,7 +16,6 @@ export default class BaseClient {
      * @returns {AsyncIterator}
      */
     stream(options: PromptOptions & StreamOptions): AsyncIterator<any, any, any>;
-    buildTemplate(options: any): Promise<any>;
     runPrompt(options: any): void;
     runStream(options: any): void;
     getTextResponse(response: any): void;
@@ -32,14 +31,21 @@ export default class BaseClient {
      * @returns {Object}
      */
     normalizeStreamEvent(event: any): any;
-    normalizeOptions(options: any): Promise<any>;
+    /**
+     * @returns {Object}
+     */
+    normalizeOptions(options: any): any;
+    normalizeInputs(options: any): {
+        system: string;
+        messages: any[];
+    };
     normalizeInput(options: any): any;
-    normalizeSchema(options: any): any;
+    normalizeSchema(options: any): {
+        schema: any;
+        hasWrappedSchema: boolean;
+    };
     getMessageExtractor(options: any): (event: any) => any;
     debug(message: any, arg: any): void;
-    resolveInstructions(options: any): Promise<any>;
-    resolveTemplate(options: any): Promise<any>;
-    loadTemplates(): Promise<void>;
 }
 export type PromptOptions = {
     /**
@@ -78,4 +84,5 @@ export type PromptMessage = {
     role: "system" | "user" | "assistant";
     content: string;
 };
+import { TemplateRenderer } from '@bedrockio/templates';
 //# sourceMappingURL=BaseClient.d.ts.map

package/types/BaseClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../src/BaseClient.js"],"names":[],"mappings":"AAIA;IACE,0BAOC;IANC,aAIC;IACD,eAAqB;IAKvB;;;;;OAKG;IACH,gBAFW,aAAa,gBAuCvB;IAED;;;;;OAKG;IACH,gBAHW,aAAa,GAAG,aAAa,gCAsDvC;IAED,0CAGC;IAID,8BAGC;IAED,8BAGC;IAED,qCAGC;IAED;;OAEG;IACH,0CAGC;IAED;;OAEG;IACH,oDAGC;IAED;;OAEG;IACH,sCAGC;IAID,6CAaC;IAED,kCAiBC;IAED,mCAuBC;IAED,uDAWC;IAED,oCAMC;IAED,gDAKC;IAED,4CAIC;IAED,+BAGC;CACF;;;;;WAIa,MAAM,GAAC,aAAa,EAAE;;;;YACtB,MAAM;;;;YACN,OAAO;;;;;;;;aAEP,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU;;;;;;;;;;;sBAOpC,MAAM;;;UAKN,QAAQ,GAAG,MAAM,GAAG,WAAW;aAC/B,MAAM"}
+{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../src/BaseClient.js"],"names":[],"mappings":"AAKA;IACE,0BASC;IARC,aAIC;IACD,2BAEE;IAKJ;;;;;OAKG;IACH,gBAFW,aAAa,gBAuCvB;IAED;;;;;OAKG;IACH,gBAHW,aAAa,GAAG,aAAa,gCAsDvC;IAID,8BAGC;IAED,8BAGC;IAED,qCAGC;IAED;;OAEG;IACH,0CAGC;IAED;;OAEG;IACH,oDAGC;IAED;;OAEG;IACH,sCAGC;IAID;;OAEG;IACH,oCAOC;IAED;;;MAsCC;IAED,kCAeC;IAED;;;MA4BC;IAED,uDAWC;IAED,oCAMC;CACF;;;;;WAIa,MAAM,GAAC,aAAa,EAAE;;;;YACtB,MAAM;;;;YACN,OAAO;;;;;;;;aAEP,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU;;;;;;;;;;;sBAOpC,MAAM;;;UAKN,QAAQ,GAAG,MAAM,GAAG,WAAW;aAC/B,MAAM;;iCAlTa,sBAAsB"}

package/types/anthropic.d.ts

@@ -13,7 +13,7 @@ export class AnthropicClient extends BaseClient {
         _request_id?: string | null;
     } & import("@anthropic-ai/sdk/core/streaming.js").Stream<Anthropic.Messages.RawMessageStreamEvent>>;
     getTextResponse(response: any): any;
-    getMessagesResponse(input: any, response: any): {
+    getMessagesResponse(response: any, options: any): {
         messages: any[];
     };
     normalizeStreamEvent(event: any): {
@@ -23,15 +23,25 @@ export class AnthropicClient extends BaseClient {
         type: string;
         text: any;
     };
-    getSchemaOptions(options: any): {
-        tools: {
-            name: string;
-            description: string;
-            input_schema: any;
-        }[];
+    getToolOptions(options: any): {
+        tools: any;
+        mcp_servers: any;
         tool_choice: {
             type: string;
             name: string;
+        } | {
+            type: string;
+            name?: undefined;
+        };
+    };
+    mapMcpTool(tool: any): {
+        type: string;
+        name: any;
+        url: any;
+    };
+    getClientOptions(params: any): {
+        headers: {
+            'anthropic-beta': string;
         };
     };
 }

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;;wGAoBC;IAED;;wGAMC;IAED,oCAKC;IASD;;MAgBC;IAED;;;;;;MAgBC;IAID;;;;;;;;;;MA8BC;CACF;uBAtIsB,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;;wGAMC;IAED,oCAKC;IASD;;MAiBC;IAED;;;;;;MAgBC;IAID;;;;;;;;;;MAsCC;IAID;;;;MAOC;IAED;;;;MAQC;CACF;uBA3KsB,iBAAiB;sBAFlB,mBAAmB"}

package/types/openai.d.ts

@@ -13,7 +13,7 @@ export class OpenAiClient extends BaseClient {
         _request_id?: string | null;
     } & import("openai/core/streaming.js").Stream<OpenAI.Responses.ResponseStreamEvent>>;
     getTextResponse(response: any): any;
-    getMessagesResponse(input: any, response: any): {
+    getMessagesResponse(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;;;OAGG;IACH,4BAGC;IAED;;yFA+BC;IAED;;yFAKC;IAED,oCAEC;IAwBD;;;MAaC;IAID;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;MAyBC;CACF;uBArJsB,iBAAiB;mBAFrB,QAAQ"}
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../src/openai.js"],"names":[],"mappings":"AAIA;IACE,6BAAoC;IAIlC,eAAiC;IAGnC;;;OAGG;IACH,4BAGC;IAED;;yFA+BC;IAED;;yFAKC;IAED,oCAEC;IAwBD;;;MAcC;IAID;;;;;;;;;;MAmBC;IAED;;;;;;;;;;;;;;;;;;;;;;;;MAyBC;CACF;uBAtJsB,iBAAiB;mBAFrB,QAAQ"}

package/dist/cjs/utils/templates.js

@@ -1,83 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadTemplates = loadTemplates;
-exports.renderTemplate = renderTemplate;
-const promises_1 = __importDefault(require("fs/promises"));
-const path_1 = __importDefault(require("path"));
-const glob_1 = require("glob");
-const mustache_1 = __importDefault(require("mustache"));
-async function loadTemplates(dir) {
-    const result = {};
-    const files = await (0, glob_1.glob)(path_1.default.join(dir, '*.md'));
-    if (!files.length) {
-        throw new Error(`No templates found in: ${dir}.`);
-    }
-    for (let file of files) {
-        const base = path_1.default.basename(file, '.md');
-        result[base] = await loadTemplate(file);
-    }
-    return result;
-}
-function renderTemplate(template, options) {
-    let params = {
-        ...options,
-        ...options.params,
-    };
-    params = mapObjects(params);
-    params = wrapProxy(params);
-    return mustache_1.default.render(template, params);
-}
-// Utils
-async function loadTemplate(file) {
-    return await promises_1.default.readFile(file, 'utf-8');
-}
-// Transform arrays and object to versions
-// that are more understandable in the context
-// of a template that may have meaningful whitespace.
-function mapObjects(params) {
-    const result = {};
-    for (let [key, value] of Object.entries(params)) {
-        if (Array.isArray(value)) {
-            value = mapArray(value);
-        }
-        else if (typeof value === 'object') {
-            value = JSON.stringify(value, null, 2);
-        }
-        result[key] = value;
-    }
-    return result;
-}
-function mapArray(arr) {
-    // Only map simple arrays of primitives.
-    if (typeof arr[0] === 'string') {
-        arr = arr
-            .map((el) => {
-            return `- ${el}`;
-        })
-            .join('\n');
-    }
-    return arr;
-}
-// Wrap params with a proxy object that reports
-// as having all properties. If one is accessed
-// that does not exist then return the original
-// token. This way templates can be partially
-// interpolated and re-interpolated later.
-function wrapProxy(params) {
-    return new Proxy(params, {
-        has() {
-            return true;
-        },
-        get(target, prop) {
-            if (prop in target) {
-                return target[prop];
-            }
-            else {
-                return `{{{${prop.toString()}}}}`;
-            }
-        },
-    });
-}

package/dist/esm/utils/templates.js

@@ -1,76 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { glob } from 'glob';
-import Mustache from 'mustache';
-export async function loadTemplates(dir) {
-    const result = {};
-    const files = await glob(path.join(dir, '*.md'));
-    if (!files.length) {
-        throw new Error(`No templates found in: ${dir}.`);
-    }
-    for (let file of files) {
-        const base = path.basename(file, '.md');
-        result[base] = await loadTemplate(file);
-    }
-    return result;
-}
-export function renderTemplate(template, options) {
-    let params = {
-        ...options,
-        ...options.params,
-    };
-    params = mapObjects(params);
-    params = wrapProxy(params);
-    return Mustache.render(template, params);
-}
-// Utils
-async function loadTemplate(file) {
-    return await fs.readFile(file, 'utf-8');
-}
-// Transform arrays and object to versions
-// that are more understandable in the context
-// of a template that may have meaningful whitespace.
-function mapObjects(params) {
-    const result = {};
-    for (let [key, value] of Object.entries(params)) {
-        if (Array.isArray(value)) {
-            value = mapArray(value);
-        }
-        else if (typeof value === 'object') {
-            value = JSON.stringify(value, null, 2);
-        }
-        result[key] = value;
-    }
-    return result;
-}
-function mapArray(arr) {
-    // Only map simple arrays of primitives.
-    if (typeof arr[0] === 'string') {
-        arr = arr
-            .map((el) => {
-            return `- ${el}`;
-        })
-            .join('\n');
-    }
-    return arr;
-}
-// Wrap params with a proxy object that reports
-// as having all properties. If one is accessed
-// that does not exist then return the original
-// token. This way templates can be partially
-// interpolated and re-interpolated later.
-function wrapProxy(params) {
-    return new Proxy(params, {
-        has() {
-            return true;
-        },
-        get(target, prop) {
-            if (prop in target) {
-                return target[prop];
-            }
-            else {
-                return `{{{${prop.toString()}}}}`;
-            }
-        },
-    });
-}