@vornrun/connector-anthropic 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,42 @@
+# Changelog
+
+All notable changes to `@vornrun/connector-anthropic`.
+
+## 0.1.0
+
+First release.
+
+Trigger a workflow when an Anthropic message batch finishes processing or a
+new model becomes available, and let a workflow step create a message, count
+tokens, list or read models, and create, read, collect or cancel a message
+batch.
+
+- **Triggers:** `batchEnded`, `newModel`.
+- **Actions:** `createMessage`, `countTokens`, `listModels`, `getModel`,
+  `createMessageBatch`, `getMessageBatch`, `getBatchResults`,
+  `cancelMessageBatch`.
+- **Signing in:** an API key from console.anthropic.com/settings/keys, sent as
+  `x-api-key` with `anthropic-version: 2023-06-01`. There is no CLI to borrow
+  a login from.
+
+Every action and both polls go through one small client rather than declared
+SDK requests, because the documented rate-limit behaviour needs more than a
+declared request can express: a `429` is retried once after `retry-after` and
+reported at once when the header is missing, since that is the spend cap; a
+`529` or `5xx` is retried once; and a reply that says no requests remain makes
+the next call wait for `anthropic-ratelimit-requests-reset`. Every failure is
+reported as `<error.type>: <error.message>` with the status and request id,
+and every message, model and batch read returns the reply as `raw` beside the
+named fields. Batch results are the JSONL stream parsed into an array.
+
+Both triggers poll on the SDK's timestamp dedupe strategy, walking `after_id`
+pages newest first. Ended batches are stamped with `ended_at` and
+the walk stops 24 hours before the cursor, the batch lifetime, so a batch
+created before one poll and ended after it still fires once. New models are
+stamped with `created_at`; the first poll looks 30 days back and an epoch
+release date never fires.
+
+Ships as a pack with a conformance receipt covering the dedupe replay of both
+triggers and the mock run of every action. No runtime dependencies: `fetch`
+and `JSON` cover the client, the pager is a loop on `after_id`, and JSONL is
+a split on newlines.

package/README.md

@@ -0,0 +1,144 @@
+# @vornrun/connector-anthropic
+
+Trigger Vorn workflows when an Anthropic message batch finishes processing or
+a new model becomes available, and create messages, count tokens, list models
+and run message batches from a workflow step. Talks to the Claude API at
+`https://api.anthropic.com/v1`.
+
+## Signing in
+
+Paste an API key into the **API key** field. There is no CLI to borrow a login
+from. Create one at https://console.anthropic.com/settings/keys (the console
+also answers at https://platform.claude.com/settings/keys). Keys have no
+scopes: choose the key's type and expiry when you create it. Use a
+**single-workspace** key; a multi-workspace key also needs an
+`anthropic-workspace-id` header, which this connector does not send.
+
+The key is sent as `x-api-key` together with `anthropic-version: 2023-06-01`
+on every call. A malformed, revoked or expired key answers
+`401 authentication_error`; a key without access to a resource answers
+`403 permission_error`. The connector surfaces every API error as
+`<error.type>: <error.message>` with the HTTP status and the `request-id`,
+such as `not_found_error: The requested resource could not be found. (HTTP 404,
+request req_…)`. Keep the key out of shared configuration: it bills against
+your organization.
+
+## Settings
+
+| Setting | Environment | Required | What it does |
+| --- | --- | --- | --- |
+| API key | `ANTHROPIC_API_KEY` | yes | Sent as `x-api-key` on every call |
+
+## Rate limits
+
+Limits are per organization and per model, in requests, input tokens and
+output tokens per minute; batches have their own request limit shared across
+models. Beyond a limit the API answers `429 rate_limit_error` with a
+`retry-after` header. The connector:
+
+- waits `retry-after` (capped at 60 seconds) and sends once more on a `429`;
+  a second `429` is reported. A `429` **without** `retry-after` is the monthly
+  spend cap and is reported at once, since no wait lifts it;
+- retries once after `retry-after`, or a jittered one to two seconds, on a
+  `529 overloaded_error` or any `5xx`;
+- reads `anthropic-ratelimit-requests-remaining` on every reply, and when it
+  reached `0` waits until `anthropic-ratelimit-requests-reset` (capped at 60
+  seconds) before the next call, so a poll that walks pages does not trip the
+  limit by itself.
+
+Nothing else is retried. Every action goes through the same client, so the
+same waits, retries and error text apply to all of them.
+
+The connector does not stream, so `createMessage` defaults `maxTokens` to
+1024. A long generation or a large job belongs in a message batch.
+
+## Triggers
+
+Both poll with `limit=100` and walk `after_id` pages, at most ten per poll,
+and deliver oldest first.
+
+### `batchEnded` — a message batch finished
+
+Polls `GET messages/batches`, newest first, and fires once for each batch
+whose `processing_status` is `ended`. Processing ends when every request has
+succeeded, errored, been canceled or expired. The list is ordered by creation,
+and a batch created before the last poll can end after it, so the poll walks
+back until it meets a batch created more than 24 hours before the cursor:
+batches expire 24 hours after creation, so anything older ended before the
+previous poll. The first poll looks 24 hours back. Each item carries the
+batch as `data`, `ended_at` as its time, and a title such as
+`Batch msgbatch_… ended: 50 succeeded, 30 errored`. The docs give no console
+URL for a batch, so there is no `url`. Read the results with
+`getBatchResults`.
+
+### `newModel` — a model became available
+
+Polls `GET models`, newest first, and fires once for each model whose
+`created_at` is at or after the cursor. The first poll looks 30 days back so
+an old catalog does not fire wholesale. A model whose release date is unknown
+carries an epoch `created_at` and never fires. Each item carries the model as
+`data`, its `display_name` as the title and the models overview page as `url`.
+
+## Actions
+
+Inputs typed JSON are checked before any call is made. `model` defaults to
+`claude-sonnet-5`; `messages` is either prompt text, sent as one user turn, or
+a JSON array of `{ "role", "content" }` turns passed through as is.
+
+| Action | Idempotent | What it does |
+| --- | --- | --- |
+| `createMessage` | no | `POST messages` with `model`, `messages`, optional `system`, `maxTokens` (default 1024), `temperature`, `tools` and `stopSequences`. Returns `id`, `model`, `text` (the first text block, empty on a tool call alone), `stopReason`, `usage`, `raw`. Every call bills a generation. |
+| `countTokens` | yes | `POST messages/count_tokens` with `model`, `messages`, optional `system`. Returns `inputTokens`. |
+| `listModels` | yes | `GET models`, every page. Returns `models`, `count`. |
+| `getModel` | yes | `GET models/{modelId}`; resolves an alias to its id. Returns `id`, `displayName`, `createdAt`, `maxInputTokens`, `maxTokens`, `capabilities`, `raw`. |
+| `createMessageBatch` | no | `POST messages/batches` with `requests`, an array of `{ "custom_id", "params" }` where `params` is a full message body; a single object is a batch of one. Returns `id`, `processingStatus`, `requestCounts`, `createdAt`, `endedAt`, `expiresAt`, `cancelInitiatedAt`, `resultsUrl`, `raw`. |
+| `getMessageBatch` | yes | `GET messages/batches/{batchId}`; poll it until `processingStatus` is `ended`. Same outputs. |
+| `getBatchResults` | yes | `GET messages/batches/{batchId}/results`, the JSONL parsed into `results` (`{ custom_id, result }`, matched by `custom_id`, not by order) and `count`. Before processing ends the API's own error is reported. |
+| `cancelMessageBatch` | no | `POST messages/batches/{batchId}/cancel`. Same outputs, with `cancelInitiatedAt` set. Requests already running may still finish. |
+
+Models released after Claude Opus 4.6, the default included, accept only a
+`temperature` of 1.0 and reject other values with a `400`. `stopSequences`
+takes a JSON array of strings, or one string as a single sequence; `tools`
+takes an array of `{ name, description, input_schema }`, and a tool call comes
+back as a `tool_use` block in `raw.content` with `stopReason` `tool_use`.
+
+## Checks
+
+From the repository root:
+
+```sh
+yarn typecheck && yarn test && yarn build
+node node_modules/@vornrun/connector-sdk/dist/cli.js check packages/anthropic/dist/index.js --mock --receipt packages/anthropic/verified.json
+```
+
+`packages/anthropic/scripts/check.sh` runs exactly this. Tests make no network
+calls: the client takes an injected `fetch`, clock and sleep.
+
+`packages/anthropic/scripts/check-live.sh` exits 0 with a note when
+`ANTHROPIC_API_KEY` is unset. With a key it lists models, reads
+`claude-sonnet-5`, counts the tokens of `hello`, lists five batches, then the
+batch named by `ANTHROPIC_BATCH_ID` and its results when that is set, and
+finally runs `vorn-connector check --live` against the built package. The
+same variable fills the live samples of `getMessageBatch` and
+`getBatchResults`. Nothing is generated, queued or canceled.
+
+## Built from
+
+The API reference was the only source. Every `docs.anthropic.com/en/api/…`
+page now redirects to the same path under `platform.claude.com/docs/en/api/`.
+
+- API overview: https://platform.claude.com/docs/en/api/overview
+- Get started (headers, `ANTHROPIC_API_KEY`): https://platform.claude.com/docs/en/get-started
+- Versions: https://platform.claude.com/docs/en/api/versioning
+- Create a message: https://platform.claude.com/docs/en/api/messages
+- Count tokens: https://platform.claude.com/docs/en/api/messages-count-tokens
+- List models: https://platform.claude.com/docs/en/api/models-list
+- Get a model: https://platform.claude.com/docs/en/api/models
+- Create a message batch: https://platform.claude.com/docs/en/api/creating-message-batches
+- List message batches: https://platform.claude.com/docs/en/api/listing-message-batches
+- Retrieve a message batch: https://platform.claude.com/docs/en/api/retrieving-message-batches
+- Retrieve batch results: https://platform.claude.com/docs/en/api/retrieving-message-batch-results
+- Cancel a message batch: https://platform.claude.com/docs/en/api/canceling-message-batches
+- Errors: https://platform.claude.com/docs/en/api/errors
+- Rate limits: https://platform.claude.com/docs/en/api/rate-limits
+- Create an API key: https://console.anthropic.com/settings/keys

package/dist/index.d.ts

@@ -0,0 +1,138 @@
+import * as _vornrun_connector_sdk from '@vornrun/connector-sdk';
+import { ConnectorItem } from '@vornrun/connector-sdk';
+
+interface AnthropicConnectorOptions {
+    version?: string;
+    /** Where live samples are read from; defaults to the process environment. */
+    env?: NodeJS.ProcessEnv;
+    /** Replaced in tests so a rate-limit wait costs no real time. */
+    sleep?: (ms: number) => Promise<void>;
+    /** The clock retry waits are measured on, in milliseconds. */
+    now?: () => number;
+    random?: () => number;
+}
+declare const BATCH_LOOKBACK_MS: number;
+declare const MODEL_LOOKBACK_MS: number;
+declare function createAnthropicConnector(options?: AnthropicConnectorOptions): _vornrun_connector_sdk.Connector;
+declare const connector: _vornrun_connector_sdk.Connector;
+
+declare const API_ROOT = "https://api.anthropic.com/v1";
+declare const ANTHROPIC_VERSION = "2023-06-01";
+declare const PAGE_LIMIT = 100;
+declare const MAX_LIST_PAGES = 10;
+declare const MAX_WAIT_MS = 60000;
+type Params = Record<string, unknown>;
+interface AnthropicModel {
+    id: string;
+    type?: string;
+    display_name?: string;
+    created_at?: string;
+    max_input_tokens?: number;
+    max_tokens?: number;
+    capabilities?: Record<string, unknown>;
+}
+interface RequestCounts {
+    processing?: number;
+    succeeded?: number;
+    errored?: number;
+    canceled?: number;
+    expired?: number;
+}
+interface MessageBatch {
+    id: string;
+    type?: string;
+    processing_status?: string;
+    request_counts?: RequestCounts;
+    created_at?: string;
+    ended_at?: string | null;
+    expires_at?: string;
+    archived_at?: string | null;
+    cancel_initiated_at?: string | null;
+    results_url?: string | null;
+}
+interface Page<T> {
+    data?: T[];
+    has_more?: boolean;
+    first_id?: string | null;
+    last_id?: string | null;
+}
+interface BatchResult {
+    custom_id?: string;
+    result?: Record<string, unknown>;
+}
+declare class AnthropicApiError extends Error {
+    readonly status: number;
+    readonly type: string | undefined;
+    readonly requestId: string | undefined;
+    constructor(status: number, detail: {
+        type?: string;
+        message: string;
+        requestId?: string;
+    });
+}
+declare function retryAfterMs(header: string | null, now: number): number | undefined;
+interface RateGateOptions {
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+declare function createRateGate(options?: RateGateOptions): {
+    acquire: () => Promise<void>;
+    observe: (headers: Headers) => void;
+};
+type RateGate = ReturnType<typeof createRateGate>;
+declare function parseJsonl(text: string): BatchResult[];
+interface AnthropicClientOptions {
+    apiKey: string;
+    fetch: typeof fetch;
+    gate?: RateGate;
+    /** Replaced in tests so a wait costs no real time. */
+    sleep?: (ms: number) => Promise<void>;
+    now?: () => number;
+    random?: () => number;
+}
+interface CallOptions {
+    method?: 'GET' | 'POST';
+    query?: Params;
+    body?: Params;
+    /** Read the body as text rather than JSON, for the JSONL results stream. */
+    text?: boolean;
+}
+interface ListOptions<T> {
+    maxPages?: number;
+    /** Stops the walk once a page holds an entry this says is past the window. */
+    until?: (entry: T) => boolean;
+}
+declare function createAnthropicClient(options: AnthropicClientOptions): {
+    call: <T>(path: string, callOptions?: CallOptions) => Promise<T>;
+    list: <T>(path: string, listOptions?: ListOptions<T>) => Promise<T[]>;
+    createMessage: (body: Params) => Promise<Params>;
+    countTokens: (body: Params) => Promise<{
+        input_tokens?: number;
+    }>;
+    listModels: (listOptions?: ListOptions<AnthropicModel>) => Promise<AnthropicModel[]>;
+    getModel: (id: string) => Promise<AnthropicModel>;
+    createBatch: (requests: unknown[]) => Promise<MessageBatch>;
+    listBatches: (listOptions?: ListOptions<MessageBatch>) => Promise<MessageBatch[]>;
+    getBatch: (id: string) => Promise<MessageBatch>;
+    getBatchResults: (id: string) => Promise<BatchResult[]>;
+    cancelBatch: (id: string) => Promise<MessageBatch>;
+};
+type AnthropicClient = ReturnType<typeof createAnthropicClient>;
+
+declare const DEFAULT_MODEL = "claude-sonnet-5";
+declare const DEFAULT_MAX_TOKENS = 1024;
+declare const MODEL_IDS: readonly ["claude-fable-5-1", "claude-sonnet-5", "claude-fable-5", "claude-opus-5", "claude-opus-4-8", "claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5", "claude-opus-4-5", "claude-sonnet-4-5"];
+declare const SAMPLE_BATCH: MessageBatch;
+declare const SAMPLE_MODEL: AnthropicModel;
+declare function messagesArg(value: unknown): Array<Record<string, unknown>>;
+declare function listArg(value: unknown, key: string): unknown[] | undefined;
+declare function stopSequencesArg(value: unknown): string[] | undefined;
+declare function numberArg(value: unknown, key: string): number | undefined;
+declare function firstText(content: unknown): string;
+declare function messageOutput(message: Params): Record<string, unknown>;
+declare function modelOutput(model: AnthropicModel): Record<string, unknown>;
+declare function batchOutput(batch: MessageBatch): Record<string, unknown>;
+declare function batchToItem(batch: MessageBatch): ConnectorItem;
+declare function modelToItem(model: AnthropicModel): ConnectorItem;
+
+export { ANTHROPIC_VERSION, API_ROOT, AnthropicApiError, type AnthropicClient, type AnthropicConnectorOptions, type AnthropicModel, BATCH_LOOKBACK_MS, type BatchResult, DEFAULT_MAX_TOKENS, DEFAULT_MODEL, MAX_LIST_PAGES, MAX_WAIT_MS, MODEL_IDS, MODEL_LOOKBACK_MS, type MessageBatch, PAGE_LIMIT, type Page, type RateGate, SAMPLE_BATCH, SAMPLE_MODEL, batchOutput, batchToItem, connector, createAnthropicClient, createAnthropicConnector, createRateGate, connector as default, firstText, listArg, messageOutput, messagesArg, modelOutput, modelToItem, numberArg, parseJsonl, retryAfterMs, stopSequencesArg };

package/dist/index.js

@@ -0,0 +1,753 @@
+#!/usr/bin/env node
+
+// src/connector.ts
+import {
+  defineConnector
+} from "@vornrun/connector-sdk";
+
+// src/client.ts
+var API_ROOT = "https://api.anthropic.com/v1";
+var ANTHROPIC_VERSION = "2023-06-01";
+var PAGE_LIMIT = 100;
+var MAX_LIST_PAGES = 10;
+var MAX_WAIT_MS = 6e4;
+var SERVER_ERROR_BACKOFF_MS = 1e3;
+var MAX_ERROR_BODY = 300;
+var AnthropicApiError = class extends Error {
+  status;
+  type;
+  requestId;
+  constructor(status, detail) {
+    const head = detail.type ? `${detail.type}: ${detail.message}` : detail.message;
+    super(detail.requestId ? `${head} (HTTP ${status}, request ${detail.requestId})` : `${head} (HTTP ${status})`);
+    this.name = "AnthropicApiError";
+    this.status = status;
+    this.type = detail.type;
+    this.requestId = detail.requestId;
+  }
+};
+var wait = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+function retryAfterMs(header, now) {
+  const trimmed = (header ?? "").trim();
+  if (trimmed === "") return void 0;
+  const seconds = Number(trimmed);
+  const ms = Number.isFinite(seconds) ? seconds * 1e3 : Date.parse(trimmed) - now;
+  return Number.isNaN(ms) ? void 0 : Math.min(MAX_WAIT_MS, Math.max(0, ms));
+}
+function createRateGate(options = {}) {
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? wait;
+  let resetAt;
+  async function acquire() {
+    if (resetAt === void 0) return;
+    const delay = Math.min(MAX_WAIT_MS, resetAt - now());
+    resetAt = void 0;
+    if (delay > 0) await sleep(delay);
+  }
+  function observe(headers) {
+    const remaining = headers.get("anthropic-ratelimit-requests-remaining");
+    const reset = headers.get("anthropic-ratelimit-requests-reset");
+    if (remaining === null || Number(remaining) > 0 || reset === null) return;
+    const at = Date.parse(reset);
+    if (!Number.isNaN(at)) resetAt = at;
+  }
+  return { acquire, observe };
+}
+async function describeFailure(response) {
+  const requestId = response.headers.get("request-id") ?? void 0;
+  const text2 = await response.text().catch(() => "");
+  try {
+    const parsed2 = JSON.parse(text2);
+    if (parsed2.error && typeof parsed2.error === "object") {
+      return new AnthropicApiError(response.status, {
+        ...parsed2.error.type && { type: parsed2.error.type },
+        message: parsed2.error.message ?? `Anthropic API ${response.status}`,
+        requestId: parsed2.request_id ?? requestId
+      });
+    }
+  } catch {
+  }
+  const quoted = text2.length > MAX_ERROR_BODY ? `${text2.slice(0, MAX_ERROR_BODY)}\u2026` : text2;
+  return new AnthropicApiError(response.status, {
+    message: `Anthropic API ${response.status}${quoted ? `: ${quoted}` : ""}`,
+    requestId
+  });
+}
+function compact(params) {
+  const out = {};
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null && value !== "") out[key] = value;
+  }
+  return out;
+}
+function parseJsonl(text2) {
+  return text2.split("\n").map((line) => line.trim()).filter((line) => line !== "").map((line, index) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      throw new Error(`Batch results line ${index + 1} is not JSON`);
+    }
+  });
+}
+function createAnthropicClient(options) {
+  const apiKey = options.apiKey.trim();
+  if (!apiKey) throw new Error("ANTHROPIC_API_KEY is required");
+  const gate = options.gate ?? createRateGate(options);
+  const sleep = options.sleep ?? wait;
+  const now = options.now ?? Date.now;
+  const random = options.random ?? Math.random;
+  async function call(path, callOptions = {}) {
+    const url = new URL(`${API_ROOT}/${path}`);
+    for (const [key, value] of Object.entries(compact(callOptions.query ?? {}))) {
+      url.searchParams.set(key, String(value));
+    }
+    const init = {
+      method: callOptions.method ?? "GET",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": ANTHROPIC_VERSION,
+        ...callOptions.body !== void 0 && { "content-type": "application/json" }
+      },
+      ...callOptions.body !== void 0 && { body: JSON.stringify(compact(callOptions.body)) }
+    };
+    for (let attempt = 0; ; attempt++) {
+      await gate.acquire();
+      const response = await options.fetch(url.toString(), init);
+      gate.observe(response.headers);
+      const retryAfter = retryAfterMs(response.headers.get("retry-after"), now());
+      if (attempt === 0 && response.status === 429 && retryAfter !== void 0) {
+        await sleep(retryAfter);
+        continue;
+      }
+      if (attempt === 0 && response.status >= 500) {
+        await sleep(retryAfter ?? SERVER_ERROR_BACKOFF_MS * (1 + random()));
+        continue;
+      }
+      if (!response.ok) throw await describeFailure(response);
+      const text2 = await response.text();
+      if (callOptions.text) return text2;
+      return text2 === "" ? {} : JSON.parse(text2);
+    }
+  }
+  async function list(path, listOptions = {}) {
+    const maxPages = listOptions.maxPages ?? MAX_LIST_PAGES;
+    const collected = [];
+    let afterId;
+    for (let index = 0; index < maxPages; index++) {
+      const page = await call(path, { query: { limit: PAGE_LIMIT, after_id: afterId } });
+      const entries = page.data ?? [];
+      collected.push(...entries);
+      if (listOptions.until && entries.some(listOptions.until)) break;
+      if (!page.has_more || !page.last_id) break;
+      afterId = page.last_id;
+    }
+    return collected;
+  }
+  const encoded = (id) => encodeURIComponent(id);
+  const createMessage = (body) => call("messages", { method: "POST", body });
+  const countTokens = (body) => call("messages/count_tokens", { method: "POST", body });
+  const listModels = (listOptions) => list("models", listOptions);
+  const getModel = (id) => call(`models/${encoded(id)}`);
+  const createBatch = (requests) => call("messages/batches", { method: "POST", body: { requests } });
+  const listBatches = (listOptions) => list("messages/batches", listOptions);
+  const getBatch = (id) => call(`messages/batches/${encoded(id)}`);
+  const getBatchResults = async (id) => parseJsonl(await call(`messages/batches/${encoded(id)}/results`, { text: true }));
+  const cancelBatch = (id) => call(`messages/batches/${encoded(id)}/cancel`, { method: "POST" });
+  return {
+    call,
+    list,
+    createMessage,
+    countTokens,
+    listModels,
+    getModel,
+    createBatch,
+    listBatches,
+    getBatch,
+    getBatchResults,
+    cancelBatch
+  };
+}
+
+// src/items.ts
+var DEFAULT_MODEL = "claude-sonnet-5";
+var DEFAULT_MAX_TOKENS = 1024;
+var MODEL_IDS = [
+  "claude-fable-5-1",
+  "claude-sonnet-5",
+  "claude-fable-5",
+  "claude-opus-5",
+  "claude-opus-4-8",
+  "claude-opus-4-7",
+  "claude-opus-4-6",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+  "claude-opus-4-5",
+  "claude-sonnet-4-5"
+];
+var MODELS_DOC_URL = "https://platform.claude.com/docs/en/about-claude/models/overview";
+var SAMPLE_BATCH = {
+  id: "msgbatch_013Zva2CMHLNnXjNJJKqJ2EF",
+  type: "message_batch",
+  processing_status: "ended",
+  request_counts: { processing: 0, succeeded: 50, errored: 30, canceled: 10, expired: 10 },
+  created_at: "2024-08-20T18:37:24.100435Z",
+  ended_at: "2024-08-20T18:37:24.100435Z",
+  expires_at: "2024-08-21T18:37:24.100435Z",
+  archived_at: null,
+  cancel_initiated_at: null,
+  results_url: "https://api.anthropic.com/v1/messages/batches/msgbatch_013Zva2CMHLNnXjNJJKqJ2EF/results"
+};
+var SAMPLE_MODEL = {
+  id: "claude-opus-5",
+  type: "model",
+  display_name: "Claude Opus 5",
+  created_at: "2026-07-24T00:00:00Z",
+  max_input_tokens: 1e6,
+  max_tokens: 128e3,
+  capabilities: {
+    batch: { supported: true },
+    thinking: { supported: true, types: { adaptive: { supported: true }, enabled: { supported: true } } }
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsed(value, key) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new Error(`${key} must be JSON`);
+  }
+}
+function messagesArg(value) {
+  if (value === void 0 || value === null || value === "") throw new Error("messages is required");
+  const raw = typeof value === "string" && value.trimStart().startsWith("[") ? parsed(value, "messages") : value;
+  if (typeof raw === "string") return [{ role: "user", content: raw }];
+  const turns = Array.isArray(raw) ? raw : [raw];
+  if (!turns.every(isRecord)) throw new Error("messages must be prompt text or a JSON array of { role, content } turns");
+  return turns;
+}
+function listArg(value, key) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const raw = parsed(value, key);
+  return Array.isArray(raw) ? raw : [raw];
+}
+function stopSequencesArg(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const raw = typeof value === "string" && value.trimStart().startsWith("[") ? parsed(value, "stopSequences") : value;
+  if (typeof raw === "string") return [raw];
+  if (!Array.isArray(raw)) return void 0;
+  if (raw.some((entry) => typeof entry !== "string")) throw new Error("stopSequences must be strings");
+  const sequences = raw.filter((entry) => entry !== "");
+  return sequences.length > 0 ? sequences : void 0;
+}
+function numberArg(value, key) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const number = Number(value);
+  if (!Number.isFinite(number)) throw new Error(`${key} must be a number, got "${String(value)}"`);
+  return number;
+}
+function firstText(content) {
+  if (!Array.isArray(content)) return "";
+  const block = content.find((entry) => isRecord(entry) && entry.type === "text" && typeof entry.text === "string");
+  return block ? String(block.text) : "";
+}
+function messageOutput(message) {
+  return {
+    id: message.id ?? "",
+    model: message.model ?? "",
+    text: firstText(message.content),
+    stopReason: message.stop_reason ?? "",
+    usage: message.usage ?? {},
+    raw: message
+  };
+}
+function modelOutput(model) {
+  return {
+    id: model.id ?? "",
+    displayName: model.display_name ?? "",
+    createdAt: model.created_at ?? "",
+    maxInputTokens: model.max_input_tokens ?? null,
+    maxTokens: model.max_tokens ?? null,
+    capabilities: model.capabilities ?? {},
+    raw: model
+  };
+}
+function batchOutput(batch) {
+  return {
+    id: batch.id ?? "",
+    processingStatus: batch.processing_status ?? "",
+    requestCounts: batch.request_counts ?? {},
+    createdAt: batch.created_at ?? "",
+    endedAt: batch.ended_at ?? null,
+    expiresAt: batch.expires_at ?? "",
+    cancelInitiatedAt: batch.cancel_initiated_at ?? null,
+    resultsUrl: batch.results_url ?? null,
+    raw: batch
+  };
+}
+function countsSummary(counts) {
+  const parts = ["succeeded", "errored", "canceled", "expired"].filter((key) => (counts?.[key] ?? 0) > 0).map((key) => `${counts?.[key]} ${key}`);
+  return parts.length > 0 ? parts.join(", ") : "no requests";
+}
+function batchToItem(batch) {
+  return {
+    externalId: batch.id,
+    title: `Batch ${batch.id} ended: ${countsSummary(batch.request_counts)}`,
+    status: batch.processing_status ?? "",
+    ...batch.ended_at && { updatedAt: batch.ended_at },
+    data: { ...batch }
+  };
+}
+function modelToItem(model) {
+  return {
+    externalId: model.id,
+    title: model.display_name ?? model.id,
+    url: MODELS_DOC_URL,
+    ...model.created_at && { updatedAt: model.created_at },
+    data: { ...model }
+  };
+}
+
+// package.json
+var package_default = {
+  name: "@vornrun/connector-anthropic",
+  version: "0.1.0",
+  description: "Trigger workflows when an Anthropic message batch finishes or a model becomes available, and create messages, count tokens, list models and run message batches from a step.",
+  type: "module",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/vorn-run/connectors.git",
+    directory: "packages/anthropic"
+  },
+  keywords: [
+    "vorn",
+    "connector",
+    "anthropic",
+    "claude",
+    "mcp"
+  ],
+  bin: {
+    "vorn-connector-anthropic": "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: [
+      "anthropic",
+      "claude",
+      "messages",
+      "llm",
+      "batches",
+      "tokens",
+      "models"
+    ],
+    auth: "Paste an Anthropic API key from console.anthropic.com/settings/keys for a single workspace. There is no CLI to sign in with.",
+    packs: true
+  }
+};
+
+// src/connector.ts
+var BATCH_LOOKBACK_MS = 24 * 60 * 6e4;
+var MODEL_LOOKBACK_MS = 30 * 24 * 60 * 6e4;
+var PLACEHOLDER_BATCH_ID = "msgbatch_placeholder";
+function text(value) {
+  const trimmed = String(value ?? "").trim();
+  return trimmed || void 0;
+}
+function required(config, key, env) {
+  const value = text(config[key]);
+  if (value === void 0) throw new Error(`${env} is required`);
+  return value;
+}
+function millis(value) {
+  const at = Date.parse(value ?? "");
+  return Number.isNaN(at) ? 0 : at;
+}
+var MODEL_INPUT = {
+  key: "model",
+  label: "Model",
+  description: `The model that will complete your prompt. Defaults to ${DEFAULT_MODEL}.`,
+  builderHint: `Sent as model. Ids the reference lists today: ${MODEL_IDS.join(", ")}; listModels returns the live set and getModel resolves an alias.`
+};
+var MESSAGES_INPUT = {
+  key: "messages",
+  label: "Messages",
+  required: true,
+  description: 'Prompt text, sent as one user turn, or a JSON array of { "role", "content" } turns.',
+  builderHint: 'Text becomes [{ role: "user", content: text }]; a value starting with [ is parsed as the messages array and passed through, so multi-turn and content blocks work. Consecutive turns of one role are merged by the API.'
+};
+var SYSTEM_INPUT = {
+  key: "system",
+  label: "System prompt",
+  description: "Context and instructions for the model, kept apart from the conversation.",
+  builderHint: "Sent as the top-level system string only when set; the API takes no system role inside messages."
+};
+var BATCH_ID_INPUT = {
+  key: "batchId",
+  label: "Batch",
+  required: true,
+  description: "The message batch id, msgbatch_\u2026",
+  builderHint: "Sent URL-encoded as the path segment; an unknown id answers 404 not_found_error."
+};
+var BATCH_OUTPUTS = [
+  { key: "id", description: "Batch id, msgbatch_\u2026" },
+  { key: "processingStatus", description: "in_progress, canceling or ended" },
+  { key: "requestCounts", description: "{ processing, succeeded, errored, canceled, expired }" },
+  { key: "createdAt", description: "When the batch was created, RFC 3339" },
+  { key: "endedAt", description: "When processing ended; null until then" },
+  { key: "expiresAt", description: "24 hours after creation, when unfinished requests expire" },
+  { key: "cancelInitiatedAt", description: "When cancellation was asked for, RFC 3339; null when it never was" },
+  { key: "resultsUrl", description: "Where the results stream from once processing has ended; null until then" },
+  { key: "raw", description: "The whole batch as the API returned it" }
+];
+function createAnthropicConnector(options = {}) {
+  const env = options.env ?? process.env;
+  const clock = options.now ?? Date.now;
+  const gate = createRateGate({ now: clock, ...options.sleep && { sleep: options.sleep } });
+  function client(context) {
+    return createAnthropicClient({
+      apiKey: required(context.config, "apiKey", "ANTHROPIC_API_KEY"),
+      fetch: context.fetch,
+      gate,
+      now: clock,
+      ...options.sleep && { sleep: options.sleep },
+      ...options.random && { random: options.random }
+    });
+  }
+  async function fetchEndedBatches(context) {
+    const floor = (context.since ? Date.parse(context.since) : Date.parse(context.now())) - BATCH_LOOKBACK_MS;
+    const batches = await client(context).listBatches({
+      until: (batch) => millis(batch.created_at) < floor
+    });
+    return batches.filter((batch) => batch.processing_status === "ended" && millis(batch.created_at) >= floor).sort((left, right) => millis(left.ended_at) - millis(right.ended_at)).map(batchToItem);
+  }
+  async function fetchNewModels(context) {
+    const floor = context.since ? Date.parse(context.since) : Date.parse(context.now()) - MODEL_LOOKBACK_MS;
+    const models = await client(context).listModels({
+      until: (model) => millis(model.created_at) < floor
+    });
+    return models.filter((model) => millis(model.created_at) >= floor).sort((left, right) => millis(left.created_at) - millis(right.created_at)).map(modelToItem);
+  }
+  const batchId = text(env.ANTHROPIC_BATCH_ID) ?? PLACEHOLDER_BATCH_ID;
+  return defineConnector({
+    id: "anthropic",
+    name: "Anthropic",
+    version: options.version ?? package_default.version,
+    description: "Trigger workflows when a message batch finishes or a model becomes available, and create messages, count tokens, list models and run message batches from a step.",
+    // Anthropic's crossbar-less A: the full-height right leg and the shorter left leg meeting below its apex.
+    icon: {
+      viewBox: "0 0 24 24",
+      paths: ["M9 3 15 3 22.5 21 16.5 21z", "M1.5 21 7.5 21 12.5 8.5 9.5 3.8z"]
+    },
+    auth: { rung: "key", keys: ["apiKey"] },
+    config: [
+      {
+        key: "apiKey",
+        env: "ANTHROPIC_API_KEY",
+        label: "API key",
+        secret: true,
+        required: true,
+        description: "An API key from console.anthropic.com/settings/keys, for a single workspace.",
+        builderHint: "Sent as x-api-key with anthropic-version: 2023-06-01 on every call. Keys have no scopes: a key without access answers 403 permission_error, a bad one 401 authentication_error. A multi-workspace key also needs anthropic-workspace-id, which is not sent, so use a single-workspace key. There is no CLI to borrow a login from."
+      }
+    ],
+    triggers: [
+      {
+        type: "batchEnded",
+        label: "A message batch finished",
+        description: "Fires once for each message batch whose processing has ended since the last poll, oldest first. Read the results with getBatchResults.",
+        dedupe: "timestamp",
+        fetch: fetchEndedBatches,
+        defaultWorkflow: { name: "Anthropic: finished batches", defaultCronFromMinutes: 5 },
+        sample: [batchToItem(SAMPLE_BATCH)]
+      },
+      {
+        type: "newModel",
+        label: "A model became available",
+        description: "Fires once for each model released since the last poll, oldest first. The first poll looks 30 days back.",
+        dedupe: "timestamp",
+        fetch: fetchNewModels,
+        defaultWorkflow: { name: "Anthropic: new models", defaultCronFromMinutes: 60 },
+        sample: [modelToItem(SAMPLE_MODEL)]
+      }
+    ],
+    actions: [
+      {
+        type: "createMessage",
+        label: "Create a message",
+        description: "Send a conversation to a model and get its reply. Every call bills a generation.",
+        idempotent: false,
+        inputs: [
+          MODEL_INPUT,
+          MESSAGES_INPUT,
+          SYSTEM_INPUT,
+          {
+            key: "maxTokens",
+            label: "Maximum tokens",
+            type: "number",
+            description: `The most tokens to generate before stopping; the model may stop sooner. Defaults to ${DEFAULT_MAX_TOKENS}.`,
+            builderHint: "Sent as max_tokens. The connector does not stream, so keep it modest; a large job belongs in createMessageBatch."
+          },
+          {
+            key: "temperature",
+            label: "Temperature",
+            type: "number",
+            description: "Randomness from 0.0 to 1.0. Leave unset for the default.",
+            builderHint: "Sent only when set. Models released after Claude Opus 4.6, the default model included, accept only 1.0 and reject other values with a 400."
+          },
+          {
+            key: "tools",
+            label: "Tools",
+            type: "json",
+            description: 'A JSON array of tool definitions, each { "name", "description", "input_schema" }.',
+            builderHint: "Sent as tools; a single object is taken as one tool. input_schema is a JSON schema for the tool input; a tool call comes back as a tool_use block in raw.content with stopReason tool_use."
+          },
+          {
+            key: "stopSequences",
+            label: "Stop sequences",
+            type: "json",
+            description: "A JSON array of strings that end generation when the model emits one.",
+            builderHint: 'Sent as stop_sequences; one JSON string such as "END" is taken as a single sequence. A hit sets stopReason to stop_sequence and raw.stop_sequence names it.'
+          }
+        ],
+        outputs: [
+          { key: "id", description: "Message id, msg_\u2026" },
+          { key: "model", description: "The model that answered" },
+          { key: "text", description: "The text of the first text block; empty when the model answered with a tool call alone" },
+          {
+            key: "stopReason",
+            description: "end_turn, max_tokens, stop_sequence, tool_use, pause_turn, refusal or model_context_window_exceeded"
+          },
+          { key: "usage", description: "{ input_tokens, output_tokens, cache_creation_input_tokens, cache_read_input_tokens }" },
+          { key: "raw", description: "The whole response, with every content block and stop_details" }
+        ],
+        async run(args, context) {
+          const message = await client(context).createMessage({
+            model: text(args.model) ?? DEFAULT_MODEL,
+            messages: messagesArg(args.messages),
+            system: text(args.system),
+            max_tokens: numberArg(args.maxTokens, "maxTokens") ?? DEFAULT_MAX_TOKENS,
+            temperature: numberArg(args.temperature, "temperature"),
+            tools: listArg(args.tools, "tools"),
+            stop_sequences: stopSequencesArg(args.stopSequences)
+          });
+          return messageOutput(message);
+        }
+      },
+      {
+        type: "countTokens",
+        label: "Count tokens",
+        description: "Count the tokens a conversation and system prompt would use, without creating a message.",
+        idempotent: true,
+        inputs: [MODEL_INPUT, MESSAGES_INPUT, SYSTEM_INPUT],
+        outputs: [
+          { key: "inputTokens", type: "number", description: "Tokens across the messages, system prompt and tools" }
+        ],
+        sample: { model: DEFAULT_MODEL, messages: "hello" },
+        async run(args, context) {
+          const counted = await client(context).countTokens({
+            model: text(args.model) ?? DEFAULT_MODEL,
+            messages: messagesArg(args.messages),
+            system: text(args.system)
+          });
+          return { inputTokens: counted.input_tokens ?? 0 };
+        }
+      },
+      {
+        type: "listModels",
+        label: "List models",
+        description: "The models the key can use, newest release first.",
+        idempotent: true,
+        inputs: [],
+        outputs: [
+          { key: "models", description: "One entry per model: id, display_name, created_at, max_input_tokens, max_tokens, capabilities" },
+          { key: "count", type: "number", description: "How many models came back" }
+        ],
+        sample: {},
+        async run(_args, context) {
+          const models = await client(context).listModels();
+          return { models, count: models.length };
+        }
+      },
+      {
+        type: "getModel",
+        label: "Get a model",
+        description: "Read one model by id, or resolve an alias to its model id.",
+        idempotent: true,
+        inputs: [
+          {
+            key: "modelId",
+            label: "Model",
+            required: true,
+            description: "A model id or alias, such as claude-sonnet-5.",
+            builderHint: "Sent URL-encoded as the path segment of GET models/{modelId}; an unknown id answers 404 not_found_error."
+          }
+        ],
+        outputs: [
+          { key: "id", description: "The resolved model id" },
+          { key: "displayName", description: "Human-readable name" },
+          { key: "createdAt", description: "Release time, RFC 3339; an epoch when unknown" },
+          { key: "maxInputTokens", type: "number", description: "Context window in tokens" },
+          { key: "maxTokens", type: "number", description: "Most output tokens per message" },
+          { key: "capabilities", description: "What the model supports, such as batch and thinking" },
+          { key: "raw", description: "The whole model as the API returned it" }
+        ],
+        sample: { modelId: DEFAULT_MODEL },
+        async run(args, context) {
+          return modelOutput(await client(context).getModel(String(args.modelId)));
+        }
+      },
+      {
+        type: "createMessageBatch",
+        label: "Create a message batch",
+        description: "Queue up to 100,000 message requests for asynchronous processing. Two calls queue two batches.",
+        idempotent: false,
+        inputs: [
+          {
+            key: "requests",
+            label: "Requests",
+            type: "json",
+            required: true,
+            description: 'A JSON array of { "custom_id", "params" } where params is a full createMessage body: model, max_tokens, messages, \u2026.',
+            builderHint: "Sent as requests; a single object is taken as a batch of one. custom_id matches ^[a-zA-Z0-9_-]{1,64}$ and must be unique within the batch; results come back keyed by it, not in order."
+          }
+        ],
+        outputs: BATCH_OUTPUTS,
+        async run(args, context) {
+          const batch = await client(context).createBatch(listArg(args.requests, "requests") ?? []);
+          return batchOutput(batch);
+        }
+      },
+      {
+        type: "getMessageBatch",
+        label: "Get a message batch",
+        description: "Read a batch and its request counts; poll it until processingStatus is ended.",
+        idempotent: true,
+        inputs: [BATCH_ID_INPUT],
+        outputs: BATCH_OUTPUTS,
+        sample: { batchId },
+        async run(args, context) {
+          return batchOutput(await client(context).getBatch(String(args.batchId)));
+        }
+      },
+      {
+        type: "getBatchResults",
+        label: "Get batch results",
+        description: "Read the results of an ended batch, one entry per request, matched by custom_id rather than by order.",
+        idempotent: true,
+        inputs: [BATCH_ID_INPUT],
+        outputs: [
+          {
+            key: "results",
+            description: "One entry per request: { custom_id, result } where result.type is succeeded (with result.message), errored (with result.error), canceled or expired"
+          },
+          { key: "count", type: "number", description: "How many results came back" }
+        ],
+        sample: { batchId },
+        async run(args, context) {
+          const results = await client(context).getBatchResults(String(args.batchId));
+          return { results, count: results.length };
+        }
+      },
+      {
+        type: "cancelMessageBatch",
+        label: "Cancel a message batch",
+        description: "Ask for a batch to stop; it enters canceling and requests already running may still finish.",
+        idempotent: false,
+        inputs: [BATCH_ID_INPUT],
+        outputs: BATCH_OUTPUTS,
+        async run(args, context) {
+          return batchOutput(await client(context).cancelBatch(String(args.batchId)));
+        }
+      }
+    ]
+  });
+}
+var connector = createAnthropicConnector();
+
+// 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 {
+  ANTHROPIC_VERSION,
+  API_ROOT,
+  AnthropicApiError,
+  BATCH_LOOKBACK_MS,
+  DEFAULT_MAX_TOKENS,
+  DEFAULT_MODEL,
+  MAX_LIST_PAGES,
+  MAX_WAIT_MS,
+  MODEL_IDS,
+  MODEL_LOOKBACK_MS,
+  PAGE_LIMIT,
+  SAMPLE_BATCH,
+  SAMPLE_MODEL,
+  batchOutput,
+  batchToItem,
+  connector,
+  createAnthropicClient,
+  createAnthropicConnector,
+  createRateGate,
+  index_default as default,
+  firstText,
+  listArg,
+  messageOutput,
+  messagesArg,
+  modelOutput,
+  modelToItem,
+  numberArg,
+  parseJsonl,
+  retryAfterMs,
+  stopSequencesArg
+};

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@vornrun/connector-anthropic",
+  "version": "0.1.0",
+  "description": "Trigger workflows when an Anthropic message batch finishes or a model becomes available, and create messages, count tokens, list models and run message batches from a step.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vorn-run/connectors.git",
+    "directory": "packages/anthropic"
+  },
+  "keywords": [
+    "vorn",
+    "connector",
+    "anthropic",
+    "claude",
+    "mcp"
+  ],
+  "bin": {
+    "vorn-connector-anthropic": "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": [
+      "anthropic",
+      "claude",
+      "messages",
+      "llm",
+      "batches",
+      "tokens",
+      "models"
+    ],
+    "auth": "Paste an Anthropic API key from console.anthropic.com/settings/keys for a single workspace. There is no CLI to sign in with.",
+    "packs": true
+  }
+}