@vornrun/connector-openai 0.1.0

package/dist/index.js

@@ -0,0 +1,1185 @@
+#!/usr/bin/env node
+
+// src/connector.ts
+import {
+  defineConnector
+} from "@vornrun/connector-sdk";
+
+// src/client.ts
+var API_ROOT = "https://api.openai.com/v1";
+var RETRYABLE_429_CODES = /* @__PURE__ */ new Set(["rate_limit_error", "rate_limit_exceeded", "slow_down", "server_is_overloaded"]);
+var RETRYABLE_SERVER_STATUS = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var DEFAULT_RATE_LIMIT_WAIT_MS = 2e3;
+var DEFAULT_SERVER_ERROR_WAIT_MS = 1e3;
+var MAX_JITTER_MS = 500;
+var MAX_PREEMPTIVE_WAIT_MS = 1e4;
+var MAX_ERROR_BODY = 300;
+var KEY_HINT = "Create one at https://platform.openai.com/api-keys (Create new secret key) and set OPENAI_API_KEY on the connection.";
+function normalizeKey(raw) {
+  const key = String(raw ?? "").trim();
+  if (key === "") throw new Error(`OPENAI_API_KEY is required. ${KEY_HINT}`);
+  return key;
+}
+var DURATION_PART = /(\d+(?:\.\d+)?)(ms|h|m|s)/g;
+var UNIT_MS = { ms: 1, s: 1e3, m: 6e4, h: 36e5 };
+function durationMs(value) {
+  const text2 = String(value ?? "").trim();
+  if (text2 === "") return void 0;
+  let total = 0;
+  let matched = "";
+  for (const part of text2.matchAll(DURATION_PART)) {
+    total += Number(part[1]) * UNIT_MS[part[2]];
+    matched += part[0];
+  }
+  return matched === text2 ? total : void 0;
+}
+function seconds(value) {
+  if (value === null || value.trim() === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : void 0;
+}
+var OpenAIApiError = class extends Error {
+  status;
+  code;
+  type;
+  param;
+  requestId;
+  constructor(status, body, requestId) {
+    super(describeFailure(status, body, requestId));
+    this.name = "OpenAIApiError";
+    const error = errorOf(body);
+    this.status = status;
+    this.code = error.code ?? void 0;
+    this.type = error.type;
+    this.param = error.param ?? void 0;
+    this.requestId = requestId;
+  }
+};
+function errorOf(body) {
+  const error = body?.error;
+  return typeof error === "object" && error !== null ? error : {};
+}
+function describeFailure(status, body, requestId) {
+  const error = errorOf(body);
+  const label = error.code ?? error.type;
+  let message = typeof error.message === "string" ? error.message.trim() : "";
+  if (message === "") {
+    const raw = typeof body === "string" ? body : body === void 0 ? "" : JSON.stringify(body);
+    message = raw.length > MAX_ERROR_BODY ? `${raw.slice(0, MAX_ERROR_BODY)}\u2026` : raw;
+  }
+  const head = label ? `${status} ${label}` : String(status);
+  const tail = requestId ? ` (request ${requestId})` : "";
+  return `${head}: ${message || "no body"}${tail}`;
+}
+var defaultSleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var defaultFetch = (input, init) => globalThis.fetch(input, init);
+async function readBody(response) {
+  const text2 = await response.text();
+  if (text2 === "") return void 0;
+  try {
+    return JSON.parse(text2);
+  } catch {
+    return text2;
+  }
+}
+function createOpenAIClient(options) {
+  const fetchImpl = options.fetchImpl ?? defaultFetch;
+  const sleep = options.sleep ?? defaultSleep;
+  const warn = options.warn ?? ((message) => console.warn(message));
+  const now = options.now ?? (() => Date.now());
+  const random = options.random ?? Math.random;
+  const headers = {
+    authorization: `Bearer ${options.apiKey}`,
+    ...options.organization && { "openai-organization": options.organization },
+    ...options.project && { "openai-project": options.project }
+  };
+  let exhaustedUntil = 0;
+  async function pause(ms, why) {
+    warn(`OpenAI: ${why}; waiting ${(ms / 1e3).toFixed(1)}s.`);
+    await sleep(ms);
+  }
+  function jitter() {
+    return Math.floor(random() * MAX_JITTER_MS);
+  }
+  function remember(response) {
+    const remaining = seconds(response.headers.get("x-ratelimit-remaining-requests"));
+    const reset = durationMs(response.headers.get("x-ratelimit-reset-requests"));
+    if (remaining === 0 && reset !== void 0) exhaustedUntil = now() + reset;
+  }
+  async function waitForBudget() {
+    const left = Math.min(MAX_PREEMPTIVE_WAIT_MS, exhaustedUntil - now());
+    if (left > 0) await pause(left, "the request budget is spent");
+  }
+  async function request(method, path, opts = {}) {
+    const url = new URL(`${API_ROOT}/${path.replace(/^\//, "")}`);
+    for (const [key, value] of Object.entries(opts.query ?? {})) {
+      if (value !== void 0 && value !== "") url.searchParams.set(key, String(value));
+    }
+    const init = {
+      method: method.toUpperCase(),
+      headers: opts.body === void 0 ? headers : { ...headers, "content-type": "application/json" },
+      ...opts.body !== void 0 && { body: JSON.stringify(opts.body) }
+    };
+    const route = `${method.toUpperCase()} /${path.replace(/^\//, "")}`;
+    let rateLimited = false;
+    let serverErrored = false;
+    for (; ; ) {
+      await waitForBudget();
+      const response = await fetchImpl(url.toString(), init);
+      remember(response);
+      const body = await readBody(response);
+      if (response.ok) return body;
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      const failure = new OpenAIApiError(response.status, body, requestId);
+      const retryAfter = seconds(response.headers.get("retry-after"));
+      if (response.status === 429) {
+        const retryable = failure.code === void 0 || RETRYABLE_429_CODES.has(failure.code);
+        if (!retryable || rateLimited) throw failure;
+        rateLimited = true;
+        const asked = retryAfter !== void 0 ? retryAfter * 1e3 : durationMs(response.headers.get("x-ratelimit-reset-requests")) ?? DEFAULT_RATE_LIMIT_WAIT_MS;
+        await pause(asked + jitter(), `${route} was rate limited`);
+        continue;
+      }
+      if (RETRYABLE_SERVER_STATUS.has(response.status) && !serverErrored) {
+        serverErrored = true;
+        const asked = retryAfter !== void 0 ? retryAfter * 1e3 : DEFAULT_SERVER_ERROR_WAIT_MS;
+        await pause(asked + jitter(), `${route} answered ${response.status}`);
+        continue;
+      }
+      throw failure;
+    }
+  }
+  return {
+    request,
+    get: (path, query) => request("GET", path, { query })
+  };
+}
+
+// src/items.ts
+var PLATFORM_URL = "https://platform.openai.com";
+var BATCH_TERMINAL_STATUSES = ["completed", "failed", "expired", "cancelled"];
+var FINE_TUNING_TERMINAL_STATUSES = ["succeeded", "failed", "cancelled"];
+function isoOf(seconds2) {
+  return typeof seconds2 === "number" && Number.isFinite(seconds2) ? new Date(seconds2 * 1e3).toISOString() : null;
+}
+function secondsOf(iso) {
+  return Math.floor(Date.parse(iso) / 1e3);
+}
+function isBatchTerminal(status) {
+  return BATCH_TERMINAL_STATUSES.includes(status ?? "");
+}
+function isFineTuningTerminal(status) {
+  return FINE_TUNING_TERMINAL_STATUSES.includes(status ?? "");
+}
+function batchFinishedAt(batch) {
+  return batch.completed_at ?? batch.failed_at ?? batch.expired_at ?? batch.cancelled_at ?? batch.created_at ?? void 0;
+}
+function jobFinishedAt(job) {
+  return job.finished_at ?? job.created_at ?? void 0;
+}
+function requestCountsText(batch) {
+  const counts = batch.request_counts ?? {};
+  const total = counts.total ?? 0;
+  const completed = counts.completed ?? 0;
+  const failed = counts.failed ?? 0;
+  return `${completed} of ${total} requests, ${failed} failed`;
+}
+function batchToItem(batch) {
+  const status = batch.status ?? "unknown";
+  return {
+    externalId: `${batch.id}:${status}`,
+    title: `Batch ${batch.id} ${status}: ${requestCountsText(batch)}`,
+    url: `${PLATFORM_URL}/batches/${encodeURIComponent(batch.id)}`,
+    status,
+    updatedAt: isoOf(batchFinishedAt(batch)) ?? void 0,
+    data: { ...batch }
+  };
+}
+function fileToItem(file) {
+  const name = file.filename ?? file.id;
+  const purpose = file.purpose ?? "unknown purpose";
+  return {
+    externalId: file.id,
+    title: `${name} (${purpose}, ${file.bytes ?? 0} bytes)`,
+    url: `${PLATFORM_URL}/storage/files/${encodeURIComponent(file.id)}`,
+    updatedAt: isoOf(file.created_at) ?? void 0,
+    data: { ...file }
+  };
+}
+function fineTuningJobToItem(job) {
+  const status = job.status ?? "unknown";
+  const detail = status === "failed" && job.error?.message ? job.error.message : job.fine_tuned_model ?? job.model ?? job.id;
+  return {
+    externalId: `${job.id}:${status}`,
+    title: `Fine-tuning job ${job.id} ${status}: ${detail}`,
+    url: `${PLATFORM_URL}/finetune/${encodeURIComponent(job.id)}`,
+    status,
+    updatedAt: isoOf(jobFinishedAt(job)) ?? void 0,
+    data: { ...job }
+  };
+}
+function batchOutput(batch) {
+  const counts = batch.request_counts ?? {};
+  return {
+    id: batch.id,
+    status: batch.status ?? null,
+    endpoint: batch.endpoint ?? null,
+    inputFileId: batch.input_file_id ?? null,
+    outputFileId: batch.output_file_id ?? null,
+    errorFileId: batch.error_file_id ?? null,
+    requestCounts: { total: counts.total ?? 0, completed: counts.completed ?? 0, failed: counts.failed ?? 0 },
+    createdAt: isoOf(batch.created_at),
+    completedAt: isoOf(batch.completed_at),
+    failedAt: isoOf(batch.failed_at),
+    expiredAt: isoOf(batch.expired_at),
+    cancelledAt: isoOf(batch.cancelled_at),
+    errors: batch.errors ?? null,
+    metadata: batch.metadata ?? null,
+    batch
+  };
+}
+function fileSummary(file) {
+  return {
+    id: file.id,
+    filename: file.filename ?? null,
+    bytes: file.bytes ?? null,
+    purpose: file.purpose ?? null,
+    createdAt: isoOf(file.created_at),
+    expiresAt: isoOf(file.expires_at)
+  };
+}
+function modelSummary(model) {
+  return {
+    id: model.id,
+    created: isoOf(model.created),
+    ownedBy: model.owned_by ?? null,
+    shutdownDate: model.shutdown_date ?? null
+  };
+}
+var SAMPLE_BATCH = {
+  id: "batch_abc123",
+  object: "batch",
+  endpoint: "/v1/chat/completions",
+  errors: null,
+  input_file_id: "file-abc123",
+  completion_window: "24h",
+  status: "completed",
+  output_file_id: "file-cvaTdG",
+  error_file_id: "file-HOWS94",
+  created_at: 1711471533,
+  in_progress_at: 1711471538,
+  expires_at: 1711557933,
+  finalizing_at: 1711493133,
+  completed_at: 1711493163,
+  failed_at: null,
+  expired_at: null,
+  cancelling_at: null,
+  cancelled_at: null,
+  request_counts: { total: 100, completed: 95, failed: 5 },
+  metadata: { customer_id: "user_123456789", batch_description: "Nightly job" }
+};
+var SAMPLE_FILE = {
+  id: "file-abc123",
+  object: "file",
+  bytes: 175,
+  created_at: 1613677385,
+  expires_at: 1677614202,
+  filename: "salesOverview.pdf",
+  purpose: "assistants"
+};
+var SAMPLE_FINE_TUNING_JOB = {
+  object: "fine_tuning.job",
+  id: "ftjob-abc123",
+  model: "gpt-4o-mini-2024-07-18",
+  created_at: 1721764800,
+  finished_at: 1721851200,
+  fine_tuned_model: "ft:gpt-4o-mini-2024-07-18:org::abc123",
+  organization_id: "org-123",
+  result_files: ["file-results123"],
+  status: "succeeded",
+  validation_file: null,
+  training_file: "file-abc123",
+  trained_tokens: 5768,
+  error: null,
+  metadata: { key: "value" }
+};
+var SAMPLE_BATCH_ITEM = batchToItem(SAMPLE_BATCH);
+var SAMPLE_FILE_ITEM = fileToItem(SAMPLE_FILE);
+var SAMPLE_FINE_TUNING_JOB_ITEM = fineTuningJobToItem(SAMPLE_FINE_TUNING_JOB);
+
+// package.json
+var package_default = {
+  name: "@vornrun/connector-openai",
+  version: "0.1.0",
+  description: "Trigger workflows when an OpenAI batch or fine-tuning job finishes or a file is uploaded, and create responses, chat completions, embeddings, moderations and batches from a step.",
+  type: "module",
+  license: "MIT",
+  author: "Javier Canizalez <javier-canizalez@outlook.com>",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/vorn-run/connectors.git",
+    directory: "packages/openai"
+  },
+  keywords: [
+    "vorn",
+    "connector",
+    "openai",
+    "mcp"
+  ],
+  bin: {
+    "vorn-connector-openai": "dist/index.js"
+  },
+  main: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      default: "./dist/index.js"
+    }
+  },
+  files: [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  scripts: {
+    build: "tsup",
+    typecheck: "tsc --noEmit",
+    test: "vitest run"
+  },
+  dependencies: {
+    "@vornrun/connector-sdk": "^0.7.0-beta.14"
+  },
+  devDependencies: {
+    "@types/node": "^22.10.2",
+    "@vitest/coverage-v8": "^4.1.10",
+    tsup: "^8.5.1",
+    typescript: "^6.0.3",
+    vitest: "^4.1.10"
+  },
+  vorn: {
+    category: "AI",
+    keywords: [
+      "openai",
+      "gpt",
+      "chatgpt",
+      "llm",
+      "responses",
+      "chat completions",
+      "embeddings",
+      "moderation",
+      "batches",
+      "fine-tuning"
+    ],
+    auth: "Paste an API key from https://platform.openai.com/api-keys. There is no OpenAI CLI to sign in with.",
+    packs: true
+  }
+};
+
+// src/connector.ts
+var PAGE_SIZE = 100;
+var MAX_PAGES = 5;
+var DEFAULT_BATCH_LOOKBACK_HOURS = 48;
+var DEFAULT_FINE_TUNING_LOOKBACK_HOURS = 168;
+var FIRST_POLL_BATCH_HOURS = 24 * 7;
+var FIRST_POLL_FILE_HOURS = 1;
+var DEFAULT_LIST_FILES_LIMIT = 100;
+var DEFAULT_SCHEMA_NAME = "output";
+var BATCH_ENDPOINTS = [
+  "/v1/responses",
+  "/v1/chat/completions",
+  "/v1/embeddings",
+  "/v1/completions",
+  "/v1/moderations",
+  "/v1/images/generations",
+  "/v1/images/edits",
+  "/v1/videos"
+];
+var FILE_PURPOSES = [
+  "assistants",
+  "assistants_output",
+  "batch",
+  "batch_output",
+  "fine-tune",
+  "fine-tune-results",
+  "vision",
+  "user_data"
+];
+function text(value) {
+  const trimmed = String(value ?? "").trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function hours(value, env, fallback) {
+  const raw = text(value);
+  if (raw === void 0) return fallback;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error(`${env} must be a number of hours of at least 0, got "${raw}"`);
+  }
+  return parsed;
+}
+function readSettings(config) {
+  const organization = text(config.organization);
+  const project = text(config.project);
+  const batchEndpoint = text(config.batchEndpoint);
+  const filePurpose = text(config.filePurpose);
+  return {
+    apiKey: normalizeKey(config.apiKey),
+    ...organization && { organization },
+    ...project && { project },
+    ...batchEndpoint && { batchEndpoint },
+    batchLookbackHours: hours(config.batchLookbackHours, "OPENAI_BATCH_LOOKBACK_HOURS", DEFAULT_BATCH_LOOKBACK_HOURS),
+    ...filePurpose && { filePurpose },
+    fineTuningLookbackHours: hours(
+      config.fineTuningLookbackHours,
+      "OPENAI_FINE_TUNING_LOOKBACK_HOURS",
+      DEFAULT_FINE_TUNING_LOOKBACK_HOURS
+    )
+  };
+}
+function textOrJsonArray(value) {
+  const raw = String(value ?? "");
+  if (raw.trim().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  return raw;
+}
+function messageList(value, key = "messages") {
+  const list = Array.isArray(value) ? value : [value];
+  if (list.length === 0) throw new Error(`${key} must hold at least one message`);
+  for (const message of list) {
+    if (typeof message !== "object" || message === null || Array.isArray(message)) {
+      throw new Error(`${key} must be a JSON array of { role, content } objects`);
+    }
+  }
+  return list;
+}
+function jsonObject(value, key) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) throw new Error(`${key} must be a JSON object`);
+  return value;
+}
+function number(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function flag(value) {
+  return /^(true|1|yes)$/i.test(String(value ?? "").trim());
+}
+function responseText(response) {
+  const parts = [];
+  for (const item of response.output ?? []) {
+    if (item?.type !== "message") continue;
+    for (const part of item.content ?? []) {
+      if (part?.type === "output_text" && typeof part.text === "string") parts.push(part.text);
+    }
+  }
+  return parts.join("");
+}
+function parsedJson(textValue) {
+  try {
+    return JSON.parse(textValue);
+  } catch {
+    return null;
+  }
+}
+function createOpenAIConnector(options = {}) {
+  const version = options.version ?? "0.0.0";
+  const warn = options.warn ?? ((message) => console.warn(message));
+  const env = options.env ?? process.env;
+  function fromEnv(value) {
+    const raw = text(value);
+    if (raw === void 0) return void 0;
+    const match = /^\$([A-Z][A-Z0-9_]*)$/.exec(raw);
+    return match ? text(env[match[1]]) : raw;
+  }
+  function clientFor(config, fetchImpl) {
+    const settings = readSettings(config);
+    return createOpenAIClient({
+      apiKey: settings.apiKey,
+      ...settings.organization && { organization: settings.organization },
+      ...settings.project && { project: settings.project },
+      fetchImpl: options.fetchImpl ?? fetchImpl,
+      ...options.sleep && { sleep: options.sleep },
+      warn
+    });
+  }
+  async function walk(client, path, query, floor) {
+    const collected = /* @__PURE__ */ new Map();
+    let after;
+    for (let page = 0; page < MAX_PAGES; page += 1) {
+      const body = await client.get(path, { ...query, limit: PAGE_SIZE, after });
+      const data = Array.isArray(body?.data) ? body.data : [];
+      for (const entry of data) if (entry?.id) collected.set(entry.id, entry);
+      if (data.length === 0 || body.has_more !== true) break;
+      const oldest = Math.min(...data.map((entry) => entry.created_at ?? Number.POSITIVE_INFINITY));
+      if (oldest < floor) break;
+      after = body.last_id ?? data[data.length - 1].id;
+    }
+    return [...collected.values()];
+  }
+  function sinceSeconds(context) {
+    return context.since ? secondsOf(context.since) : void 0;
+  }
+  async function fetchBatches(context) {
+    const settings = readSettings(context.config);
+    const client = clientFor(context.config, context.fetch);
+    const since = sinceSeconds(context);
+    const firstPollFloor = secondsOf(context.now()) - FIRST_POLL_BATCH_HOURS * 3600;
+    const pagingFloor = since === void 0 ? firstPollFloor : since - settings.batchLookbackHours * 3600;
+    const batches = await walk(client, "batches", {}, pagingFloor);
+    return batches.filter((batch) => isBatchTerminal(batch.status)).filter((batch) => settings.batchEndpoint === void 0 || batch.endpoint === settings.batchEndpoint).filter((batch) => since !== void 0 || (batchFinishedAt(batch) ?? 0) >= firstPollFloor).sort((left, right) => (batchFinishedAt(left) ?? 0) - (batchFinishedAt(right) ?? 0)).map(batchToItem);
+  }
+  async function fetchFiles(context) {
+    const settings = readSettings(context.config);
+    const client = clientFor(context.config, context.fetch);
+    const floor = sinceSeconds(context) ?? secondsOf(context.now()) - FIRST_POLL_FILE_HOURS * 3600;
+    const files = await walk(client, "files", { order: "desc", purpose: settings.filePurpose }, floor);
+    return files.filter((file) => (file.created_at ?? 0) >= floor).sort((left, right) => (left.created_at ?? 0) - (right.created_at ?? 0)).map(fileToItem);
+  }
+  async function fetchFineTuningJobs(context) {
+    const settings = readSettings(context.config);
+    const client = clientFor(context.config, context.fetch);
+    const lookback = settings.fineTuningLookbackHours * 3600;
+    const since = sinceSeconds(context) ?? secondsOf(context.now()) - lookback;
+    const jobs = await walk(client, "fine_tuning/jobs", {}, since - lookback);
+    return jobs.filter((job) => isFineTuningTerminal(job.status)).filter((job) => (jobFinishedAt(job) ?? 0) >= since).sort((left, right) => (jobFinishedAt(left) ?? 0) - (jobFinishedAt(right) ?? 0)).map(fineTuningJobToItem);
+  }
+  function requiredArg(args, key) {
+    const value = fromEnv(args[key]);
+    if (!value) throw new Error(`${key} is required`);
+    return value;
+  }
+  const MODEL_INPUT = {
+    key: "model",
+    label: "Model",
+    required: true,
+    description: "Model id, such as gpt-4o-mini.",
+    builderHint: "Any id listModels returns. A fine-tuned model is its ft:\u2026 id."
+  };
+  const TEMPERATURE_INPUT = {
+    key: "temperature",
+    label: "Temperature",
+    type: "number",
+    description: "Sampling temperature, 0 to 2. Lower is more deterministic.",
+    builderHint: "Alter this or top_p, not both; leave empty for the model default of 1."
+  };
+  return defineConnector({
+    id: "openai",
+    name: "OpenAI",
+    version,
+    description: "Trigger workflows when an OpenAI batch or fine-tuning job finishes or a file is uploaded, and create responses, chat completions, embeddings, moderations and batches from a step.",
+    auth: { rung: "key", keys: ["apiKey"] },
+    // The hexagonal knot: six interlaced loops as one path, the counters punched through by the evenodd rule.
+    icon: {
+      viewBox: "0 0 24 24",
+      paths: [
+        "M22.2819 9.8211a5.9847 5.9847 0 0 0-.5157-4.9108 6.0462 6.0462 0 0 0-6.5098-2.9A6.0651 6.0651 0 0 0 4.9807 4.1818a5.9847 5.9847 0 0 0-3.9977 2.9 6.0462 6.0462 0 0 0 .7427 7.0966 5.98 5.98 0 0 0 .511 4.9107 6.051 6.051 0 0 0 6.5146 2.9001A5.9847 5.9847 0 0 0 13.2599 24a6.0557 6.0557 0 0 0 5.7718-4.2058 5.9894 5.9894 0 0 0 3.9977-2.9001 6.0557 6.0557 0 0 0-.7475-7.0729zm-9.022 12.6081a4.4755 4.4755 0 0 1-2.8764-1.0408l.1419-.0804 4.7783-2.7582a.7948.7948 0 0 0 .3927-.6813v-6.7369l2.02 1.1686a.071.071 0 0 1 .038.052v5.5826a4.504 4.504 0 0 1-4.4945 4.4944zm-9.6607-4.1254a4.4708 4.4708 0 0 1-.5346-3.0137l.142.0852 4.783 2.7582a.7712.7712 0 0 0 .7806 0l5.8428-3.3685v2.3324a.0804.0804 0 0 1-.0332.0615L9.74 19.9502a4.4992 4.4992 0 0 1-6.1408-1.6464zM2.3408 7.8956a4.485 4.485 0 0 1 2.3655-1.9728V11.6a.7664.7664 0 0 0 .3879.6765l5.8144 3.3543-2.0201 1.1685a.0757.0757 0 0 1-.071 0l-4.8303-2.7865A4.504 4.504 0 0 1 2.3408 7.872zm16.5963 3.8558L13.1038 8.364 15.1192 7.2a.0757.0757 0 0 1 .071 0l4.8303 2.7913a4.4944 4.4944 0 0 1-.6765 8.1042v-5.6772a.79.79 0 0 0-.407-.667zm2.0107-3.0231l-.142-.0852-4.7735-2.7818a.7759.7759 0 0 0-.7854 0L9.409 9.2297V6.8974a.0662.0662 0 0 1 .0284-.0615l4.8303-2.7866a4.4992 4.4992 0 0 1 6.6802 4.66zM8.3065 12.863l-2.02-1.1638a.0804.0804 0 0 1-.038-.0567V6.0742a4.4992 4.4992 0 0 1 7.3757-3.4537l-.142.0805L8.704 5.459a.7948.7948 0 0 0-.3927.6813zm1.0976-2.3654l2.602-1.4998 2.6069 1.4998v2.9994l-2.5974 1.4997-2.6067-1.4997Z"
+      ]
+    },
+    config: [
+      {
+        key: "apiKey",
+        env: "OPENAI_API_KEY",
+        label: "API key",
+        secret: true,
+        required: true,
+        description: `Sent as \`Authorization: Bearer <key>\`. ${KEY_HINT}`,
+        builderHint: "A standard or project key (sk-\u2026 or sk-proj-\u2026), not an Admin key: Admin keys serve only the Administration API. Permissions are set per key at creation; a key that lacks an endpoint answers 401 insufficient permissions. Pasted whitespace is trimmed."
+      },
+      {
+        key: "organization",
+        env: "OPENAI_ORGANIZATION",
+        label: "Organization",
+        description: "Organization id (org-\u2026), sent as OpenAI-Organization. Only needed when the key belongs to more than one organization.",
+        builderHint: "Settings \u2192 Organization \u2192 General. Leave empty for a project key, which is already scoped."
+      },
+      {
+        key: "project",
+        env: "OPENAI_PROJECT",
+        label: "Project",
+        description: "Project id (proj_\u2026), sent as OpenAI-Project. Only needed when a legacy user key should bill one project.",
+        builderHint: "Settings \u2192 Project \u2192 General. Leave empty for a project key."
+      },
+      {
+        key: "batchEndpoint",
+        env: "OPENAI_BATCH_ENDPOINT",
+        label: "Batch endpoint filter",
+        description: "Only batches for this endpoint, such as /v1/chat/completions. Empty delivers every batch.",
+        builderHint: "The list has no server-side filter; the connector compares the batch object\u2019s endpoint field."
+      },
+      {
+        key: "batchLookbackHours",
+        env: "OPENAI_BATCH_LOOKBACK_HOURS",
+        label: "Batch look-back (hours)",
+        default: String(DEFAULT_BATCH_LOOKBACK_HOURS),
+        description: "How far before the watermark the batch poll reads, because a batch finishes up to a day after it is created.",
+        builderHint: "Raise it if batches take longer than two days to finish or expire; lower it for a busy account."
+      },
+      {
+        key: "filePurpose",
+        env: "OPENAI_FILE_PURPOSE",
+        label: "File purpose filter",
+        description: `Only files uploaded with this purpose (${FILE_PURPOSES.join(", ")}). Empty delivers every file.`,
+        builderHint: "Passed through as the purpose query parameter, so the API does the filtering."
+      },
+      {
+        key: "fineTuningLookbackHours",
+        env: "OPENAI_FINE_TUNING_LOOKBACK_HOURS",
+        label: "Fine-tuning look-back (hours)",
+        default: String(DEFAULT_FINE_TUNING_LOOKBACK_HOURS),
+        description: "How far before the watermark the fine-tuning poll reads, because a job is created long before it finishes.",
+        builderHint: "A week by default. Jobs that queue longer than this before finishing are missed."
+      }
+    ],
+    async preflight() {
+      const key = text(env.OPENAI_API_KEY);
+      if (!key) return { ok: false, message: `Set OPENAI_API_KEY. ${KEY_HINT}` };
+      const client = createOpenAIClient({
+        apiKey: normalizeKey(key),
+        ...text(env.OPENAI_ORGANIZATION) && { organization: text(env.OPENAI_ORGANIZATION) },
+        ...text(env.OPENAI_PROJECT) && { project: text(env.OPENAI_PROJECT) },
+        ...options.fetchImpl && { fetchImpl: options.fetchImpl },
+        ...options.sleep && { sleep: options.sleep },
+        warn
+      });
+      const models = await client.get("models");
+      const count = Array.isArray(models?.data) ? models.data.length : 0;
+      return { ok: true, message: `Signed in; ${count} models available` };
+    },
+    triggers: [
+      {
+        type: "batchFinished",
+        label: "A batch finishes",
+        description: "Fires once when a batch reaches completed, failed, expired or cancelled. The list has no status filter, so every batch created inside the look-back is read and the terminal ones kept.",
+        defaultWorkflow: { name: "OpenAI: finished batches", defaultCronFromMinutes: 5 },
+        statusMapping: [
+          { upstream: "completed", suggestedLocal: "done" },
+          { upstream: "failed", suggestedLocal: "todo" },
+          { upstream: "expired", suggestedLocal: "cancelled" },
+          { upstream: "cancelled", suggestedLocal: "cancelled" }
+        ],
+        dedupe: "timestamp",
+        sample: [SAMPLE_BATCH_ITEM],
+        fetch: fetchBatches
+      },
+      {
+        type: "fileUploaded",
+        label: "A file is uploaded",
+        description: "Fires once per file uploaded since the last poll, newest first from GET /files.",
+        defaultWorkflow: { name: "OpenAI: uploaded files", defaultCronFromMinutes: 5 },
+        dedupe: "timestamp",
+        sample: [SAMPLE_FILE_ITEM],
+        fetch: fetchFiles
+      },
+      {
+        type: "fineTuningJobFinished",
+        label: "A fine-tuning job finishes",
+        description: "Fires once when a fine-tuning job reaches succeeded, failed or cancelled.",
+        defaultWorkflow: { name: "OpenAI: finished fine-tuning jobs", defaultCronFromMinutes: 15 },
+        statusMapping: [
+          { upstream: "succeeded", suggestedLocal: "done" },
+          { upstream: "failed", suggestedLocal: "todo" },
+          { upstream: "cancelled", suggestedLocal: "cancelled" }
+        ],
+        dedupe: "timestamp",
+        sample: [SAMPLE_FINE_TUNING_JOB_ITEM],
+        fetch: fetchFineTuningJobs
+      }
+    ],
+    actions: [
+      {
+        type: "createResponse",
+        label: "Create a response",
+        description: "Ask a model for a response with the Responses API, optionally constrained to a JSON schema. Spends tokens; not stored unless asked.",
+        idempotent: false,
+        inputs: [
+          MODEL_INPUT,
+          {
+            key: "input",
+            label: "Input",
+            required: true,
+            description: "Plain text, or a JSON array of message items { role, content } with role user, assistant, system or developer.",
+            builderHint: "A value that parses as a JSON array is sent as the array; anything else is sent as text."
+          },
+          {
+            key: "instructions",
+            label: "Instructions",
+            description: "A system or developer message inserted into the model\u2019s context.",
+            builderHint: "Prefer this over a system message in input; it is not carried into a later turn."
+          },
+          TEMPERATURE_INPUT,
+          {
+            key: "maxOutputTokens",
+            label: "Max output tokens",
+            type: "number",
+            description: "Upper bound on generated tokens, including reasoning tokens. Sent as max_output_tokens.",
+            builderHint: "The API refuses values under 16. A response cut here reports incompleteReason max_output_tokens."
+          },
+          {
+            key: "schema",
+            label: "JSON schema",
+            type: "json",
+            description: "A JSON Schema object the output must match, sent as text.format json_schema with strict true.",
+            builderHint: "Strict mode wants every property in required and additionalProperties false. The parsed result is the json output."
+          },
+          {
+            key: "schemaName",
+            label: "Schema name",
+            description: `Name of the format, letters, digits, underscores and dashes up to 64 characters. Default ${DEFAULT_SCHEMA_NAME}.`,
+            builderHint: "Only read when schema is given."
+          },
+          {
+            key: "store",
+            label: "Store the response",
+            type: "boolean",
+            description: "Keep the response retrievable for 30 days. Off here by default, unlike the API.",
+            builderHint: "true when a later step needs previous_response_id."
+          }
+        ],
+        outputs: [
+          { key: "id", description: "Response id" },
+          { key: "status", description: "completed, incomplete, failed or in_progress" },
+          { key: "text", description: "Every output_text part of every message, joined" },
+          { key: "json", description: "The text parsed as JSON when a schema was given, else null" },
+          { key: "model", description: "The model that answered" },
+          { key: "usage", description: "{ input_tokens, output_tokens, total_tokens, reasoning_tokens }" },
+          { key: "incompleteReason", description: "Why the response stopped early, or null" },
+          { key: "response", description: "The raw response object" }
+        ],
+        async run(args, context) {
+          const schema = jsonObject(args.schema, "schema");
+          const schemaName = text(args.schemaName) ?? DEFAULT_SCHEMA_NAME;
+          const temperature = number(args.temperature);
+          const maxOutputTokens = number(args.maxOutputTokens);
+          const instructions = text(args.instructions);
+          const client = clientFor(context.config, context.fetch);
+          const response = await client.request("POST", "responses", {
+            body: {
+              model: requiredArg(args, "model"),
+              input: textOrJsonArray(args.input),
+              store: flag(args.store),
+              ...instructions && { instructions },
+              ...temperature !== void 0 && { temperature },
+              ...maxOutputTokens !== void 0 && { max_output_tokens: maxOutputTokens },
+              ...schema && { text: { format: { type: "json_schema", name: schemaName, schema, strict: true } } }
+            }
+          });
+          const body = response ?? {};
+          const output = responseText(body);
+          return {
+            id: body.id ?? null,
+            status: body.status ?? null,
+            text: output,
+            json: schema ? parsedJson(output) : null,
+            model: body.model ?? null,
+            usage: {
+              input_tokens: body.usage?.input_tokens ?? 0,
+              output_tokens: body.usage?.output_tokens ?? 0,
+              total_tokens: body.usage?.total_tokens ?? 0,
+              reasoning_tokens: body.usage?.output_tokens_details?.reasoning_tokens ?? 0
+            },
+            incompleteReason: body.incomplete_details?.reason ?? null,
+            response: body
+          };
+        }
+      },
+      {
+        type: "createChatCompletion",
+        label: "Create a chat completion",
+        description: "Ask a model for the next message in a conversation with the Chat Completions API. Spends tokens.",
+        idempotent: false,
+        inputs: [
+          MODEL_INPUT,
+          {
+            key: "messages",
+            label: "Messages",
+            type: "json",
+            required: true,
+            description: "A JSON array of { role, content } with role system, developer, user, assistant or tool.",
+            builderHint: "One object is taken as a single message."
+          },
+          TEMPERATURE_INPUT,
+          {
+            key: "maxTokens",
+            label: "Max completion tokens",
+            type: "number",
+            description: "Upper bound on generated tokens, including reasoning tokens. Sent as max_completion_tokens.",
+            builderHint: "max_tokens is deprecated and refused by o-series models, so this never sends it."
+          },
+          {
+            key: "responseFormat",
+            label: "Response format",
+            type: "json",
+            description: 'JSON: { "type": "text" }, { "type": "json_object" } or { "type": "json_schema", "json_schema": { name, schema, strict } }.',
+            builderHint: "json_object needs the word JSON somewhere in the messages or the API refuses."
+          }
+        ],
+        outputs: [
+          { key: "id", description: "Completion id" },
+          { key: "text", description: "Content of the first choice" },
+          { key: "finishReason", description: "stop, length, tool_calls, content_filter or function_call" },
+          { key: "refusal", description: "The refusal message of the first choice, or null" },
+          { key: "model", description: "The model that answered" },
+          { key: "usage", description: "{ prompt_tokens, completion_tokens, total_tokens }" },
+          { key: "completion", description: "The raw completion object" }
+        ],
+        async run(args, context) {
+          const temperature = number(args.temperature);
+          const maxTokens = number(args.maxTokens);
+          const responseFormat = jsonObject(args.responseFormat, "responseFormat");
+          const client = clientFor(context.config, context.fetch);
+          const completion = await client.request("POST", "chat/completions", {
+            body: {
+              model: requiredArg(args, "model"),
+              messages: messageList(args.messages),
+              ...temperature !== void 0 && { temperature },
+              ...maxTokens !== void 0 && { max_completion_tokens: maxTokens },
+              ...responseFormat && { response_format: responseFormat }
+            }
+          });
+          const body = completion ?? {};
+          const first = body.choices?.[0];
+          return {
+            id: body.id ?? null,
+            text: first?.message?.content ?? "",
+            finishReason: first?.finish_reason ?? null,
+            refusal: first?.message?.refusal ?? null,
+            model: body.model ?? null,
+            usage: {
+              prompt_tokens: body.usage?.prompt_tokens ?? 0,
+              completion_tokens: body.usage?.completion_tokens ?? 0,
+              total_tokens: body.usage?.total_tokens ?? 0
+            },
+            completion: body
+          };
+        }
+      },
+      {
+        type: "createEmbeddings",
+        label: "Create embeddings",
+        description: "Turn text into embedding vectors. The same input yields the same vectors and nothing is stored.",
+        idempotent: true,
+        sample: { model: "text-embedding-3-small", input: "hello" },
+        inputs: [
+          {
+            ...MODEL_INPUT,
+            description: "text-embedding-3-small, text-embedding-3-large or text-embedding-ada-002.",
+            builderHint: "text-embedding-3-small is the cheapest; dimensions only works on the 3 series."
+          },
+          {
+            key: "input",
+            label: "Input",
+            required: true,
+            description: "Plain text, or a JSON array of strings to embed in one call.",
+            builderHint: "Each string at most 8192 tokens, an array at most 2048 entries."
+          },
+          {
+            key: "dimensions",
+            label: "Dimensions",
+            type: "number",
+            description: "How many dimensions each vector should have. text-embedding-3 models only.",
+            builderHint: "Leave empty for the model default (1536 for small, 3072 for large)."
+          }
+        ],
+        outputs: [
+          { key: "embeddings", description: "Array of number arrays, in input order" },
+          { key: "dimensions", type: "number", description: "Length of the first vector" },
+          { key: "model", description: "The model used" },
+          { key: "usage", description: "{ prompt_tokens, total_tokens }" }
+        ],
+        async run(args, context) {
+          const dimensions = number(args.dimensions);
+          const client = clientFor(context.config, context.fetch);
+          const body = await client.request("POST", "embeddings", {
+            body: {
+              model: requiredArg(args, "model"),
+              input: textOrJsonArray(args.input),
+              ...dimensions !== void 0 && { dimensions }
+            }
+          });
+          const embeddings = [...body?.data ?? []].sort((left, right) => (left.index ?? 0) - (right.index ?? 0)).map((entry) => entry.embedding ?? []);
+          return {
+            embeddings,
+            dimensions: embeddings[0]?.length ?? 0,
+            model: body?.model ?? null,
+            usage: { prompt_tokens: body?.usage?.prompt_tokens ?? 0, total_tokens: body?.usage?.total_tokens ?? 0 }
+          };
+        }
+      },
+      {
+        type: "moderateText",
+        label: "Moderate text",
+        description: "Classify text against OpenAI\u2019s usage policies. Free, and nothing is stored.",
+        idempotent: true,
+        sample: { input: "hello" },
+        inputs: [
+          {
+            key: "input",
+            label: "Input",
+            required: true,
+            description: "Plain text, or a JSON array of strings to classify separately.",
+            builderHint: "One result per string, in order."
+          },
+          {
+            key: "model",
+            label: "Model",
+            description: "omni-moderation-latest (default), omni-moderation-2024-09-26, text-moderation-latest or text-moderation-stable.",
+            builderHint: "Leave empty for omni-moderation-latest."
+          }
+        ],
+        outputs: [
+          { key: "flagged", type: "boolean", description: "True when any result is flagged" },
+          { key: "results", description: "Array of { flagged, categories, category_scores, category_applied_input_types }" },
+          { key: "model", description: "The moderation model used" },
+          { key: "id", description: "Moderation id" }
+        ],
+        async run(args, context) {
+          const model = text(args.model);
+          const client = clientFor(context.config, context.fetch);
+          const body = await client.request("POST", "moderations", {
+            body: { input: textOrJsonArray(args.input), ...model && { model } }
+          });
+          const results = Array.isArray(body?.results) ? body.results : [];
+          return {
+            flagged: results.some((result) => result?.flagged === true),
+            results,
+            model: body?.model ?? null,
+            id: body?.id ?? null
+          };
+        }
+      },
+      {
+        type: "listModels",
+        label: "List models",
+        description: "List the models the key can use, with their owner.",
+        idempotent: true,
+        sample: {},
+        outputs: [
+          { key: "models", description: "Array of { id, created, ownedBy, shutdownDate }" },
+          { key: "count", type: "number", description: "How many models" }
+        ],
+        async run(_args, context) {
+          const client = clientFor(context.config, context.fetch);
+          const body = await client.get("models");
+          const models = (Array.isArray(body?.data) ? body.data : []).map(modelSummary);
+          return { models, count: models.length };
+        }
+      },
+      {
+        type: "getModel",
+        label: "Get a model",
+        description: "Read one model by id. An unknown id answers 404 model_not_found.",
+        idempotent: true,
+        sample: { model: "gpt-4o-mini" },
+        inputs: [MODEL_INPUT],
+        outputs: [
+          { key: "id", description: "Model id" },
+          { key: "created", description: "When it was created, ISO 8601" },
+          { key: "ownedBy", description: "The organization that owns it" },
+          { key: "shutdownDate", description: "Planned retirement date, or null" }
+        ],
+        async run(args, context) {
+          const client = clientFor(context.config, context.fetch);
+          const model = await client.get(`models/${encodeURIComponent(requiredArg(args, "model"))}`);
+          return modelSummary(model ?? { id: requiredArg(args, "model") });
+        }
+      },
+      {
+        type: "listFiles",
+        label: "List files",
+        description: "List uploaded files, newest first, optionally by purpose.",
+        idempotent: true,
+        sample: { limit: "5" },
+        inputs: [
+          {
+            key: "purpose",
+            label: "Purpose",
+            type: "select",
+            options: FILE_PURPOSES.map((value) => ({ value })),
+            description: "Only files uploaded with this purpose.",
+            builderHint: "Leave empty for every purpose."
+          },
+          {
+            key: "limit",
+            label: "Limit",
+            type: "number",
+            description: `1 to 10,000 files per page; default ${DEFAULT_LIST_FILES_LIMIT}.`,
+            builderHint: "The API default is 10,000, which is a lot to hand a workflow step."
+          },
+          {
+            key: "order",
+            label: "Order",
+            type: "select",
+            options: [{ value: "desc", label: "Newest first" }, { value: "asc", label: "Oldest first" }],
+            description: "Sort by created_at. Default desc.",
+            builderHint: "asc with after walks a backlog oldest first."
+          },
+          {
+            key: "after",
+            label: "After",
+            description: "A file id from an earlier page; the list continues after it.",
+            builderHint: "Feed lastId from the previous call."
+          }
+        ],
+        outputs: [
+          { key: "files", description: "Array of { id, filename, bytes, purpose, createdAt, expiresAt }" },
+          { key: "hasMore", type: "boolean", description: "Whether another page follows" },
+          { key: "lastId", description: "Id of the last file listed, for after" }
+        ],
+        async run(args, context) {
+          const client = clientFor(context.config, context.fetch);
+          const body = await client.get("files", {
+            purpose: text(args.purpose),
+            limit: number(args.limit) ?? DEFAULT_LIST_FILES_LIMIT,
+            order: text(args.order),
+            after: text(args.after)
+          });
+          const files = Array.isArray(body?.data) ? body.data : [];
+          return {
+            files: files.map(fileSummary),
+            hasMore: body?.has_more === true,
+            lastId: body?.last_id ?? files[files.length - 1]?.id ?? null
+          };
+        }
+      },
+      {
+        type: "getBatch",
+        label: "Get a batch",
+        description: "Read one batch by id, with its status, request counts and output files.",
+        idempotent: true,
+        sample: { batch: "$OPENAI_BATCH_ID" },
+        inputs: [
+          {
+            key: "batch",
+            label: "Batch",
+            required: true,
+            description: "Batch id, such as batch_abc123.",
+            builderHint: "Often {{trigger.item.id}} from the batch trigger. $NAME reads the environment for live checks."
+          }
+        ],
+        outputs: batchOutputs(),
+        async run(args, context) {
+          const client = clientFor(context.config, context.fetch);
+          const id = requiredArg(args, "batch");
+          const batch = await client.get(`batches/${encodeURIComponent(id)}`);
+          return batchOutput(batch ?? { id });
+        }
+      },
+      {
+        type: "createBatch",
+        label: "Create a batch",
+        description: "Queue a batch of requests from an uploaded JSONL file. Each call queues a new batch that runs and bills.",
+        idempotent: false,
+        inputs: [
+          {
+            key: "inputFileId",
+            label: "Input file",
+            required: true,
+            description: "Id of an uploaded JSONL file with purpose batch, one request per line.",
+            builderHint: "Upload with the Files API first; this connector does not upload."
+          },
+          {
+            key: "endpoint",
+            label: "Endpoint",
+            type: "select",
+            required: true,
+            options: BATCH_ENDPOINTS.map((value) => ({ value })),
+            description: "The endpoint every request in the file targets.",
+            builderHint: "Must match the url field of each line in the file."
+          },
+          {
+            key: "completionWindow",
+            label: "Completion window",
+            type: "select",
+            options: [{ value: "24h" }],
+            description: "How long the batch has to finish. Only 24h is supported; default 24h.",
+            builderHint: "Left as a select so a future window can be added without a code change."
+          },
+          {
+            key: "metadata",
+            label: "Metadata",
+            type: "json",
+            description: "A JSON object of up to 16 string pairs, keys up to 64 characters and values up to 512.",
+            builderHint: "Comes back on the batch object and in the trigger item\u2019s data.metadata."
+          }
+        ],
+        outputs: batchOutputs(),
+        async run(args, context) {
+          const metadata = jsonObject(args.metadata, "metadata");
+          const client = clientFor(context.config, context.fetch);
+          const batch = await client.request("POST", "batches", {
+            body: {
+              input_file_id: requiredArg(args, "inputFileId"),
+              endpoint: requiredArg(args, "endpoint"),
+              completion_window: text(args.completionWindow) ?? "24h",
+              ...metadata && { metadata }
+            }
+          });
+          return batchOutput(batch ?? { id: "" });
+        }
+      }
+    ]
+  });
+}
+function batchOutputs() {
+  return [
+    { key: "id", description: "Batch id" },
+    { key: "status", description: "validating, failed, in_progress, finalizing, completed, expired, cancelling or cancelled" },
+    { key: "endpoint", description: "The endpoint the batch calls" },
+    { key: "inputFileId", description: "The JSONL file of requests" },
+    { key: "outputFileId", description: "The file of results, once completed" },
+    { key: "errorFileId", description: "The file of failed requests, or null" },
+    { key: "requestCounts", description: "{ total, completed, failed }" },
+    { key: "createdAt", description: "When it was created, ISO 8601" },
+    { key: "completedAt", description: "When it completed, or null" },
+    { key: "failedAt", description: "When it failed, or null" },
+    { key: "expiredAt", description: "When it expired, or null" },
+    { key: "cancelledAt", description: "When it was cancelled, or null" },
+    { key: "errors", description: "Validation errors, or null" },
+    { key: "metadata", description: "The metadata it was created with" },
+    { key: "batch", description: "The raw batch object" }
+  ];
+}
+var connector = createOpenAIConnector({ version: package_default.version });
+
+// src/entry.ts
+import { realpathSync } from "fs";
+import { fileURLToPath } from "url";
+import { serveConnector } from "@vornrun/connector-sdk";
+function isEntryPoint(moduleUrl, argv = process.argv) {
+  const invoked = argv[1];
+  if (invoked === void 0) return false;
+  try {
+    return realpathSync(fileURLToPath(moduleUrl)) === realpathSync(invoked);
+  } catch {
+    return false;
+  }
+}
+async function serveIfEntryPoint(moduleUrl, serve = serveConnector) {
+  if (!isEntryPoint(moduleUrl)) return false;
+  await serve(connector);
+  return true;
+}
+
+// src/index.ts
+var index_default = connector;
+await serveIfEntryPoint(import.meta.url);
+export {
+  API_ROOT,
+  OpenAIApiError,
+  connector,
+  createOpenAIClient,
+  createOpenAIConnector,
+  index_default as default,
+  durationMs,
+  normalizeKey,
+  readSettings
+};