@bedrockio/ai 0.4.2 → 0.5.0

package/__mocks__/@anthropic-ai/sdk.js

@@ -1,37 +0,0 @@
-let mock;
-let models;
-
-export default function MockAnthropicClient() {
-  return {
-    messages: {
-      create(options) {
-        if (options.stream) {
-          return streamMock();
-        } else {
-          return mock;
-        }
-      },
-    },
-    models: {
-      list() {
-        return {
-          data: models,
-        };
-      },
-    },
-  };
-}
-
-export function setResponse(data) {
-  mock = data;
-}
-
-export function setModels(data) {
-  models = data;
-}
-
-async function* streamMock() {
-  for await (let event of mock) {
-    yield event;
-  }
-}

package/__mocks__/@google/generative-ai.js

@@ -1,59 +0,0 @@
-let mock;
-
-class MockGoogleClient {
-  constructor() {
-    return {
-      getGenerativeModel() {
-        return {
-          generateContent() {
-            return mock;
-          },
-          generateContentStream() {
-            return {
-              stream: streamMock(),
-            };
-          },
-        };
-      },
-    };
-  }
-}
-
-function setResponse(data) {
-  mock = data;
-}
-
-async function* streamMock() {
-  const content = mock.response.candidates[0].content.parts[0].text;
-  const size = Math.floor(content.length / 3);
-  const one = content.slice(0, size);
-  const two = content.slice(size, 2 * size);
-  const three = content.slice(2 * size);
-  yield wrapChunk(one);
-  yield wrapChunk(two);
-  yield wrapChunk(three, true);
-}
-
-function wrapChunk(str, finish) {
-  return {
-    candidates: [
-      {
-        ...(finish && {
-          finishReason: 'STOP',
-        }),
-        content: {
-          parts: [
-            {
-              text: str,
-            },
-          ],
-        },
-      },
-    ],
-  };
-}
-
-module.exports = {
-  GoogleGenerativeAI: MockGoogleClient,
-  setResponse,
-};

package/__mocks__/openai.js

@@ -1,53 +0,0 @@
-let models;
-let responses = {};
-
-export default function MockOpenAiClient() {
-  return {
-    chat: {
-      completions: {
-        create(options) {
-          if (options.stream) {
-            return streamMock();
-          } else {
-            return responses['default'];
-          }
-        },
-      },
-    },
-    responses: {
-      create(options) {
-        const { previous_response_id = 'default' } = options;
-        if (!options.input) {
-          throw new Error('Missing parameter "input".');
-        }
-        const response = responses[previous_response_id];
-        if (options.stream) {
-          return streamMock(response);
-        } else {
-          return response;
-        }
-      },
-    },
-    models: {
-      list() {
-        return {
-          data: models,
-        };
-      },
-    },
-  };
-}
-
-export function setResponse(data, name = 'default') {
-  responses[name] = data;
-}
-
-export function setModels(data) {
-  models = data;
-}
-
-async function* streamMock(response) {
-  for await (let event of response) {
-    yield event;
-  }
-}

package/eslint.config.js

@@ -1,2 +0,0 @@
-import { nodeImports, recommended } from '@bedrockio/eslint-plugin';
-export default [recommended, nodeImports];

package/src/BaseClient.js

@@ -1,288 +0,0 @@
-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 = {
-      // @ts-ignore
-      model: this.constructor.DEFAULT_MODEL,
-      ...options,
-    };
-    this.templates = null;
-  }
-
-  // Public
-
-  /**
-   * Interpolates vars into the provided template as instructions and runs the
-   * prompt.
-   *
-   * @param {PromptOptions} options
-   */
-  async prompt(options) {
-    options = await this.normalizeOptions(options);
-
-    const { input, output, stream, schema } = options;
-
-    const response = await this.runPrompt(options);
-
-    if (!stream) {
-      this.debug('Response:', response);
-    }
-
-    if (output === 'raw') {
-      return response;
-    }
-
-    let result;
-    if (schema) {
-      result = this.getStructuredResponse(response);
-
-      // @ts-ignore
-      if (options.hasWrappedSchema) {
-        result = result.items;
-      }
-    } else if (output === 'json') {
-      result = JSON.parse(parseCode(this.getTextResponse(response)));
-    } else {
-      result = parseCode(this.getTextResponse(response));
-    }
-
-    if (output === 'messages') {
-      return {
-        result,
-        ...this.getMessagesResponse(input, response),
-      };
-    } else {
-      return result;
-    }
-  }
-
-  /**
-   * Streams the prompt response.
-   *
-   * @param {PromptOptions & StreamOptions} options
-   * @returns {AsyncIterator}
-   */
-  async *stream(options) {
-    options = await this.normalizeOptions(options);
-
-    const extractor = this.getMessageExtractor(options);
-
-    try {
-      const stream = await this.runStream(options);
-
-      // @ts-ignore
-      for await (let event of stream) {
-        this.debug('Event:', event);
-
-        event = this.normalizeStreamEvent(event);
-
-        if (event) {
-          yield event;
-        }
-
-        const extractedMessages = extractor?.(event) || [];
-
-        for (let message of extractedMessages) {
-          const { key, delta, text, done } = message;
-
-          let extractEvent;
-          if (done) {
-            extractEvent = {
-              type: 'extract:done',
-              text,
-              key,
-            };
-          } else {
-            extractEvent = {
-              type: 'extract:delta',
-              delta,
-              key,
-            };
-          }
-
-          this.debug('Extract:', extractEvent);
-
-          yield extractEvent;
-        }
-      }
-    } catch (error) {
-      const { message, code } = error;
-      yield {
-        type: 'error',
-        code,
-        message,
-      };
-    }
-  }
-
-  async buildTemplate(options) {
-    const template = await this.resolveTemplate(options);
-    return renderTemplate(template, options);
-  }
-
-  // Protected
-
-  runPrompt(options) {
-    void options;
-    throw new Error('Method not implemented.');
-  }
-
-  runStream(options) {
-    void options;
-    throw new Error('Method not implemented.');
-  }
-
-  getTextResponse(response) {
-    void response;
-    throw new Error('Method not implemented.');
-  }
-
-  /**
-   * @returns {Object}
-   */
-  getStructuredResponse(response) {
-    void response;
-    throw new Error('Method not implemented.');
-  }
-
-  /**
-   * @returns {Object}
-   */
-  getMessagesResponse(input, response) {
-    void response;
-    throw new Error('Method not implemented.');
-  }
-
-  /**
-   * @returns {Object}
-   */
-  normalizeStreamEvent(event) {
-    void event;
-    throw new Error('Method not implemented.');
-  }
-
-  // Private
-
-  async normalizeOptions(options) {
-    options = {
-      input: '',
-      output: 'text',
-      ...this.options,
-      ...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.';
-      }
-
-      input = [
-        {
-          role: 'user',
-          content: input,
-        },
-      ];
-    }
-
-    return input;
-  }
-
-  normalizeSchema(options) {
-    let { schema } = options;
-
-    if (!schema) {
-      return;
-    }
-
-    // Convert to JSON schema.
-    schema = schema.toJSON?.() || schema;
-
-    if (schema?.type === 'array') {
-      schema = {
-        type: 'object',
-        properties: {
-          items: schema,
-        },
-        required: ['items'],
-        additionalProperties: false,
-      };
-      options.hasWrappedSchema = true;
-    }
-
-    return schema;
-  }
-
-  getMessageExtractor(options) {
-    const { extractMessages } = options;
-    if (!extractMessages) {
-      return;
-    }
-    const messageExtractor = createMessageExtractor([extractMessages]);
-    return (event) => {
-      if (event?.type === 'delta') {
-        return messageExtractor(event.delta);
-      }
-    };
-  }
-
-  debug(message, arg) {
-    if (this.options.debug) {
-      // TODO: replace with logger when opentelemetry is removed
-      // eslint-disable-next-line
-      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
- * @property {string|PromptMessage[]} input - Input to use.
- * @property {string} [model] - The model to use.
- * @property {boolean} stream - Stream response.
- * @property {Object} [schema] - A JSON schema compatible object that defines the output shape.
- * @property {"raw" | "text" | "json" | "messages"} [output] - The return value type.
- * @property {Object} [params] - Params to be interpolated into the template.
- *                               May also be passed as additional props to options.
- */
-
-/**
- * @typedef {Object} StreamOptions
- * @property {string} [extractMessages] - Key in JSON response to extract a message stream from.
- */
-
-/**
- * @typedef {Object} PromptMessage
- * @property {"system" | "user" | "assistant"} role
- * @property {string} content
- */

package/src/anthropic.js

@@ -1,137 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-
-import BaseClient from './BaseClient.js';
-
-const DEFAULT_TOKENS = 4096;
-
-export class AnthropicClient extends BaseClient {
-  static DEFAULT_MODEL = 'claude-sonnet-4-5';
-
-  constructor(options) {
-    super(options);
-    this.client = new Anthropic(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 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,
-    });
-  }
-
-  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',
-        },
-      };
-    }
-  }
-}

package/src/google.js

@@ -1,88 +0,0 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
-
-import BaseClient from './BaseClient.js';
-
-const DEFAULT_MODEL = 'models/gemini-2.0-flash-exp';
-
-export class GoogleClient extends BaseClient {
-  constructor(options) {
-    super(options);
-    const { apiKey } = options;
-    this.client = new 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,
-    });
-
-    // @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;
-  }
-  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 || '',
-      };
-    }
-  }
-}

package/src/index.js

@@ -1,24 +0,0 @@
-import { AnthropicClient } from './anthropic.js';
-import { GoogleClient } from './google.js';
-import { OpenAiClient } from './openai.js';
-import { XAiClient } from './xai.js';
-
-export function createClient(options = {}) {
-  const { platform } = options;
-
-  if (!platform) {
-    throw new Error('No platform specified.');
-  }
-
-  if (platform === 'openai' || platform === 'gpt') {
-    return new OpenAiClient(options);
-  } else if (platform === 'google' || platform === 'gemini') {
-    return new GoogleClient(options);
-  } else if (platform === 'anthropic' || platform === 'claude') {
-    return new AnthropicClient(options);
-  } else if (platform === 'xai' || platform === 'grok') {
-    return new XAiClient(options);
-  } else if (platform) {
-    throw new Error(`Unknown platform "${platform}".`);
-  }
-}