@bedrockio/ai 0.3.0 → 0.4.2

package/dist/cjs/BaseClient.js

@@ -1,186 +1,246 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _mustache = _interopRequireDefault(require("mustache"));
-var _util = require("./util.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-const MESSAGES_REG = /(?:^|\n)-{3,}\s*(\w+)\s*-{3,}(.*?)(?=\n-{3,}|$)/gs;
+Object.defineProperty(exports, "__esModule", { value: true });
+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 = 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 (0, _util.loadTemplates)(templates);
-  }
-  async resolveTemplate(options) {
-    const {
-      template,
-      file
-    } = options;
-    if (template) {
-      return template;
-    } else if (file?.endsWith('.md')) {
-      return await (0, _util.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.');
-  }
+    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((0, code_js_1.parseCode)(this.getTextResponse(response)));
+        }
+        else {
+            result = (0, code_js_1.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 (0, templates_js_1.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 = (0, json_js_1.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 (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;
-function render(template, options) {
-  let params = {
-    ...options,
-    ...options.params
-  };
-  params = mapObjects(params);
-  params = wrapProxy(params);
-  return _mustache.default.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()}}}}`;
-      }
-    }
-  });
-}
+/**
+ * @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/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
-  };
-}