@bedrockio/ai 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.4.3
+
+- Moved to files whitelist.
+
 ## 0.4.2
 
 - Exclude keys from tarball.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bedrockio/ai",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "Bedrock wrapper for common AI chatbots.",
   "type": "module",
   "scripts": {
@@ -19,7 +19,7 @@
   "exports": {
     ".": {
       "types": "./types/index.d.ts",
-      "import": "./src/index.js",
+      "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js"
     }
   },
@@ -51,6 +51,12 @@
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   },
+  "files": [
+    "dist/**",
+    "types/**",
+    "README.md",
+    "CHANGELOG.md"
+  ],
   "volta": {
     "node": "22.20.0",
     "yarn": "1.22.22"

package/.claude/settings.local.json

@@ -1,11 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:ai-sdk.dev)",
-      "WebSearch",
-      "Bash(yarn build:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/.prettierignore

@@ -1 +0,0 @@
-test/templates

package/.prettierrc.cjs

@@ -1 +0,0 @@
-module.exports = require('@bedrockio/prettier-config');

package/__mocks__/@anthropic-ai/sdk.js

@@ -1,37 +0,0 @@
-let mock;
-let models;
-
-export default function MockAnthropicClient() {
-  return {
-    messages: {
-      create(options) {
-        if (options.stream) {
-          return streamMock();
-        } else {
-          return mock;
-        }
-      },
-    },
-    models: {
-      list() {
-        return {
-          data: models,
-        };
-      },
-    },
-  };
-}
-
-export function setResponse(data) {
-  mock = data;
-}
-
-export function setModels(data) {
-  models = data;
-}
-
-async function* streamMock() {
-  for await (let event of mock) {
-    yield event;
-  }
-}

package/__mocks__/@google/generative-ai.js

@@ -1,59 +0,0 @@
-let mock;
-
-class MockGoogleClient {
-  constructor() {
-    return {
-      getGenerativeModel() {
-        return {
-          generateContent() {
-            return mock;
-          },
-          generateContentStream() {
-            return {
-              stream: streamMock(),
-            };
-          },
-        };
-      },
-    };
-  }
-}
-
-function setResponse(data) {
-  mock = data;
-}
-
-async function* streamMock() {
-  const content = mock.response.candidates[0].content.parts[0].text;
-  const size = Math.floor(content.length / 3);
-  const one = content.slice(0, size);
-  const two = content.slice(size, 2 * size);
-  const three = content.slice(2 * size);
-  yield wrapChunk(one);
-  yield wrapChunk(two);
-  yield wrapChunk(three, true);
-}
-
-function wrapChunk(str, finish) {
-  return {
-    candidates: [
-      {
-        ...(finish && {
-          finishReason: 'STOP',
-        }),
-        content: {
-          parts: [
-            {
-              text: str,
-            },
-          ],
-        },
-      },
-    ],
-  };
-}
-
-module.exports = {
-  GoogleGenerativeAI: MockGoogleClient,
-  setResponse,
-};

package/__mocks__/openai.js

@@ -1,53 +0,0 @@
-let models;
-let responses = {};
-
-export default function MockOpenAiClient() {
-  return {
-    chat: {
-      completions: {
-        create(options) {
-          if (options.stream) {
-            return streamMock();
-          } else {
-            return responses['default'];
-          }
-        },
-      },
-    },
-    responses: {
-      create(options) {
-        const { previous_response_id = 'default' } = options;
-        if (!options.input) {
-          throw new Error('Missing parameter "input".');
-        }
-        const response = responses[previous_response_id];
-        if (options.stream) {
-          return streamMock(response);
-        } else {
-          return response;
-        }
-      },
-    },
-    models: {
-      list() {
-        return {
-          data: models,
-        };
-      },
-    },
-  };
-}
-
-export function setResponse(data, name = 'default') {
-  responses[name] = data;
-}
-
-export function setModels(data) {
-  models = data;
-}
-
-async function* streamMock(response) {
-  for await (let event of response) {
-    yield event;
-  }
-}

package/eslint.config.js

@@ -1,2 +0,0 @@
-import { nodeImports, recommended } from '@bedrockio/eslint-plugin';
-export default [recommended, nodeImports];

package/src/BaseClient.js

@@ -1,288 +0,0 @@
-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/src/anthropic.js

@@ -1,137 +0,0 @@
-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/src/google.js

@@ -1,88 +0,0 @@
-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/src/index.js

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

package/src/openai.js

@@ -1,134 +0,0 @@
-import OpenAI from 'openai';
-
-import BaseClient from './BaseClient.js';
-
-export class OpenAiClient extends BaseClient {
-  static DEFAULT_MODEL = 'gpt-5-nano';
-
-  constructor(options) {
-    super(options);
-    this.client = new OpenAI(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 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,
-      };
-    }
-  }
-}

package/src/utils/code.js

@@ -1,9 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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,12 +0,0 @@
-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

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

package/tsconfig.esm.json

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

package/tsconfig.types.json

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

package/vitest.config.js

@@ -1,10 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    reporters: 'verbose',
-    environment: 'node',
-    include: ['test/**/*.test.*'],
-    testTimeout: 60000,
-  },
-});