@bedrockio/ai 0.3.0 → 0.4.4

package/dist/cjs/anthropic.js

@@ -1,101 +1,123 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicClient = void 0;
-var _sdk = _interopRequireDefault(require("@anthropic-ai/sdk"));
-var _BaseClient = _interopRequireDefault(require("./BaseClient.js"));
-var _util = require("./util.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const MODELS_URL = 'https://docs.anthropic.com/en/docs/about-claude/models';
-const DEFAULT_MODEL = 'claude-3-5-sonnet-latest';
-class AnthropicClient extends _BaseClient.default {
-  constructor(options) {
-    super(options);
-    this.client = new _sdk.default({
-      ...options
-    });
-  }
-
-  /**
-   * Lists available models.
-   * {@link https://docs.anthropic.com/en/docs/about-claude/models Documentation}
-   */
-  async models() {
-    const {
-      data
-    } = await this.client.models.list();
-    return data.map(o => o.id);
-  }
-  async getCompletion(options) {
-    const {
-      model = DEFAULT_MODEL,
-      max_tokens = 2048,
-      output = 'text',
-      stream = false,
-      messages
-    } = options;
-    const {
-      client
-    } = this;
-    const {
-      system,
-      user
-    } = splitMessages(messages);
-    if (!model) {
-      throw new Error(`No model specified. Available models are here: ${MODELS_URL}.`);
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const BaseClient_js_1 = __importDefault(require("./BaseClient.js"));
+const DEFAULT_TOKENS = 4096;
+class AnthropicClient extends BaseClient_js_1.default {
+    static DEFAULT_MODEL = 'claude-sonnet-4-5';
+    constructor(options) {
+        super(options);
+        this.client = new sdk_1.default(options);
     }
-    const response = await client.messages.create({
-      max_tokens,
-      messages: user,
-      system,
-      model,
-      stream
-    });
-    if (output === 'raw') {
-      return response;
+    /**
+     * Lists available models.
+     * {@link https://docs.anthropic.com/en/docs/about-claude/models Documentation}
+     */
+    async models() {
+        const { data } = await this.client.models.list();
+        return data.map((o) => o.id);
     }
-
-    // @ts-ignore
-    const message = response.content[0];
-    return (0, _util.transformResponse)({
-      ...options,
-      messages,
-      message
-    });
-  }
-  getStreamedChunk(chunk) {
-    // @ts-ignore
-    let type;
-    if (chunk.type === 'content_block_start') {
-      type = 'start';
-    } else if (chunk.type === 'content_block_delta') {
-      type = 'chunk';
-    } else if (chunk.type === 'message_stop') {
-      type = 'stop';
+    async runPrompt(options) {
+        const { input, model, temperature, instructions, stream = false, tokens = DEFAULT_TOKENS, } = options;
+        // @ts-ignore
+        return await this.client.messages.create({
+            model,
+            stream,
+            temperature,
+            max_tokens: tokens,
+            system: instructions,
+            ...this.getSchemaOptions(options),
+            messages: input,
+        });
     }
-    if (type) {
-      return {
-        type,
-        text: chunk.delta?.text || ''
-      };
+    async runStream(options) {
+        return await this.runPrompt({
+            ...options,
+            output: 'raw',
+            stream: true,
+        });
+    }
+    getTextResponse(response) {
+        const textBlock = response.content.find((block) => {
+            return block.type === 'text';
+        });
+        return textBlock?.text || null;
+    }
+    getStructuredResponse(response) {
+        const toolBlock = response.content.find((block) => {
+            return block.type === 'tool_use';
+        });
+        return toolBlock?.input || null;
+    }
+    getMessagesResponse(input, response) {
+        return {
+            messages: [
+                ...input,
+                ...response.content
+                    .filter((item) => {
+                    return item.type === 'text';
+                })
+                    .map((item) => {
+                    return {
+                        role: 'assistant',
+                        content: item.text,
+                    };
+                }),
+            ],
+        };
+    }
+    normalizeStreamEvent(event) {
+        let { type } = event;
+        if (type === 'content_block_start') {
+            return {
+                type: 'start',
+            };
+        }
+        else if (type === 'content_block_stop') {
+            return {
+                type: 'stop',
+            };
+        }
+        else if (type === 'content_block_delta') {
+            return {
+                type: 'delta',
+                text: event.delta.text,
+            };
+        }
+    }
+    // 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,
+                };
+            }
+            return {
+                tools: [
+                    {
+                        name: 'schema',
+                        description: 'Follow the schema for JSON output.',
+                        input_schema: schema,
+                    },
+                ],
+                tool_choice: {
+                    type: 'tool',
+                    name: 'schema',
+                },
+            };
+        }
     }
-  }
 }
 exports.AnthropicClient = AnthropicClient;
-function splitMessages(messages) {
-  const system = [];
-  const user = [];
-  for (let message of messages) {
-    if (message.role === 'system') {
-      system.push(message);
-    } else {
-      user.push(message);
-    }
-  }
-  return {
-    system: system.join('\n'),
-    user
-  };
-}

package/dist/cjs/google.js

@@ -1,88 +1,82 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleClient = void 0;
-var _generativeAi = require("@google/generative-ai");
-var _BaseClient = _interopRequireDefault(require("./BaseClient.js"));
-var _util = require("./util.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const generative_ai_1 = require("@google/generative-ai");
+const BaseClient_js_1 = __importDefault(require("./BaseClient.js"));
 const DEFAULT_MODEL = 'models/gemini-2.0-flash-exp';
-class GoogleClient extends _BaseClient.default {
-  constructor(options) {
-    super(options);
-    const {
-      apiKey
-    } = options;
-    this.client = new _generativeAi.GoogleGenerativeAI(apiKey);
-  }
-
-  /**
-   * Lists available models.
-   * {@link https://ai.google.dev/gemini-api/docs/models/gemini#gemini-2.0-flashl Documentation}
-   */
-  async models() {
-    return ['gemini-2.0-flash-exp', 'gemini-1.5-flash', 'gemini-1.5-flash-8b', 'gemini-1.5-pro'];
-  }
-  async getCompletion(options) {
-    const {
-      model = DEFAULT_MODEL,
-      output = 'text',
-      stream = false
-    } = options;
-    const {
-      client
-    } = this;
-    const generator = client.getGenerativeModel({
-      model
-    });
-    const messages = await this.getMessages(options);
-    const prompts = messages.map(message => {
-      return message.content;
-    });
-    let response;
-    if (stream) {
-      response = await generator.generateContentStream(prompts);
-    } else {
-      response = await generator.generateContent(prompts);
+class GoogleClient extends BaseClient_js_1.default {
+    constructor(options) {
+        super(options);
+        const { apiKey } = options;
+        this.client = new generative_ai_1.GoogleGenerativeAI(apiKey);
     }
-    if (output === 'raw') {
-      return response;
+    /**
+     * Lists available models.
+     * {@link https://ai.google.dev/gemini-api/docs/models/gemini#gemini-2.0-flashl Documentation}
+     */
+    async models() {
+        return [
+            'gemini-2.0-flash-exp',
+            'gemini-1.5-flash',
+            'gemini-1.5-flash-8b',
+            'gemini-1.5-pro',
+        ];
     }
-
-    // @ts-ignore
-    const parts = response.response.candidates.flatMap(candidate => {
-      return candidate.content.parts;
-    });
-    const [message] = parts;
-    return (0, _util.transformResponse)({
-      ...options,
-      messages,
-      message
-    });
-  }
-  async getStream(options) {
-    const response = await super.getStream(options);
-    // @ts-ignore
-    return response.stream;
-  }
-  getStreamedChunk(chunk, started) {
-    const [candidate] = chunk.candidates;
-    let type;
-    if (!started) {
-      type = 'start';
-    } else if (candidate.finishReason === 'STOP') {
-      type = 'stop';
-    } else {
-      type = 'chunk';
+    async getCompletion(options) {
+        const { model = DEFAULT_MODEL, output = 'text', stream = false } = options;
+        const { client } = this;
+        const generator = client.getGenerativeModel({
+            model,
+        });
+        // @ts-ignore
+        const messages = await this.getMessages(options);
+        const prompts = messages.map((message) => {
+            return message.content;
+        });
+        let response;
+        if (stream) {
+            response = await generator.generateContentStream(prompts);
+        }
+        else {
+            response = await generator.generateContent(prompts);
+        }
+        if (output === 'raw') {
+            return response;
+        }
+        // @ts-ignore
+        const parts = response.response.candidates.flatMap((candidate) => {
+            return candidate.content.parts;
+        });
+        const [message] = parts;
+        return message;
     }
-    if (type) {
-      return {
-        type,
-        text: candidate.content.parts[0].text || ''
-      };
+    async getStream(options) {
+        // @ts-ignore
+        const response = await super.getStream(options);
+        // @ts-ignore
+        return response.stream;
+    }
+    getStreamedChunk(chunk, started) {
+        const [candidate] = chunk.candidates;
+        let type;
+        if (!started) {
+            type = 'start';
+        }
+        else if (candidate.finishReason === 'STOP') {
+            type = 'stop';
+        }
+        else {
+            type = 'chunk';
+        }
+        if (type) {
+            return {
+                type,
+                text: candidate.content.parts[0].text || '',
+            };
+        }
     }
-  }
 }
-exports.GoogleClient = GoogleClient;
+exports.GoogleClient = GoogleClient;

package/dist/cjs/index.js

@@ -1,80 +1,28 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.MultiClient = exports.Client = void 0;
-var _openai = require("./openai.js");
-var _google = require("./google.js");
-var _anthropic = require("./anthropic.js");
-var _xai = require("./xai.js");
-class Client {
-  constructor(options = {}) {
-    if (!options.platform) {
-      throw new Error('No platform specified.');
-    } else if (!options.templates) {
-      throw new Error('No templates directory specified.');
-    } else if (!options.apiKey) {
-      throw new Error('No API key specified.');
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+const anthropic_js_1 = require("./anthropic.js");
+const google_js_1 = require("./google.js");
+const openai_js_1 = require("./openai.js");
+const xai_js_1 = require("./xai.js");
+function createClient(options = {}) {
+    const { platform } = options;
+    if (!platform) {
+        throw new Error('No platform specified.');
     }
-    return getClientForPlatform(options);
-  }
-}
-exports.Client = Client;
-class MultiClient {
-  constructor(options) {
-    const {
-      platforms
-    } = options;
-    this.clients = {};
-    for (let platform of platforms) {
-      const {
-        name,
-        apiKey
-      } = platform;
-      const client = getClientForPlatform({
-        ...options,
-        platform: name,
-        apiKey
-      });
-      this.clients[name] = client;
-      this.clients[undefined] ||= client;
+    if (platform === 'openai' || platform === 'gpt') {
+        return new openai_js_1.OpenAiClient(options);
+    }
+    else if (platform === 'google' || platform === 'gemini') {
+        return new google_js_1.GoogleClient(options);
+    }
+    else if (platform === 'anthropic' || platform === 'claude') {
+        return new anthropic_js_1.AnthropicClient(options);
+    }
+    else if (platform === 'xai' || platform === 'grok') {
+        return new xai_js_1.XAiClient(options);
     }
-  }
-  prompt(options) {
-    return this.getClient(options).prompt(options);
-  }
-  stream(options) {
-    return this.getClient(options).stream(options);
-  }
-  buildTemplate(options) {
-    return this.getClient(options).buildTemplate(options);
-  }
-  getClient(options) {
-    const {
-      platform
-    } = options;
-    const client = this.clients[platform];
-    if (!client) {
-      throw new Error(`Platform "${platform}" not found.`);
+    else if (platform) {
+        throw new Error(`Unknown platform "${platform}".`);
     }
-    return client;
-  }
 }
-exports.MultiClient = MultiClient;
-function getClientForPlatform(options) {
-  const {
-    platform
-  } = options;
-  if (platform === 'openai' || platform === 'gpt') {
-    return new _openai.OpenAiClient(options);
-  } else if (platform === 'google' || platform === 'gemini') {
-    return new _google.GoogleClient(options);
-  } else if (platform === 'anthropic' || platform === 'claude') {
-    return new _anthropic.AnthropicClient(options);
-  } else if (platform === 'xai' || platform === 'grok') {
-    return new _xai.XAiClient(options);
-  } else if (platform) {
-    throw new Error(`Unknown platform "${platform}".`);
-  }
-}

package/dist/cjs/openai.js

@@ -1,78 +1,120 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAiClient = void 0;
-var _openai = _interopRequireDefault(require("openai"));
-var _BaseClient = _interopRequireDefault(require("./BaseClient.js"));
-var _util = require("./util.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const DEFAULT_MODEL = 'gpt-4o-mini';
-class OpenAiClient extends _BaseClient.default {
-  constructor(options) {
-    super(options);
-    this.client = new _openai.default({
-      ...options
-    });
-  }
-
-  /**
-   * Lists available models.
-   * {@link https://platform.openai.com/docs/models Documentation}
-   */
-  async models() {
-    const {
-      data
-    } = await this.client.models.list();
-    return data.map(o => o.id);
-  }
-  async getCompletion(options) {
-    const {
-      model = DEFAULT_MODEL,
-      output = 'text',
-      stream = false
-    } = options;
-    const {
-      client
-    } = this;
-    const messages = await this.getMessages(options);
-    const response = await client.chat.completions.create({
-      model,
-      messages,
-      stream,
-      response_format: {
-        type: output === 'json' ? 'json_object' : 'text'
-      }
-    });
-    if (output === 'raw') {
-      return response;
+const openai_1 = __importDefault(require("openai"));
+const BaseClient_js_1 = __importDefault(require("./BaseClient.js"));
+class OpenAiClient extends BaseClient_js_1.default {
+    static DEFAULT_MODEL = 'gpt-5-nano';
+    constructor(options) {
+        super(options);
+        this.client = new openai_1.default(options);
     }
-    const {
-      message
-    } = response.choices[0];
-    return (0, _util.transformResponse)({
-      ...options,
-      messages,
-      message
-    });
-  }
-  getStreamedChunk(chunk, started) {
-    const [choice] = chunk.choices;
-    let type;
-    if (!started) {
-      type = 'start';
-    } else if (choice.finish_reason === 'stop') {
-      type = 'stop';
-    } else {
-      type = 'chunk';
+    /**
+     * Lists available models.
+     * {@link https://platform.openai.com/docs/models Documentation}
+     */
+    async models() {
+        const { data } = await this.client.models.list();
+        return data.map((o) => o.id);
     }
-    if (type) {
-      return {
-        type,
-        text: choice.delta.content || ''
-      };
+    async runPrompt(options) {
+        const { input, model, tools, verbosity, temperature, instructions, prevResponseId, stream = false, } = options;
+        const params = {
+            model,
+            input,
+            tools,
+            stream,
+            temperature,
+            instructions,
+            previous_response_id: prevResponseId,
+            text: {
+                format: this.getOutputFormat(options),
+                verbosity,
+            },
+        };
+        this.debug('Params:', params);
+        // @ts-ignore
+        return await this.client.responses.create(params);
+    }
+    async runStream(options) {
+        return await this.runPrompt({
+            ...options,
+            stream: true,
+        });
+    }
+    getTextResponse(response) {
+        return response.output_text;
+    }
+    getStructuredResponse(response) {
+        return JSON.parse(response.output_text);
+    }
+    getMessagesResponse(input, response) {
+        return {
+            messages: [
+                ...input,
+                {
+                    role: 'assistant',
+                    content: response.output_text,
+                },
+            ],
+            // Note that this ability currently only
+            // exists for OpenAI compatible providers.
+            prevResponseId: response.id,
+        };
+    }
+    // Private
+    getOutputFormat(options) {
+        let { output, schema } = options;
+        if (output === 'json') {
+            return {
+                type: 'json_object',
+            };
+        }
+        else if (schema) {
+            return {
+                type: 'json_schema',
+                // Name is required but arbitrary.
+                name: 'schema',
+                strict: true,
+                schema,
+            };
+        }
+        else {
+            return {
+                type: 'text',
+            };
+        }
+    }
+    normalizeStreamEvent(event) {
+        const { type } = event;
+        if (type === 'response.created') {
+            return {
+                type: 'start',
+                id: event.response.id,
+            };
+        }
+        else if (type === 'response.completed') {
+            return {
+                type: 'stop',
+                id: event.response.id,
+                usage: event.response.usage,
+            };
+        }
+        else if (type === 'response.output_text.delta') {
+            return {
+                type: 'delta',
+                delta: event.delta,
+            };
+        }
+        else if (type === 'response.output_text.done') {
+            return {
+                type: 'done',
+                text: event.text,
+            };
+        }
     }
-  }
 }
-exports.OpenAiClient = OpenAiClient;
+exports.OpenAiClient = OpenAiClient;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{ "type": "commonjs" }