agentic-assistant 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 0.3.0
+
+Added
+
+- `agentic-assistant/client`, a typed fetch-based client for the HTTP API: `health`, `tools`, `chat` (an async generator of events), `approvals`, `approve`, and `deny`. It has an injectable `fetch`, a base URL, and a typed `AssistantApiError`.
+- A demo Worker entry (`dist/demo.js`, built from `src/demo.ts`), `wrangler.demo.jsonc`, and `npm run deploy:demo`. It serves a demo page, `/health`, and the `/api/v1` routes with bearer auth. With no model key, chat answers 503 `not_configured`.
+- `createStaticTokenAuth`, an `agentic-identity` `Auth` for a fixed map of bearer tokens.
+- Chat responses carry the header `x-ai-generated: true`.
+- A small schema checker for hosts that refuse code generation, such as Workers. It fails closed on keywords it does not support.
+
+Removed
+
+- The default export of `agentic-assistant/worker` (a stub that answered `/health` only). Use `createWorker`.
+
+Changed
+
+- The package needs Node.js 22 or newer. `agentic-identity` needs Node 22, so `engines.node` is now `>=22`. It was `>=18`.
+- The `agentic-identity` dependency is now `^0.4.0`. It was `^0.3.0`. The exported names did not change.
+
 ## 0.2.0
 
 Added

package/README.md

@@ -7,8 +7,9 @@
 
 An AI assistant that acts inside your apps with the user's own permissions.
 
-> Status: early. The core loop, the tool sources, approvals, the React panel, the CLI, and the MCP server work.
-> There is no hosted HTTP API yet.
+> Status: early. The core loop, the tool sources, approvals, the React panel, the CLI, the MCP server, and the hosted HTTP API work.
+
+A demo Worker runs at https://agentic-assistant-demo.hello-fd1.workers.dev. `GET /` shows a demo page and `GET /health` answers 200. The `/api/v1` routes need a bearer key, so without one they answer 401. The demo has no model key set. A signed-in `POST /api/v1/chat` answers 503 with `not_configured`. The demo never fakes an answer.
 
 ## Install
 
@@ -16,7 +17,7 @@ An AI assistant that acts inside your apps with the user's own permissions.
 npm install agentic-assistant
 ```
 
-You need Node.js 18 or newer. The React panel needs `react` 18 or newer.
+You need Node.js 22 or newer. The React panel needs `react` 18 or newer.
 
 To build from source:
 
@@ -173,7 +174,9 @@ export default {
 };
 ```
 
-Every route is under `/api/v1` and needs `Authorization: Bearer <key>`. The key resolves to an `agentic-identity` principal. A person, an agent, and a token that acts for a user all work. A missing, bad, or odd credential is a 401.
+To deploy the demo Worker yourself, set the secrets `ASSISTANT_TOKENS` (a JSON map of a bearer token of 32 bytes or more to `{"id":"ana","scopes":["demo:read"]}`) and `MODEL_KEY`, set the var `MODEL_URL` (or `MODEL_USE_DEFAULT_ENDPOINT=1` to call the US-hosted `api.anthropic.com`), then run `npm run deploy:demo`. Without `MODEL_KEY`, chat answers 503. `agentic-assistant/worker` also exports `createStaticTokenAuth`, an `agentic-identity` `Auth` that reads bearer tokens from a fixed map.
+
+Every route is under `/api/v1` and needs `Authorization: Bearer <key>`. The key resolves to an `agentic-identity` principal. A person, an agent, and a token that acts for a user all work. A missing, bad, or odd credential is a 401. Every chat response has the header `x-ai-generated: true`.
 
 | Route | What it does |
 |---|---|
@@ -185,6 +188,32 @@ Every route is under `/api/v1` and needs `Authorization: Bearer <key>`. The key
 
 The assistant holds the caller's scopes and no more. A chat turn waits at a risky call until another principal decides. The stream stays open for that time. A principal that asked for the turn never decides on its own proposal: an agent gets a 403 for both approve and deny. The same holds for an agent it made and for the agent that made it. A person who asks may decide, because the assistant proposed the call. Another agent may decide only when it holds `assistant:admin` and the scope of the tool. A principal with another owner sees a 404. The list hides a call whose tool the caller has no scope for. If a client hangs up, the run stops and its pending calls go. If the key is revoked or its scopes change during a run, the run stops before its next tool call.
 
+## Use the HTTP client
+
+`agentic-assistant/client` is a typed client for the hosted API routes. It uses only `fetch`, so it runs in Workers and Node. In a browser it works on the same origin only, because the API sends no CORS headers.
+
+```ts
+import { createClient, AssistantApiError } from "agentic-assistant/client";
+
+const assistant = createClient({ baseUrl: "https://assistant.example.com", token });
+const tools = await assistant.tools();
+for await (const event of assistant.chat("Delete note n1")) {
+  if (event.type === "text_delta") process.stdout.write(event.text);
+}
+try {
+  const [pending] = await assistant.approvals();
+  if (pending?.canDecide) await assistant.approve(pending.id, pending.digest);
+} catch (error) {
+  if (error instanceof AssistantApiError) console.error(error.code, error.status);
+}
+```
+
+- The methods match the routes: `health`, `tools`, `chat`, `approvals`, `approve`, `deny`. Each takes an optional `{ signal }` as its last argument.
+- `chat` is an async generator of the same events as `runAssistant`, ending with `done`. It sends the request on the first read. A run that fails on the server ends with an `error` event. A stream that ends with no `done` or `error` throws `UNKNOWN`: the run did not finish. Stop reading to stop the run. The stream stays open while a risky call waits, so decide from another call.
+- `baseUrl` is the Worker URL: `https`, or `http` on `localhost`, `127.0.0.1`, or `[::1]`, with no query, hash, or credentials. A path prefix is for a host that strips it before the Worker. Pass `fetch` to use your own. `health` sends no token.
+- A failed call throws `AssistantApiError`. `code` is `INVALID_INPUT`, `UNAUTHENTICATED`, `FORBIDDEN`, `NOT_FOUND`, `METHOD_NOT_ALLOWED`, `CONFLICT`, `RATE_LIMITED`, `NOT_CONFIGURED`, `INTERNAL`, or `UNKNOWN`. `status` is the HTTP status. `retryAfter` is set for a 429. A `200` reply with the wrong shape fails as `UNKNOWN`.
+- The client never follows a redirect and never retries. A decision that you abort after the client sends it can still apply: read `approvals()` before you try again.
+
 ## AI transparency
 
 The package marks what the assistant makes as AI-generated. This follows the idea of EU AI Act Article 50.
@@ -232,7 +261,8 @@ The record says who made the content. It does not say the content is true.
 ## Limits
 
 - The hosted API keeps pending approvals in the memory of one Worker instance. A decision must reach the instance that holds the chat stream. Run it on one instance or behind sticky routing until a shared queue exists. It has no per-IP limit, only a cap of four chat turns at once per principal.
-- The tests run the API under Node with a fake model. They do not run it under `wrangler dev`. The sample Worker in `wrangler.jsonc` answers `/health` only.
+- The tests run the API under Node with a fake model. They do not run it under `wrangler dev`. The demo Worker was checked by hand under `wrangler dev` and on workers.dev.
+- Workers refuse code generation, so there a tool schema is checked by a small built-in checker, not by Ajv. It supports type, properties, required, additionalProperties, enum, const, items, length and size bounds, and anyOf, oneOf, allOf. It accepts annotation keywords such as `description` and `format` but does not check `format`, as the Ajv setup does not. It refuses a tool whose schema has any other keyword, such as `$ref`.
 - The CLI reads one message, or a short conversation on a terminal. It does not keep a conversation between runs.
 - The panel is tested in a simulated browser (jsdom). Contrast is checked from the CSS values. Run a screen reader and a real browser before you ship it to people who need it.
 - The panel shows plain text, not Markdown.

package/dist/{chat-pBg4wRjQ.d.ts → chat-CXbhePC5.d.ts}

@@ -1,4 +1,4 @@
-import { S as Scope, u as ToolRisk, s as ToolDefinition, R as RunLimits, t as ToolRegistry, d as ApprovalGate, h as AssistantEvent } from './loop-42giKLVa.js';
+import { S as Scope, u as ToolRisk, s as ToolDefinition, o as RunLimits, t as ToolRegistry, g as ApprovalGate, A as AssistantEvent } from './loop-D4qWbRu6.js';
 import { P as Pricing, M as ModelProvider, c as Message } from './types-DGH8FS56.js';
 
 type McpTransportConfig = {

package/dist/{chunk-T4ZMDOB4.js → chunk-3LKTJJ75.js}

@@ -1,6 +1,6 @@
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.2.0" : readPackageVersion();
+var VERSION = true ? "0.3.0" : readPackageVersion();
 
 // src/approvals.ts
 import { createHash, randomUUID } from "crypto";
@@ -216,6 +216,166 @@ function cutText(text, max) {
 
 // src/tools.ts
 import Ajv2020Module from "ajv/dist/2020.js";
+
+// src/schema-fallback.ts
+var ANNOTATIONS = /* @__PURE__ */ new Set(["$schema", "$id", "$comment", "title", "description", "default", "examples", "deprecated", "readOnly", "writeOnly", "format"]);
+var KEYWORDS = /* @__PURE__ */ new Set([
+  "type",
+  "properties",
+  "required",
+  "additionalProperties",
+  "enum",
+  "const",
+  "items",
+  "minItems",
+  "maxItems",
+  "minLength",
+  "maxLength",
+  "minimum",
+  "maximum",
+  "exclusiveMinimum",
+  "exclusiveMaximum",
+  "anyOf",
+  "oneOf",
+  "allOf",
+  "uniqueItems"
+]);
+var MAX_DEPTH = 64;
+var TYPES = ["string", "number", "integer", "boolean", "null", "object", "array"];
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function typeOf(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function isType(value, type) {
+  if (type === "integer") return typeof value === "number" && Number.isInteger(value);
+  if (type === "number") return typeof value === "number" && Number.isFinite(value);
+  return typeOf(value) === type;
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isObject(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+var same = (a, b) => canonical(a) === canonical(b);
+function assertSupported(schema, depth = 0) {
+  if (typeof schema === "boolean") return;
+  if (!isObject(schema)) throw new Error("a schema must be an object");
+  if (depth > MAX_DEPTH) throw new Error("the schema is nested too deeply");
+  for (const [key, value] of Object.entries(schema)) {
+    if (ANNOTATIONS.has(key)) continue;
+    if (!KEYWORDS.has(key)) throw new Error(`the keyword "${key}" is not supported without code generation`);
+    if (key === "type") {
+      const types = Array.isArray(value) ? value : [value];
+      if (types.some((t) => typeof t !== "string" || !TYPES.includes(t))) throw new Error("a bad type");
+    } else if (key === "properties") {
+      if (!isObject(value)) throw new Error("properties must be an object");
+      for (const child of Object.values(value)) assertSupported(child, depth + 1);
+    } else if (key === "items" || key === "additionalProperties") assertSupported(value, depth + 1);
+    else if (key === "anyOf" || key === "oneOf" || key === "allOf") {
+      if (!Array.isArray(value)) throw new Error(`${key} must be a list`);
+      for (const child of value) assertSupported(child, depth + 1);
+    } else if (key === "required") {
+      if (!Array.isArray(value) || value.some((name) => typeof name !== "string")) throw new Error("required must be a list of names");
+    } else if (key === "enum") {
+      if (!Array.isArray(value)) throw new Error("enum must be a list");
+    } else if (key === "uniqueItems") {
+      if (typeof value !== "boolean") throw new Error("uniqueItems must be true or false");
+    } else if (key !== "const" && typeof value !== "number") throw new Error(`${key} must be a number`);
+  }
+}
+function check(schema, value, path, depth) {
+  if (depth > MAX_DEPTH) throw new Error("too deep");
+  if (schema === true) return void 0;
+  if (schema === false) return { instancePath: path, message: "must not be present", params: {} };
+  const s = schema;
+  const fail = (message, params = {}) => ({ instancePath: path, message, params });
+  if (s.type !== void 0) {
+    const types = Array.isArray(s.type) ? s.type : [s.type];
+    if (!types.some((t) => isType(value, t))) return fail(`must be ${types.join(" or ")}`);
+  }
+  if ("const" in s && !same(s.const, value)) return fail("must be equal to constant");
+  if (Array.isArray(s.enum) && !s.enum.some((option) => same(option, value))) return fail("must be equal to one of the allowed values");
+  if (typeof value === "string") {
+    if (typeof s.minLength === "number" && [...value].length < s.minLength) return fail(`must NOT have fewer than ${s.minLength} characters`);
+    if (typeof s.maxLength === "number" && [...value].length > s.maxLength) return fail(`must NOT have more than ${s.maxLength} characters`);
+  }
+  if (typeof value === "number") {
+    if (typeof s.minimum === "number" && value < s.minimum) return fail(`must be >= ${s.minimum}`);
+    if (typeof s.maximum === "number" && value > s.maximum) return fail(`must be <= ${s.maximum}`);
+    if (typeof s.exclusiveMinimum === "number" && value <= s.exclusiveMinimum) return fail(`must be > ${s.exclusiveMinimum}`);
+    if (typeof s.exclusiveMaximum === "number" && value >= s.exclusiveMaximum) return fail(`must be < ${s.exclusiveMaximum}`);
+  }
+  if (Array.isArray(value)) {
+    if (typeof s.minItems === "number" && value.length < s.minItems) return fail(`must NOT have fewer than ${s.minItems} items`);
+    if (typeof s.maxItems === "number" && value.length > s.maxItems) return fail(`must NOT have more than ${s.maxItems} items`);
+    if (s.uniqueItems === true) {
+      const seen = /* @__PURE__ */ new Set();
+      for (const item of value) {
+        const text = canonical(item);
+        if (seen.has(text)) return fail("must NOT have duplicate items");
+        seen.add(text);
+      }
+    }
+    if (s.items !== void 0) {
+      for (let i = 0; i < value.length; i++) {
+        const error = check(s.items, value[i], `${path}/${i}`, depth + 1);
+        if (error) return error;
+      }
+    }
+  }
+  if (isObject(value)) {
+    for (const name of s.required ?? []) {
+      if (!Object.hasOwn(value, name)) return fail(`must have required property '${name}'`, { missingProperty: name });
+    }
+    const properties = isObject(s.properties) ? s.properties : {};
+    for (const [name, child] of Object.entries(value)) {
+      const key = `${path}/${name.replace(/~/g, "~0").replace(/\//g, "~1")}`;
+      if (Object.hasOwn(properties, name)) {
+        const error = check(properties[name], child, key, depth + 1);
+        if (error) return error;
+      } else if (s.additionalProperties === false) {
+        return fail("must NOT have additional properties", { additionalProperty: name });
+      } else if (s.additionalProperties !== void 0) {
+        const error = check(s.additionalProperties, child, key, depth + 1);
+        if (error) return error;
+      }
+    }
+  }
+  if (Array.isArray(s.allOf)) {
+    for (const child of s.allOf) {
+      const error = check(child, value, path, depth + 1);
+      if (error) return error;
+    }
+  }
+  if (Array.isArray(s.anyOf) && !s.anyOf.some((child) => check(child, value, path, depth + 1) === void 0)) return fail("must match a schema in anyOf");
+  if (Array.isArray(s.oneOf) && s.oneOf.filter((child) => check(child, value, path, depth + 1) === void 0).length !== 1) {
+    return fail("must match exactly one schema in oneOf");
+  }
+  return void 0;
+}
+function compileFallback(schema) {
+  assertSupported(schema);
+  const validate2 = (input) => {
+    const error = check(schema, input, "", 0);
+    validate2.errors = error ? [error] : null;
+    return error === void 0;
+  };
+  return validate2;
+}
+function canGenerateCode() {
+  try {
+    new Function("return 1")();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tools.ts
 function defineTool(tool) {
   return tool;
 }
@@ -233,6 +393,18 @@ var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   // One validator per registry, so an `$id` in one tool's schema cannot clash with another registry's.
   ajv = new Ajv2020({ strict: false, logger: false, allErrors: false, coerceTypes: false, useDefaults: false, removeAdditional: false });
+  /**
+   * Ajv builds validators with `new Function`. Workers refuse that inside a request, though not while a module loads.
+   * So try Ajv first, and use the small checker when this host refuses code generation. A bad schema still throws.
+   */
+  compile(schema) {
+    try {
+      return this.ajv.compile(schema);
+    } catch (error) {
+      if (canGenerateCode()) throw error;
+      return compileFallback(schema);
+    }
+  }
   register(tool) {
     if (!NAME_PATTERN.test(tool.name)) throw new Error(`invalid tool name "${tool.name}"`);
     if (this.tools.has(tool.name)) throw new Error(`tool "${tool.name}" is already registered`);
@@ -245,7 +417,7 @@ var ToolRegistry = class {
     const { $schema: _draft, $id: _id, ...schema } = tool.inputSchema;
     let validate2;
     try {
-      validate2 = this.ajv.compile(schema);
+      validate2 = this.compile(schema);
     } catch (error) {
       throw new Error(`tool "${tool.name}" has an invalid input schema: ${error instanceof Error ? error.message : String(error)}`);
     }

package/dist/{chunk-BDXAUNMR.js → chunk-3X6KU636.js}

@@ -1,6 +1,11 @@
 import {
   ScriptedProvider
 } from "./chunk-HYT732TN.js";
+import {
+  AnthropicProvider,
+  checkBaseUrl,
+  isLoopback
+} from "./chunk-DXTIEMOT.js";
 import {
   PrincipalError,
   ProviderError,
@@ -12,37 +17,12 @@ import {
   digestCall,
   printable,
   runAssistant
-} from "./chunk-T4ZMDOB4.js";
+} from "./chunk-3LKTJJ75.js";
 
 // src/sources/mcp.ts
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-
-// src/providers/url.ts
-function isLoopback(url) {
-  return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
-}
-function checkBaseUrl(baseUrl) {
-  let url;
-  try {
-    url = new URL(baseUrl);
-  } catch {
-    throw new ProviderError("baseUrl is not a valid URL");
-  }
-  if (url.username !== "" || url.password !== "") {
-    throw new ProviderError("baseUrl must not carry credentials; pass apiKey instead");
-  }
-  if (url.search !== "" || url.hash !== "") {
-    throw new ProviderError("baseUrl must not carry a query string or a fragment");
-  }
-  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url))) {
-    throw new ProviderError("baseUrl must use https, except for localhost");
-  }
-  return { url, text: baseUrl.replace(/\/+$/, "") };
-}
-
-// src/sources/mcp.ts
 var MAX_PAGES = 20;
 var MAX_SCHEMA_CHARS = 2e4;
 function positive(name, value, fallback, max = Number.MAX_SAFE_INTEGER) {
@@ -180,112 +160,6 @@ async function connectMcpTools(options) {
   }
 }
 
-// src/providers/anthropic.ts
-import Anthropic from "@anthropic-ai/sdk";
-var DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-5-5";
-var PRICING_CHECKED_ON = "2026-10-29";
-var KNOWN_PRICING = Object.freeze({
-  "claude-sonnet-5-5": Object.freeze({ inputPerMTok: 2, outputPerMTok: 10 }),
-  "claude-opus-5-5": Object.freeze({ inputPerMTok: 4, outputPerMTok: 20 })
-});
-var STOP_REASONS = {
-  end_turn: "end_turn",
-  stop_sequence: "end_turn",
-  tool_use: "tool_use",
-  max_tokens: "max_tokens",
-  refusal: "refusal"
-};
-function toAnthropicMessages(messages) {
-  return messages.map((message) => ({
-    role: message.role,
-    content: message.content.flatMap((block) => {
-      switch (block.type) {
-        case "text":
-          return block.text.length > 0 ? [{ type: "text", text: block.text }] : [];
-        case "tool_use":
-          return [{ type: "tool_use", id: block.id, name: block.name, input: block.input }];
-        case "tool_result":
-          return [{ type: "tool_result", tool_use_id: block.toolUseId, content: block.content, is_error: block.isError ?? false }];
-        case "provider_block":
-          return block.provider === "anthropic" ? [block.raw] : [];
-      }
-    })
-  }));
-}
-function fromAnthropicContent(content) {
-  return content.map((block) => {
-    if (block.type === "text") return { type: "text", text: block.text };
-    if (block.type === "tool_use") return { type: "tool_use", id: block.id, name: block.name, input: block.input };
-    return { type: "provider_block", provider: "anthropic", raw: block };
-  });
-}
-var AnthropicProvider = class {
-  name = "anthropic";
-  model;
-  pricing;
-  client;
-  effort;
-  constructor(options = {}) {
-    this.model = options.model ?? DEFAULT_ANTHROPIC_MODEL;
-    this.pricing = options.pricing ?? KNOWN_PRICING[this.model];
-    this.effort = options.effort;
-    if (options.client !== void 0) {
-      this.client = options.client;
-      return;
-    }
-    if (options.baseUrl === void 0 && options.useDefaultEndpoint !== true) {
-      throw new ProviderError("set baseUrl, or set useDefaultEndpoint: true to call api.anthropic.com, a US-hosted endpoint");
-    }
-    const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
-    if (typeof apiKey !== "string" || apiKey.length === 0) {
-      throw new ProviderError("apiKey is required: pass it, or set ANTHROPIC_API_KEY");
-    }
-    this.client = new Anthropic({
-      apiKey,
-      // Always set, so ANTHROPIC_BASE_URL in the environment cannot redirect the key.
-      baseURL: options.baseUrl !== void 0 ? checkBaseUrl(options.baseUrl).text : "https://api.anthropic.com"
-    });
-  }
-  async *stream(request) {
-    const stream = this.client.messages.stream(
-      {
-        model: this.model,
-        max_tokens: request.maxOutputTokens,
-        ...request.system !== void 0 ? { system: request.system } : {},
-        messages: toAnthropicMessages(request.messages),
-        ...request.tools.length > 0 ? {
-          tools: request.tools.map((tool) => ({
-            name: tool.name,
-            description: tool.description,
-            input_schema: tool.inputSchema
-          }))
-        } : {},
-        ...this.effort !== void 0 ? { output_config: { effort: this.effort } } : {}
-      },
-      { signal: request.signal }
-    );
-    for await (const event of stream) {
-      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
-        yield { type: "text_delta", text: event.delta.text };
-      }
-    }
-    const message = await stream.finalMessage();
-    const usage = message.usage;
-    if (typeof usage?.input_tokens !== "number" || typeof usage.output_tokens !== "number") {
-      throw new ProviderError("anthropic response carried no token usage");
-    }
-    yield {
-      type: "message",
-      content: fromAnthropicContent(message.content),
-      stopReason: STOP_REASONS[message.stop_reason ?? ""] ?? "other",
-      usage: {
-        inputTokens: usage.input_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0),
-        outputTokens: usage.output_tokens
-      }
-    };
-  }
-};
-
 // src/providers/openai-compatible.ts
 import { randomUUID } from "crypto";
 var FINISH_REASONS = {
@@ -685,9 +559,6 @@ function readTextFile(path) {
 
 export {
   connectMcpTools,
-  DEFAULT_ANTHROPIC_MODEL,
-  PRICING_CHECKED_ON,
-  AnthropicProvider,
   OpenAICompatibleProvider,
   FallbackProvider,
   ConfigError,

package/dist/chunk-DXTIEMOT.js

@@ -0,0 +1,142 @@
+import {
+  ProviderError
+} from "./chunk-3LKTJJ75.js";
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+
+// src/providers/url.ts
+function isLoopback(url) {
+  return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+}
+function checkBaseUrl(baseUrl) {
+  let url;
+  try {
+    url = new URL(baseUrl);
+  } catch {
+    throw new ProviderError("baseUrl is not a valid URL");
+  }
+  if (url.username !== "" || url.password !== "") {
+    throw new ProviderError("baseUrl must not carry credentials; pass apiKey instead");
+  }
+  if (url.search !== "" || url.hash !== "") {
+    throw new ProviderError("baseUrl must not carry a query string or a fragment");
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && isLoopback(url))) {
+    throw new ProviderError("baseUrl must use https, except for localhost");
+  }
+  return { url, text: baseUrl.replace(/\/+$/, "") };
+}
+
+// src/providers/anthropic.ts
+var DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-5-5";
+var PRICING_CHECKED_ON = "2026-10-29";
+var KNOWN_PRICING = Object.freeze({
+  "claude-sonnet-5-5": Object.freeze({ inputPerMTok: 2, outputPerMTok: 10 }),
+  "claude-opus-5-5": Object.freeze({ inputPerMTok: 4, outputPerMTok: 20 })
+});
+var STOP_REASONS = {
+  end_turn: "end_turn",
+  stop_sequence: "end_turn",
+  tool_use: "tool_use",
+  max_tokens: "max_tokens",
+  refusal: "refusal"
+};
+function toAnthropicMessages(messages) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: message.content.flatMap((block) => {
+      switch (block.type) {
+        case "text":
+          return block.text.length > 0 ? [{ type: "text", text: block.text }] : [];
+        case "tool_use":
+          return [{ type: "tool_use", id: block.id, name: block.name, input: block.input }];
+        case "tool_result":
+          return [{ type: "tool_result", tool_use_id: block.toolUseId, content: block.content, is_error: block.isError ?? false }];
+        case "provider_block":
+          return block.provider === "anthropic" ? [block.raw] : [];
+      }
+    })
+  }));
+}
+function fromAnthropicContent(content) {
+  return content.map((block) => {
+    if (block.type === "text") return { type: "text", text: block.text };
+    if (block.type === "tool_use") return { type: "tool_use", id: block.id, name: block.name, input: block.input };
+    return { type: "provider_block", provider: "anthropic", raw: block };
+  });
+}
+var AnthropicProvider = class {
+  name = "anthropic";
+  model;
+  pricing;
+  client;
+  effort;
+  constructor(options = {}) {
+    this.model = options.model ?? DEFAULT_ANTHROPIC_MODEL;
+    this.pricing = options.pricing ?? KNOWN_PRICING[this.model];
+    this.effort = options.effort;
+    if (options.client !== void 0) {
+      this.client = options.client;
+      return;
+    }
+    if (options.baseUrl === void 0 && options.useDefaultEndpoint !== true) {
+      throw new ProviderError("set baseUrl, or set useDefaultEndpoint: true to call api.anthropic.com, a US-hosted endpoint");
+    }
+    const apiKey = options.apiKey ?? process.env.ANTHROPIC_API_KEY;
+    if (typeof apiKey !== "string" || apiKey.length === 0) {
+      throw new ProviderError("apiKey is required: pass it, or set ANTHROPIC_API_KEY");
+    }
+    this.client = new Anthropic({
+      apiKey,
+      // Always set, so ANTHROPIC_BASE_URL in the environment cannot redirect the key.
+      baseURL: options.baseUrl !== void 0 ? checkBaseUrl(options.baseUrl).text : "https://api.anthropic.com"
+    });
+  }
+  async *stream(request) {
+    const stream = this.client.messages.stream(
+      {
+        model: this.model,
+        max_tokens: request.maxOutputTokens,
+        ...request.system !== void 0 ? { system: request.system } : {},
+        messages: toAnthropicMessages(request.messages),
+        ...request.tools.length > 0 ? {
+          tools: request.tools.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            input_schema: tool.inputSchema
+          }))
+        } : {},
+        ...this.effort !== void 0 ? { output_config: { effort: this.effort } } : {}
+      },
+      { signal: request.signal }
+    );
+    for await (const event of stream) {
+      if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
+        yield { type: "text_delta", text: event.delta.text };
+      }
+    }
+    const message = await stream.finalMessage();
+    const usage = message.usage;
+    if (typeof usage?.input_tokens !== "number" || typeof usage.output_tokens !== "number") {
+      throw new ProviderError("anthropic response carried no token usage");
+    }
+    yield {
+      type: "message",
+      content: fromAnthropicContent(message.content),
+      stopReason: STOP_REASONS[message.stop_reason ?? ""] ?? "other",
+      usage: {
+        inputTokens: usage.input_tokens + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0),
+        outputTokens: usage.output_tokens
+      }
+    };
+  }
+};
+
+export {
+  isLoopback,
+  checkBaseUrl,
+  DEFAULT_ANTHROPIC_MODEL,
+  PRICING_CHECKED_ON,
+  AnthropicProvider
+};