automify 0.1.0

package/src/lib/errors.js

@@ -0,0 +1,24 @@
+export class AutomifyError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "AutomifyError";
+    if (options.cause) this.cause = options.cause;
+  }
+}
+
+export class SafetyCheckError extends AutomifyError {
+  constructor(checks, action) {
+    super("Computer-use returned pending safety checks that were not acknowledged.");
+    this.name = "SafetyCheckError";
+    this.checks = checks;
+    this.action = action;
+  }
+}
+
+export class MaxStepsExceededError extends AutomifyError {
+  constructor(maxSteps) {
+    super(`Computer-use exceeded the configured maxSteps limit of ${maxSteps}.`);
+    this.name = "MaxStepsExceededError";
+    this.maxSteps = maxSteps;
+  }
+}

package/src/lib/file-data.js

@@ -0,0 +1,140 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+
+import { AutomifyError } from "./errors.js";
+
+export async function fileToData(file, options = {}) {
+  const descriptor = normalizeFileDescriptor(file);
+  const path = resolve(descriptor.path);
+  const info = await stat(path);
+  if (!info.isFile()) {
+    throw new AutomifyError(`fileToData expected a file: ${path}`);
+  }
+
+  const mediaType = descriptor.mediaType ?? options.mediaType ?? mediaTypeForPath(path);
+  const format = descriptor.format ?? options.format ?? "text";
+  const entry = {
+    name: descriptor.name ?? basename(path),
+    path,
+    mediaType,
+    size: info.size
+  };
+
+  if (format === "metadata") return entry;
+
+  const buffer = await readFile(path);
+  if (format === "base64") {
+    return { ...entry, base64: buffer.toString("base64") };
+  }
+  if (format === "data_url" || format === "dataUrl") {
+    return { ...entry, dataUrl: `data:${mediaType};base64,${buffer.toString("base64")}` };
+  }
+  if (format === "buffer") {
+    return { ...entry, buffer };
+  }
+
+  return { ...entry, text: buffer.toString(descriptor.encoding ?? options.encoding ?? "utf8") };
+}
+
+export async function filesToData(files, options = {}) {
+  const list = Array.isArray(files) ? files : [files];
+  return Promise.all(list.map((file) => fileToData(file, options)));
+}
+
+export async function fileToEvaluate(file, options = {}) {
+  const descriptor = normalizeFileDescriptor(file);
+  const path = resolve(descriptor.path);
+  const info = await stat(path);
+  if (!info.isFile()) {
+    throw new AutomifyError(`fileToEvaluate expected a file: ${path}`);
+  }
+
+  const name = descriptor.name ?? basename(path);
+  const mediaType = descriptor.mediaType ?? options.mediaType ?? mediaTypeForPath(path);
+  const detail = descriptor.detail ?? options.detail;
+
+  if (mediaType.startsWith("image/")) {
+    const buffer = await readFile(path);
+    return {
+      type: "input_image",
+      image_url: `data:${mediaType};base64,${buffer.toString("base64")}`,
+      ...(detail ? { detail } : {})
+    };
+  }
+
+  if (isTextMediaType(mediaType)) {
+    const maxBytes = positiveInteger(descriptor.maxBytes ?? options.maxBytes) ?? 200_000;
+    const buffer = await readFile(path);
+    const truncated = buffer.byteLength > maxBytes;
+    const text = buffer.subarray(0, maxBytes).toString(descriptor.encoding ?? options.encoding ?? "utf8");
+    return {
+      type: "input_text",
+      text: [
+        `File for evaluation: ${name}`,
+        `Path: ${path}`,
+        `Media type: ${mediaType}`,
+        truncated ? `Content truncated to ${maxBytes} bytes from ${buffer.byteLength} bytes.` : null,
+        "",
+        text
+      ].filter((part) => part != null).join("\n")
+    };
+  }
+
+  return {
+    type: "input_text",
+    text: [
+      `File for evaluation: ${name}`,
+      `Path: ${path}`,
+      `Media type: ${mediaType}`,
+      `Size: ${info.size} bytes`,
+      "This file type is represented as metadata only."
+    ].join("\n")
+  };
+}
+
+export async function filesToEvaluate(files, options = {}) {
+  const list = Array.isArray(files) ? files : [files];
+  return Promise.all(list.map((file) => fileToEvaluate(file, options)));
+}
+
+function normalizeFileDescriptor(file) {
+  if (typeof file === "string") return { path: file };
+  if (file && typeof file === "object" && typeof file.path === "string") return file;
+  throw new AutomifyError("fileToData files must be paths or objects with a path.");
+}
+
+function mediaTypeForPath(path) {
+  const ext = extname(path).toLowerCase();
+  const types = {
+    ".csv": "text/csv",
+    ".gif": "image/gif",
+    ".html": "text/html",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".json": "application/json",
+    ".md": "text/markdown",
+    ".pdf": "application/pdf",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".txt": "text/plain",
+    ".webp": "image/webp",
+    ".xml": "application/xml",
+    ".yaml": "application/yaml",
+    ".yml": "application/yaml"
+  };
+  return types[ext] ?? "application/octet-stream";
+}
+
+function isTextMediaType(mediaType) {
+  return mediaType.startsWith("text/") || [
+    "application/json",
+    "application/xml",
+    "application/yaml"
+  ].includes(mediaType);
+}
+
+function positiveInteger(value) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return null;
+  return Math.floor(number);
+}

package/src/lib/init.js

@@ -0,0 +1,217 @@
+import { createAutomify } from "./automify.js";
+import { createBrowserAutomify, withBrowserAutomify } from "./browser-automify.js";
+import { createCliAutomify } from "./cli-automify.js";
+import { createDockerCliAutomify } from "./docker-cli-automify.js";
+import {
+  createComputerAutomify,
+  createDockerComputerAutomify,
+  createLocalComputerAutomify
+} from "./computer-automify.js";
+import { createAnthropicModelAdapter } from "./anthropic-model-adapter.js";
+import { AutomifyError } from "./errors.js";
+import { createModelAdapter } from "./model-adapter.js";
+import { OpenAIResponsesClient } from "./openai-responses-client.js";
+
+const ANTHROPIC_COMPUTER_SCREENSHOT_MAX_WIDTH = 1280;
+const ANTHROPIC_COMPUTER_SCREENSHOT_MAX_HEIGHT = 800;
+
+export function initAutomify(options = {}) {
+  const provider = normalizeProvider(options);
+  const client = createClient(provider);
+  const limits = options.limits ?? {};
+  const safety = options.safety ?? {};
+  const hooks = options.hooks ?? {};
+  const screenshots = options.screenshots ?? {};
+  const screenshot = options.screenshot ?? {};
+  const providerScreenshotDefaults = screenshotDefaultsForProvider(provider);
+  const defaults = {
+    model: provider.model,
+    maxSteps: options.maxSteps ?? limits.steps ?? limits.maxSteps,
+    requestOptions: options.requestOptions,
+    reasoning: options.reasoning,
+    safetyIdentifier: options.safetyIdentifier ?? safety.identifier ?? safety.safetyIdentifier,
+    allowedDomains: options.allowedDomains ?? safety.domains ?? safety.allowedDomains,
+    onStep: options.onStep ?? hooks.step ?? hooks.onStep,
+    onRequest: options.onRequest,
+    onResponse: options.onResponse,
+    onComplete: options.onComplete ?? hooks.complete ?? hooks.onComplete,
+    redactScreenshot: options.redactScreenshot ?? screenshot.redact ?? screenshot.redactScreenshot,
+    screenshotDetail: options.screenshotDetail ?? screenshot.detail,
+    screenshotMaxWidth:
+      options.screenshotMaxWidth ??
+      screenshot.maxWidth ??
+      screenshot.screenshotMaxWidth ??
+      providerScreenshotDefaults.maxWidth,
+    screenshotMaxHeight:
+      options.screenshotMaxHeight ??
+      screenshot.maxHeight ??
+      screenshot.screenshotMaxHeight ??
+      providerScreenshotDefaults.maxHeight,
+    screenshotResize: options.screenshotResize ?? screenshot.resize ?? screenshot.screenshotResize,
+    initialScreenshot: options.initialScreenshot ?? screenshots.initial,
+    finalScreenshot: options.finalScreenshot ?? screenshots.final,
+    actionScreenshots: options.actionScreenshots ?? screenshots.actions ?? screenshots.actionScreenshots,
+    trace: options.trace,
+    silent: options.silent,
+    debug: options.debug ?? false
+  };
+  const computerDefaults = {
+    ...defaults,
+    model: options.computerModel ?? provider.computerModel ?? provider.model
+  };
+
+  return {
+    client,
+
+    browser(browserOptions = {}) {
+      return createBrowserAutomify({
+        ...computerDefaults,
+        ...browserOptions,
+        client
+      });
+    },
+
+    withBrowser(browserOptions = {}, run) {
+      return withBrowserAutomify(
+        {
+          ...computerDefaults,
+          ...browserOptions,
+          client
+        },
+        run
+      );
+    },
+
+    cli(cliOptions = {}) {
+      return createCliAutomify({
+        ...defaults,
+        ...cliOptions,
+        client
+      });
+    },
+
+    dockerCli(cliOptions = {}) {
+      return createDockerCliAutomify({
+        ...defaults,
+        ...cliOptions,
+        client
+      });
+    },
+
+    dockerComputer(computerOptions = {}) {
+      return createDockerComputerAutomify({
+        ...computerDefaults,
+        ...computerOptions,
+        client
+      });
+    },
+
+    localComputer(computerOptions = {}) {
+      return createLocalComputerAutomify({
+        ...computerDefaults,
+        ...computerOptions,
+        client
+      });
+    },
+
+    virtualCli(cliOptions = {}) {
+      return createDockerCliAutomify({
+        ...defaults,
+        ...cliOptions,
+        client
+      });
+    },
+
+    computer(computerOptions = {}) {
+      return createComputerAutomify({
+        ...computerDefaults,
+        ...computerOptions,
+        client
+      });
+    },
+
+    custom(automifyOptions = {}) {
+      return createAutomify({
+        ...defaults,
+        ...automifyOptions,
+        client
+      });
+    }
+  };
+}
+
+function screenshotDefaultsForProvider(provider) {
+  if (provider.type !== "anthropic") return {};
+  return {
+    maxWidth: ANTHROPIC_COMPUTER_SCREENSHOT_MAX_WIDTH,
+    maxHeight: ANTHROPIC_COMPUTER_SCREENSHOT_MAX_HEIGHT
+  };
+}
+
+function createClient(provider) {
+  if (provider.type === "custom") {
+    if (provider.client) return provider.client;
+    return createModelAdapter(provider.adapter, provider.options ?? {});
+  }
+
+  if (provider.type === "anthropic") {
+    return createAnthropicModelAdapter({
+      ...withoutProviderKeys(provider),
+      anthropicApiKey: provider.apiKey
+    });
+  }
+
+  if (provider.type !== "openai") {
+    throw new AutomifyError(`Unsupported provider.type: ${provider.type}`);
+  }
+
+  return new OpenAIResponsesClient({
+    ...withoutProviderKeys(provider),
+    openaiApiKey: provider.apiKey
+  });
+}
+
+function normalizeProvider(options) {
+  if (options.provider && typeof options.provider === "object") {
+    const provider = {
+      ...options.provider,
+      type: options.provider.type ?? options.provider.name
+    };
+    validateProvider(provider);
+    return provider;
+  }
+
+  if (typeof options.provider === "string") {
+    throw new AutomifyError("initAutomify provider must be an object, for example { type: 'openai', apiKey, model }.");
+  }
+
+  throw new AutomifyError(
+    "initAutomify requires provider: { type, apiKey, model } or provider: { type: 'custom', adapter, model }."
+  );
+}
+
+function withoutProviderKeys(provider) {
+  const { type, name, apiKey, model, adapter, client, options, ...rest } = provider;
+  return rest;
+}
+
+function validateProvider(provider) {
+  if (!provider.type || typeof provider.type !== "string") {
+    throw new AutomifyError("provider.type is required.");
+  }
+
+  if (!provider.model || typeof provider.model !== "string") {
+    throw new AutomifyError("provider.model is required.");
+  }
+
+  if (provider.type === "custom") {
+    if (!provider.adapter && !provider.client) {
+      throw new AutomifyError("provider.adapter or provider.client is required when provider.type is 'custom'.");
+    }
+    return;
+  }
+
+  if (!provider.apiKey || typeof provider.apiKey !== "string") {
+    throw new AutomifyError("provider.apiKey is required.");
+  }
+}