@bedrockio/ai 0.3.0 → 0.4.4

package/dist/cjs/utils/code.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCode = parseCode;
+const CODE_REG = /^```\w*(.+)```/s;
+function parseCode(content) {
+    const match = content.trim().match(CODE_REG);
+    if (match) {
+        content = match[1].trim();
+    }
+    return content;
+}

package/dist/cjs/utils/json.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMessageExtractor = createMessageExtractor;
+const partial_json_1 = require("partial-json");
+function createMessageExtractor(keys) {
+    let buffer = '';
+    const extractors = keys.map((key) => {
+        return createExtractor(key);
+    });
+    return (delta) => {
+        buffer += delta;
+        return extractors
+            .map((extractor) => {
+            return extractor(buffer);
+        })
+            .filter((extracted) => {
+            return extracted;
+        });
+    };
+}
+function createExtractor(key) {
+    let lastText = '';
+    let done = false;
+    return (buffer) => {
+        if (done) {
+            return;
+        }
+        const text = extractText(buffer, key);
+        if (!text) {
+            return;
+        }
+        // Don't finish while the buffer has whitespace as it
+        // may be in the middle of trying to extract.
+        if (text === lastText && !buffer.endsWith(' ')) {
+            done = true;
+        }
+        const delta = text.slice(lastText.length);
+        lastText = text;
+        return {
+            key,
+            text,
+            delta,
+            done,
+        };
+    };
+}
+function extractText(input, key) {
+    if (!input) {
+        return;
+    }
+    const parsed = (0, partial_json_1.parse)(input, partial_json_1.STR | partial_json_1.OBJ);
+    return parsed?.[key] || '';
+}

package/dist/cjs/utils/templates.js

@@ -0,0 +1,83 @@
+"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/cjs/xai.js

@@ -1,23 +1,14 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.XAiClient = void 0;
-var _openai = require("./openai.js");
-const DEFAULT_MODEL = 'grok-2-1212';
-class XAiClient extends _openai.OpenAiClient {
-  constructor(options) {
-    super({
-      ...options,
-      baseURL: 'https://api.x.ai/v1'
-    });
-  }
-  async getCompletion(options) {
-    return super.getCompletion({
-      model: DEFAULT_MODEL,
-      ...options
-    });
-  }
+const openai_js_1 = require("./openai.js");
+class XAiClient extends openai_js_1.OpenAiClient {
+    static DEFAULT_MODEL = 'grok-4-fast';
+    constructor(options) {
+        super({
+            ...options,
+            baseURL: 'https://api.x.ai/v1',
+        });
+    }
 }
-exports.XAiClient = XAiClient;
+exports.XAiClient = XAiClient;

package/dist/esm/BaseClient.js

@@ -0,0 +1,243 @@
+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/dist/esm/anthropic.js

@@ -0,0 +1,116 @@
+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/dist/esm/google.js

@@ -0,0 +1,75 @@
+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/dist/esm/index.js

@@ -0,0 +1,25 @@
+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}".`);
+    }
+}