@bedrockio/ai 0.2.1 → 0.4.2

package/src/google.js

@@ -1,7 +1,6 @@
 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';
 
@@ -29,8 +28,11 @@ export class GoogleClient extends BaseClient {
     const { model = DEFAULT_MODEL, output = 'text', stream = false } = options;
     const { client } = this;
 
-    const generator = client.getGenerativeModel({ model });
+    const generator = client.getGenerativeModel({
+      model,
+    });
 
+    // @ts-ignore
     const messages = await this.getMessages(options);
 
     const prompts = messages.map((message) => {
@@ -44,11 +46,6 @@ export class GoogleClient extends BaseClient {
     } else {
       response = await generator.generateContent(prompts);
     }
-    // const response = await client.chat.completions.create({
-    //   model,
-    //   messages,
-    //   stream,
-    // });
 
     if (output === 'raw') {
       return response;
@@ -60,13 +57,10 @@ export class GoogleClient extends BaseClient {
     });
     const [message] = parts;
 
-    return transformResponse({
-      ...options,
-      messages,
-      message,
-    });
+    return message;
   }
   async getStream(options) {
+    // @ts-ignore
     const response = await super.getStream(options);
     // @ts-ignore
     return response.stream;

package/src/index.js

@@ -1,20 +1,24 @@
-import { OpenAiClient } from './openai.js';
-import { GoogleClient } from './google.js';
 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.');
+  }
 
-export class Client {
-  constructor(options) {
-    const { platform, ...rest } = options;
-    if (platform === 'openai' || platform === 'gpt') {
-      return new OpenAiClient(rest);
-    } else if (platform === 'google' || platform === 'gemini') {
-      return new GoogleClient(rest);
-    } else if (platform === 'anthropic' || platform === 'claude') {
-      return new AnthropicClient(rest);
-    } else if (platform) {
-      throw new Error(`Unknown platform "${platform}".`);
-    } else {
-      throw new Error('Platform required.');
-    }
+  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}".`);
   }
 }

package/src/openai.js

@@ -1,16 +1,13 @@
 import OpenAI from 'openai';
 
 import BaseClient from './BaseClient.js';
-import { transformResponse } from './util.js';
-
-const DEFAULT_MODEL = 'gpt-4o';
 
 export class OpenAiClient extends BaseClient {
+  static DEFAULT_MODEL = 'gpt-5-nano';
+
   constructor(options) {
     super(options);
-    this.client = new OpenAI({
-      ...options,
-    });
+    this.client = new OpenAI(options);
   }
 
   /**
@@ -22,46 +19,115 @@ export class OpenAiClient extends BaseClient {
     return data.map((o) => o.id);
   }
 
-  async getCompletion(options) {
-    const { model = DEFAULT_MODEL, output = 'text', stream = false } = options;
-    const { client } = this;
+  async runPrompt(options) {
+    const {
+      input,
+      model,
+      tools,
+      verbosity,
+      temperature,
+      instructions,
+      prevResponseId,
+      stream = false,
+    } = options;
 
-    const messages = await this.getMessages(options);
-    const response = await client.chat.completions.create({
+    const params = {
       model,
-      messages,
+      input,
+      tools,
       stream,
-    });
+      temperature,
+      instructions,
+      previous_response_id: prevResponseId,
 
-    if (output === 'raw') {
-      return response;
-    }
+      text: {
+        format: this.getOutputFormat(options),
+        verbosity,
+      },
+    };
 
-    const { message } = response.choices[0];
+    this.debug('Params:', params);
 
-    return transformResponse({
+    // @ts-ignore
+    return await this.client.responses.create(params);
+  }
+
+  async runStream(options) {
+    return await this.runPrompt({
       ...options,
-      messages,
-      message,
+      stream: true,
     });
   }
 
-  getStreamedChunk(chunk, started) {
-    const [choice] = chunk.choices;
+  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
 
-    let type;
-    if (!started) {
-      type = 'start';
-    } else if (choice.finish_reason === 'stop') {
-      type = 'stop';
+  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 {
-      type = 'chunk';
+      return {
+        type: 'text',
+      };
     }
+  }
 
-    if (type) {
+  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,
-        text: choice.delta.content || '',
+        type: 'done',
+        text: event.text,
       };
     }
   }

package/src/utils/code.js

@@ -0,0 +1,9 @@
+const CODE_REG = /^```\w*(.+)```/s;
+
+export function parseCode(content) {
+  const match = content.trim().match(CODE_REG);
+  if (match) {
+    content = match[1].trim();
+  }
+  return content;
+}

package/src/utils/json.js

@@ -0,0 +1,58 @@
+import { OBJ, STR, parse } from 'partial-json';
+
+export 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 = parse(input, STR | OBJ);
+  return parsed?.[key] || '';
+}

package/src/utils/templates.js

@@ -0,0 +1,87 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+import { glob } from 'glob';
+import Mustache from 'mustache';
+
+export async function loadTemplates(dir) {
+  const result = {};
+  const files = await glob(path.join(dir, '*.md'));
+
+  if (!files.length) {
+    throw new Error(`No templates found in: ${dir}.`);
+  }
+
+  for (let file of files) {
+    const base = path.basename(file, '.md');
+    result[base] = await loadTemplate(file);
+  }
+
+  return result;
+}
+
+export function renderTemplate(template, options) {
+  let params = {
+    ...options,
+    ...options.params,
+  };
+
+  params = mapObjects(params);
+  params = wrapProxy(params);
+  return Mustache.render(template, params);
+}
+
+// Utils
+
+async function loadTemplate(file) {
+  return await fs.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/src/xai.js

@@ -0,0 +1,12 @@
+import { OpenAiClient } from './openai.js';
+
+export class XAiClient extends OpenAiClient {
+  static DEFAULT_MODEL = 'grok-4-fast';
+
+  constructor(options) {
+    super({
+      ...options,
+      baseURL: 'https://api.x.ai/v1',
+    });
+  }
+}

package/tsconfig.cjs.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "outDir": "dist/cjs"
+  }
+}

package/tsconfig.esm.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "outDir": "dist/esm",
+    "useDefineForClassFields": true
+  }
+}

package/tsconfig.types.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "types",
+    "declaration": true,
+    "declarationMap": true,
+    "emitDeclarationOnly": true,
+  }
+}

package/types/BaseClient.d.ts

@@ -3,37 +3,79 @@ export default class BaseClient {
     options: any;
     templates: any;
     /**
-     * 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}
+     * Interpolates vars into the provided template as instructions and runs the
+     * prompt.
      *
-     * @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.
-     */
-    prompt(options: {
-        model: string;
-        output?: "raw" | "text" | "json" | "messages";
-        other?: {
-            [x: string]: any;
-        };
-    }): Promise<void>;
+     * @param {PromptOptions} options
+     */
+    prompt(options: PromptOptions): Promise<any>;
     /**
      * Streams the prompt response.
+     *
+     * @param {PromptOptions & StreamOptions} options
      * @returns {AsyncIterator}
      */
-    stream(options: any): AsyncIterator<any, any, any>;
-    getMessages(options: any): Promise<{
-        role: any;
-        content: any;
-    }[]>;
-    loadTemplates(): Promise<void>;
+    stream(options: PromptOptions & StreamOptions): AsyncIterator<any, any, any>;
+    buildTemplate(options: any): Promise<any>;
+    runPrompt(options: any): void;
+    runStream(options: any): void;
+    getTextResponse(response: any): void;
+    /**
+     * @returns {Object}
+     */
+    getStructuredResponse(response: any): any;
+    /**
+     * @returns {Object}
+     */
+    getMessagesResponse(input: any, response: any): any;
+    /**
+     * @returns {Object}
+     */
+    normalizeStreamEvent(event: any): any;
+    normalizeOptions(options: any): Promise<any>;
+    normalizeInput(options: any): any;
+    normalizeSchema(options: any): any;
+    getMessageExtractor(options: any): (event: any) => any;
+    debug(message: any, arg: any): void;
+    resolveInstructions(options: any): Promise<any>;
     resolveTemplate(options: any): Promise<any>;
-    getStream(options: any): Promise<void>;
-    getCompletion(options: any): void;
-    getStreamedChunk(chunk: any, started: any): void;
+    loadTemplates(): Promise<void>;
 }
+export type PromptOptions = {
+    /**
+     * - Input to use.
+     */
+    input: string | PromptMessage[];
+    /**
+     * - The model to use.
+     */
+    model?: string;
+    /**
+     * - Stream response.
+     */
+    stream: boolean;
+    /**
+     * - A JSON schema compatible object that defines the output shape.
+     */
+    schema?: any;
+    /**
+     * - The return value type.
+     */
+    output?: "raw" | "text" | "json" | "messages";
+    /**
+     * - Params to be interpolated into the template.
+     *    May also be passed as additional props to options.
+     */
+    params?: any;
+};
+export type StreamOptions = {
+    /**
+     * - Key in JSON response to extract a message stream from.
+     */
+    extractMessages?: string;
+};
+export type PromptMessage = {
+    role: "system" | "user" | "assistant";
+    content: string;
+};
 //# sourceMappingURL=BaseClient.d.ts.map

package/types/BaseClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../src/BaseClient.js"],"names":[],"mappings":"AAMA;IACE,0BAGC;IAFC,aAAsB;IACtB,eAAqB;IAGvB;;;;;;;;;;;OAWG;IACH,gBALG;QAAwB,KAAK,EAArB,MAAM;QACyC,MAAM,GAArD,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU;QACL,KAAK,GAApC;gBAAQ,MAAM,GAAE,GAAG;SAAC;KAE9B,iBAYA;IAED;;;OAGG;IACH,mDAeC;IAED;;;SAqBC;IAED,+BAGC;IAED,4CAcC;IAED,uCAMC;IAED,kCAGC;IAED,iDAIC;CACF"}
+{"version":3,"file":"BaseClient.d.ts","sourceRoot":"","sources":["../src/BaseClient.js"],"names":[],"mappings":"AAIA;IACE,0BAOC;IANC,aAIC;IACD,eAAqB;IAKvB;;;;;OAKG;IACH,gBAFW,aAAa,gBAuCvB;IAED;;;;;OAKG;IACH,gBAHW,aAAa,GAAG,aAAa,gCAsDvC;IAED,0CAGC;IAID,8BAGC;IAED,8BAGC;IAED,qCAGC;IAED;;OAEG;IACH,0CAGC;IAED;;OAEG;IACH,oDAGC;IAED;;OAEG;IACH,sCAGC;IAID,6CAaC;IAED,kCAiBC;IAED,mCAuBC;IAED,uDAWC;IAED,oCAMC;IAED,gDAKC;IAED,4CAIC;IAED,+BAGC;CACF;;;;;WAIa,MAAM,GAAC,aAAa,EAAE;;;;YACtB,MAAM;;;;YACN,OAAO;;;;;;;;aAEP,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU;;;;;;;;;;;sBAOpC,MAAM;;;UAKN,QAAQ,GAAG,MAAM,GAAG,WAAW;aAC/B,MAAM"}

package/types/anthropic.d.ts

@@ -1,15 +1,39 @@
 export class AnthropicClient extends BaseClient {
+    static DEFAULT_MODEL: string;
     client: Anthropic;
     /**
      * Lists available models.
      * {@link https://docs.anthropic.com/en/docs/about-claude/models Documentation}
      */
     models(): Promise<string[]>;
-    getCompletion(options: any): Promise<any>;
-    getStreamedChunk(chunk: any): {
+    runPrompt(options: any): Promise<Anthropic.Messages.Message & {
+        _request_id?: string | null;
+    } & import("@anthropic-ai/sdk/core/streaming.js").Stream<Anthropic.Messages.RawMessageStreamEvent>>;
+    runStream(options: any): Promise<Anthropic.Messages.Message & {
+        _request_id?: string | null;
+    } & import("@anthropic-ai/sdk/core/streaming.js").Stream<Anthropic.Messages.RawMessageStreamEvent>>;
+    getTextResponse(response: any): any;
+    getMessagesResponse(input: any, response: any): {
+        messages: any[];
+    };
+    normalizeStreamEvent(event: any): {
+        type: string;
+        text?: undefined;
+    } | {
         type: string;
         text: any;
     };
+    getSchemaOptions(options: any): {
+        tools: {
+            name: string;
+            description: string;
+            input_schema: any;
+        }[];
+        tool_choice: {
+            type: string;
+            name: string;
+        };
+    };
 }
 import BaseClient from './BaseClient.js';
 import Anthropic from '@anthropic-ai/sdk';

package/types/anthropic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../src/anthropic.js"],"names":[],"mappings":"AAQA;IAGI,kBAEE;IAGJ;;;OAGG;IACH,4BAGC;IAED,0CAsCC;IAED;;;MAiBC;CACF;uBAjFsB,iBAAiB;sBAFlB,mBAAmB"}
+{"version":3,"file":"anthropic.d.ts","sourceRoot":"","sources":["../src/anthropic.js"],"names":[],"mappings":"AAMA;IACE,6BAA2C;IAIzC,kBAAoC;IAGtC;;;OAGG;IACH,4BAGC;IAED;;wGAoBC;IAED;;wGAMC;IAED,oCAKC;IASD;;MAgBC;IAED;;;;;;MAgBC;IAID;;;;;;;;;;MA8BC;CACF;uBAtIsB,iBAAiB;sBAFlB,mBAAmB"}

package/types/google.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../src/google.js"],"names":[],"mappings":"AAOA;IAII,2BAA4C;IAG9C;;;OAGG;IACH,4BAOC;IAED,0CAwCC;IACD,sCAIC;IAED;;;MAkBC;CACF;uBA3FsB,iBAAiB;mCAFL,uBAAuB"}
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../src/google.js"],"names":[],"mappings":"AAMA;IAII,2BAA4C;IAG9C;;;OAGG;IACH,4BAOC;IAED,0CAkCC;IACD,sCAKC;IAED;;;MAkBC;CACF;uBArFsB,iBAAiB;mCAFL,uBAAuB"}

package/types/index.d.ts

@@ -1,4 +1,5 @@
-export class Client {
-    constructor(options: any);
-}
+export function createClient(options?: {}): AnthropicClient | GoogleClient | OpenAiClient;
+import { AnthropicClient } from './anthropic.js';
+import { GoogleClient } from './google.js';
+import { OpenAiClient } from './openai.js';
 //# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAIA;IACE,0BAaC;CACF"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AAKA,0FAkBC;gCAvB+B,gBAAgB;6BACnB,aAAa;6BACb,aAAa"}