@bedrockio/ai 0.2.1 → 0.4.2

package/dist/cjs/google.js

@@ -1,94 +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);
     }
-    // const response = await client.chat.completions.create({
-    //   model,
-    //   messages,
-    //   stream,
-    // });
-
-    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,29 +1,28 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Client = void 0;
-var _openai = require("./openai.js");
-var _google = require("./google.js");
-var _anthropic = require("./anthropic.js");
-class Client {
-  constructor(options) {
-    const {
-      platform,
-      ...rest
-    } = options;
+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.');
+    }
     if (platform === 'openai' || platform === 'gpt') {
-      return new _openai.OpenAiClient(rest);
-    } else if (platform === 'google' || platform === 'gemini') {
-      return new _google.GoogleClient(rest);
-    } else if (platform === 'anthropic' || platform === 'claude') {
-      return new _anthropic.AnthropicClient(rest);
-    } else if (platform) {
-      throw new Error(`Unknown platform "${platform}".`);
-    } else {
-      throw new Error('Platform required.');
+        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);
+    }
+    else if (platform) {
+        throw new Error(`Unknown platform "${platform}".`);
     }
-  }
 }
-exports.Client = Client;

package/dist/cjs/openai.js

@@ -1,75 +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';
-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
-    });
-    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" }

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XAiClient = void 0;
+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;