@bedrockio/ai 0.3.0 → 0.4.4

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

@@ -1,43 +0,0 @@
-let mock;
-
-function MockAnthropicClient() {
-  return {
-    messages: {
-      create(options) {
-        if (options.stream) {
-          return streamMock();
-        } else {
-          return mock;
-        }
-      },
-    },
-  };
-}
-
-function setResponse(data) {
-  mock = data;
-}
-
-async function* streamMock() {
-  const content = mock.content[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, 'content_block_start');
-  yield wrapChunk(two, 'content_block_delta');
-  yield wrapChunk(three, 'message_stop');
-}
-
-function wrapChunk(str, type) {
-  return {
-    type,
-    delta: {
-      text: str,
-    },
-  };
-}
-
-MockAnthropicClient.setResponse = setResponse;
-
-module.exports = MockAnthropicClient;

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 = {
-  setResponse,
-  GoogleGenerativeAI: MockGoogleClient,
-};

package/__mocks__/openai.js

@@ -1,48 +0,0 @@
-let mock;
-
-function MockOpenAiClient() {
-  return {
-    chat: {
-      completions: {
-        create(options) {
-          if (options.stream) {
-            return streamMock();
-          } else {
-            return mock;
-          }
-        },
-      },
-    },
-  };
-}
-
-async function* streamMock() {
-  const content = mock.choices[0].message.content;
-  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);
-}
-
-function wrapChunk(str) {
-  return {
-    choices: [
-      {
-        delta: {
-          content: str,
-        },
-      },
-    ],
-  };
-}
-
-function setResponse(data) {
-  mock = data;
-}
-
-MockOpenAiClient.setResponse = setResponse;
-
-module.exports = MockOpenAiClient;

package/dist/cjs/util.js

@@ -1,62 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.loadTemplate = loadTemplate;
-exports.loadTemplates = loadTemplates;
-exports.transformResponse = transformResponse;
-var _promises = _interopRequireDefault(require("fs/promises"));
-var _path = _interopRequireDefault(require("path"));
-var _glob = require("glob");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const CODE_REG = /^```\w*$(.+)```/ms;
-const JSON_REG = /([{[].+[}\]])/s;
-async function loadTemplates(dir) {
-  const result = {};
-  const files = await (0, _glob.glob)(_path.default.join(dir, '*.md'));
-  if (!files.length) {
-    throw new Error(`No templates found in: ${dir}.`);
-  }
-  for (let file of files) {
-    const base = _path.default.basename(file, '.md');
-    result[base] = await loadTemplate(file);
-  }
-  return result;
-}
-async function loadTemplate(file) {
-  return await _promises.default.readFile(file, 'utf-8');
-}
-function transformResponse(options) {
-  const {
-    output = 'text',
-    messages,
-    message
-  } = options;
-  const content = message.content || message.text;
-  if (output === 'text') {
-    return content;
-  } else if (output === 'messages') {
-    return [...messages, message];
-  } else if (output === 'json') {
-    return parseJson(content);
-  } else if (output === 'code') {
-    return parseCode(content);
-  } else {
-    throw new Error(`No output type provided.`);
-  }
-}
-function parseJson(content) {
-  try {
-    return JSON.parse(content.match(JSON_REG)[0]);
-  } catch (error) {
-    throw new Error(`Unable to derive JSON from response:\n\n${content}`);
-  }
-}
-function parseCode(content) {
-  try {
-    return content.match(CODE_REG)[1].trim();
-  } catch (error) {
-    throw new Error(`Unable to derive code from response:\n\n${content}`);
-  }
-}

package/src/BaseClient.js

@@ -1,195 +0,0 @@
-import Mustache from 'mustache';
-
-import { loadTemplates, loadTemplate } from './util.js';
-
-const MESSAGES_REG = /(?:^|\n)-{3,}\s*(\w+)\s*-{3,}(.*?)(?=\n-{3,}|$)/gs;
-
-export default class BaseClient {
-  constructor(options) {
-    this.options = options;
-    this.templates = null;
-  }
-
-  /**
-   * Interpolates vars into the provided template and
-   * runs the chat completion. The "output" option may
-   * be omitted and will default to `"text"`.
-   * {@link https://github.com/bedrockio/ai?tab=readme-ov-file#bedrockioai Documentation}
-   *
-   * @param {object} options
-   * @param {string} options.model - The model to use.
-   * @param {"raw" | "text" | "json" | "messages"} [options.output] - The output to use.
-   * @param {Object.<string, any>} [options.other] - Additional props
-   *             will be interpolated in the template.
-   */
-  async prompt(options) {
-    options = {
-      ...this.options,
-      ...options,
-    };
-
-    const messages = await this.getMessages(options);
-    return await this.getCompletion({
-      ...options,
-      messages,
-    });
-  }
-
-  /**
-   * Streams the prompt response.
-   * @returns {AsyncIterator}
-   */
-  async *stream(options) {
-    const stream = await this.getStream(options);
-
-    let started = false;
-
-    // @ts-ignore
-    for await (const chunk of stream) {
-      const resolved = this.getStreamedChunk(chunk, started);
-      started = true;
-
-      // @ts-ignore
-      if (resolved) {
-        yield resolved;
-      }
-    }
-  }
-
-  async getMessages(options) {
-    const { text } = options;
-    const template = await this.resolveTemplate(options);
-
-    if (template) {
-      const raw = render(template, options);
-
-      const messages = [];
-      for (let match of raw.matchAll(MESSAGES_REG)) {
-        const [, role, content] = match;
-        messages.push({
-          role: role.toLowerCase(),
-          content: content.trim(),
-        });
-      }
-
-      if (!messages.length) {
-        messages.push({
-          role: 'user',
-          content: raw.trim(),
-        });
-      }
-
-      return messages;
-    } else if (text) {
-      return [
-        {
-          role: 'user',
-          content: text,
-        },
-      ];
-    } else {
-      throw new Error('No input provided.');
-    }
-  }
-
-  async buildTemplate(options) {
-    const template = await this.resolveTemplate(options);
-    return render(template, options);
-  }
-
-  async loadTemplates() {
-    const { templates } = this.options;
-    this.templates ||= await loadTemplates(templates);
-  }
-
-  async resolveTemplate(options) {
-    const { template, file } = options;
-    if (template) {
-      return template;
-    } else if (file?.endsWith('.md')) {
-      return await loadTemplate(file);
-    } else if (file) {
-      await this.loadTemplates();
-      return this.templates[file];
-    }
-  }
-
-  async getStream(options) {
-    return await this.prompt({
-      ...options,
-      output: 'raw',
-      stream: true,
-    });
-  }
-
-  getCompletion(options) {
-    void options;
-    new Error('Method not implemented.');
-  }
-
-  getStreamedChunk(chunk, started) {
-    void chunk;
-    void started;
-    new Error('Method not implemented.');
-  }
-}
-
-function render(template, options) {
-  let params = {
-    ...options,
-    ...options.params,
-  };
-
-  params = mapObjects(params);
-  params = wrapProxy(params);
-  return Mustache.render(template, params);
-}
-
-// 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/src/anthropic.js

@@ -1,97 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-
-import BaseClient from './BaseClient.js';
-import { transformResponse } from './util.js';
-
-const MODELS_URL = 'https://docs.anthropic.com/en/docs/about-claude/models';
-const DEFAULT_MODEL = 'claude-3-5-sonnet-latest';
-
-export class AnthropicClient extends BaseClient {
-  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 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 response = await client.messages.create({
-      max_tokens,
-      messages: user,
-      system,
-      model,
-      stream,
-    });
-
-    if (output === 'raw') {
-      return response;
-    }
-
-    // @ts-ignore
-    const message = response.content[0];
-
-    return 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';
-    }
-
-    if (type) {
-      return {
-        type,
-        text: chunk.delta?.text || '',
-      };
-    }
-  }
-}
-
-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/src/google.js

@@ -1,91 +0,0 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
-
-import BaseClient from './BaseClient.js';
-import { transformResponse } from './util.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,
-    });
-
-    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 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';
-    }
-
-    if (type) {
-      return {
-        type,
-        text: candidate.content.parts[0].text || '',
-      };
-    }
-  }
-}

package/src/index.js

@@ -1,72 +0,0 @@
-import { OpenAiClient } from './openai.js';
-import { GoogleClient } from './google.js';
-import { AnthropicClient } from './anthropic.js';
-import { XAiClient } from './xai.js';
-
-export 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.');
-    }
-    return getClientForPlatform(options);
-  }
-}
-
-export 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;
-    }
-  }
-
-  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.`);
-    }
-    return client;
-  }
-}
-
-function getClientForPlatform(options) {
-  const { platform } = options;
-  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}".`);
-  }
-}