@bedrockio/ai 0.3.0 → 0.4.2

package/src/anthropic.js

@@ -1,17 +1,15 @@
 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';
+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,
-    });
+    this.client = new Anthropic(options);
   }
 
   /**
@@ -23,75 +21,117 @@ export class AnthropicClient extends BaseClient {
     return data.map((o) => o.id);
   }
 
-  async getCompletion(options) {
+  async runPrompt(options) {
     const {
-      model = DEFAULT_MODEL,
-      max_tokens = 2048,
-      output = 'text',
+      input,
+      model,
+      temperature,
+      instructions,
       stream = false,
-      messages,
+      tokens = DEFAULT_TOKENS,
     } = 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,
+    // @ts-ignore
+    return await this.client.messages.create({
       model,
       stream,
+      temperature,
+      max_tokens: tokens,
+      system: instructions,
+      ...this.getSchemaOptions(options),
+      messages: input,
     });
+  }
 
-    if (output === 'raw') {
-      return response;
-    }
+  async runStream(options) {
+    return await this.runPrompt({
+      ...options,
+      output: 'raw',
+      stream: true,
+    });
+  }
 
-    // @ts-ignore
-    const message = response.content[0];
+  getTextResponse(response) {
+    const textBlock = response.content.find((block) => {
+      return block.type === 'text';
+    });
+    return textBlock?.text || null;
+  }
 
-    return transformResponse({
-      ...options,
-      messages,
-      message,
+  getStructuredResponse(response) {
+    const toolBlock = response.content.find((block) => {
+      return block.type === 'tool_use';
     });
+    return toolBlock?.input || null;
   }
 
-  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';
-    }
+  getMessagesResponse(input, response) {
+    return {
+      messages: [
+        ...input,
+        ...response.content
+          .filter((item) => {
+            return item.type === 'text';
+          })
+          .map((item) => {
+            return {
+              role: 'assistant',
+              content: item.text,
+            };
+          }),
+      ],
+    };
+  }
 
-    if (type) {
+  normalizeStreamEvent(event) {
+    let { type } = event;
+    if (type === 'content_block_start') {
+      return {
+        type: 'start',
+      };
+    } else if (type === 'content_block_stop') {
       return {
-        type,
-        text: chunk.delta?.text || '',
+        type: 'stop',
+      };
+    } else if (type === 'content_block_delta') {
+      return {
+        type: 'delta',
+        text: event.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);
+  // 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',
+        },
+      };
     }
   }
-  return { system: system.join('\n'), user };
 }

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';
 
@@ -33,6 +32,7 @@ export class GoogleClient extends BaseClient {
       model,
     });
 
+    // @ts-ignore
     const messages = await this.getMessages(options);
 
     const prompts = messages.map((message) => {
@@ -57,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,63 +1,15 @@
-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 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);
-  }
+export function createClient(options = {}) {
+  const { platform } = options;
 
-  getClient(options) {
-    const { platform } = options;
-    const client = this.clients[platform];
-    if (!client) {
-      throw new Error(`Platform "${platform}" not found.`);
-    }
-    return client;
+  if (!platform) {
+    throw new Error('No platform specified.');
   }
-}
 
-function getClientForPlatform(options) {
-  const { platform } = options;
   if (platform === 'openai' || platform === 'gpt') {
     return new OpenAiClient(options);
   } else if (platform === 'google' || platform === 'gemini') {

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-mini';
 
 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,49 +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,
-      response_format: {
-        type: output === 'json' ? 'json_object' : 'text',
+      temperature,
+      instructions,
+      previous_response_id: prevResponseId,
+
+      text: {
+        format: this.getOutputFormat(options),
+        verbosity,
       },
-    });
+    };
 
-    if (output === 'raw') {
-      return response;
-    }
+    this.debug('Params:', params);
 
-    const { message } = response.choices[0];
+    // @ts-ignore
+    return await this.client.responses.create(params);
+  }
 
-    return transformResponse({
+  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

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

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,
+  }
+}