agentic-assistant 0.1.0 → 0.3.0

package/dist/cli.js

@@ -1,30 +1,307 @@
 #!/usr/bin/env node
 import {
-  VERSION
-} from "./chunk-4QE7E5UQ.js";
+  ConfigError,
+  buildSetup,
+  readTextFile,
+  runChat
+} from "./chunk-3X6KU636.js";
+import "./chunk-HYT732TN.js";
+import "./chunk-DXTIEMOT.js";
+import {
+  TOOL_RISKS,
+  VERSION,
+  printable,
+  provenanceLabel
+} from "./chunk-3LKTJJ75.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";
+import { createInterface } from "readline/promises";
 import { pathToFileURL } from "url";
-var HELP = [
-  `agentic-assistant ${VERSION}`,
-  "An AI assistant that acts inside your apps with the user's own permissions.",
-  "",
-  "Usage: agentic-assistant [--help] [--version]"
-].join("\n");
-function runCli(argv, out = console.log, err = console.error) {
-  const [first] = argv;
-  if (first === void 0 || first === "--help" || first === "-h") {
-    out(HELP);
+import { parseArgs } from "util";
+var UsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
+var HELP = `agentic-assistant ${VERSION}
+An AI assistant that acts inside your apps with the user's own permissions.
+
+Usage:
+  agentic-assistant chat [flags] [message]   Send a message. Read stdin when there is no message.
+  agentic-assistant mcp [flags]              Start an MCP server with one tool, assistant_chat.
+
+Flags for chat and mcp:
+  --tools <target>          An https MCP URL, or a command that starts an MCP server on stdio. Required.
+  --tools-header-env <h=E>  Send header h with the value of environment variable E (http only). Repeat it.
+  --scope <scope>           A scope the assistant may hold, like notes:read. Repeat it. Required.
+  --tool-scope <scope>      The scope each tool needs. Required.
+  --tool-risk <risk>        safe, risky, or irreversible, for each tool. Default risky.
+  --approve-call <json>     Approve one exact call before the run: {"tool":"...","input":{...}}. Repeat it.
+  --approve <ask|deny>      ask: question a person on the terminal (chat only). Default deny.
+  --provider <name>         anthropic (default), openai-compatible, or scripted (for tests).
+  --model <id>              Model id. Default for anthropic: claude-sonnet-5-5.
+  --fallback-model <id>     A second model on the same provider. It answers once when --model refuses or fails.
+  --base-url <url>          Endpoint. Required for openai-compatible. https, or localhost.
+  --use-default-endpoint    Call api.anthropic.com, a US-hosted endpoint. Anthropic only.
+  --api-key-env <NAME>      Read the API key from this environment variable. Keys never go in arguments.
+  --price-in <n> --price-out <n>   US dollars per million tokens, for the cost cap.
+  --script <file>           Turns for --provider scripted.
+  --system <text>           Extra system text.
+  --user <id>               The person the assistant acts for. Default cli-user.
+  --max-turns <n> --max-tokens <n> --max-cost <usd> --max-tool-calls <n>   Run limits.
+  --json                    Print one JSON event per line on stdout (chat).
+
+Other:
+  --help, -h     Print this help.
+  --version, -V  Print the version.
+
+Exit codes: 0 the run ended normally, 1 it stopped for another reason or failed, 2 bad usage.
+`;
+var OPTIONS = {
+  tools: { type: "string" },
+  "tools-header-env": { type: "string", multiple: true },
+  scope: { type: "string", multiple: true },
+  "tool-scope": { type: "string" },
+  "tool-risk": { type: "string" },
+  "approve-call": { type: "string", multiple: true },
+  approve: { type: "string" },
+  provider: { type: "string" },
+  model: { type: "string" },
+  "fallback-model": { type: "string" },
+  "base-url": { type: "string" },
+  "use-default-endpoint": { type: "boolean" },
+  "api-key-env": { type: "string" },
+  "price-in": { type: "string" },
+  "price-out": { type: "string" },
+  script: { type: "string" },
+  system: { type: "string" },
+  user: { type: "string" },
+  "max-turns": { type: "string" },
+  "max-tokens": { type: "string" },
+  "max-cost": { type: "string" },
+  "max-tool-calls": { type: "string" },
+  json: { type: "boolean" },
+  message: { type: "string" },
+  help: { type: "boolean", short: "h" },
+  version: { type: "boolean", short: "V" }
+};
+function number(name, value, integer) {
+  if (value === void 0) return void 0;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || integer && !Number.isInteger(parsed)) {
+    throw new UsageError(`${name} needs a positive ${integer ? "whole " : ""}number, got "${value}"`);
+  }
+  return parsed;
+}
+function parseCli(argv) {
+  let parsed;
+  try {
+    parsed = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true, strict: true });
+  } catch (error) {
+    throw new UsageError(error instanceof Error ? error.message : String(error));
+  }
+  const { values, positionals } = parsed;
+  if (values.version) return { command: "version", json: false };
+  const [command, ...rest] = positionals;
+  if (values.help || command === void 0) return { command: "help", json: false };
+  if (command !== "chat" && command !== "mcp") throw new UsageError(`unknown command "${command}"`);
+  if (!values.tools) throw new UsageError("--tools is required");
+  if (!values["tool-scope"]) throw new UsageError("--tool-scope is required");
+  const risk = values["tool-risk"] ?? "risky";
+  if (!TOOL_RISKS.includes(risk)) throw new UsageError(`--tool-risk must be one of ${TOOL_RISKS.join(", ")}`);
+  const provider = values.provider ?? "anthropic";
+  if (provider !== "anthropic" && provider !== "openai-compatible" && provider !== "scripted") {
+    throw new UsageError("--provider must be anthropic, openai-compatible, or scripted");
+  }
+  const approve = values.approve ?? "deny";
+  if (approve !== "ask" && approve !== "deny") throw new UsageError("--approve must be ask or deny");
+  if (command === "mcp" && approve === "ask") throw new UsageError("--approve ask works with chat only");
+  const preApproved = (values["approve-call"] ?? []).map((text) => {
+    try {
+      const call = JSON.parse(text);
+      if (typeof call.tool !== "string" || typeof call.input !== "object" || call.input === null || Array.isArray(call.input)) throw new Error("shape");
+      return { tool: call.tool, input: call.input };
+    } catch {
+      throw new UsageError(`--approve-call needs JSON like {"tool":"name","input":{}}, got ${text.slice(0, 80)}`);
+    }
+  });
+  if (values["fallback-model"] === "") throw new UsageError("--fallback-model needs a model id");
+  const priceIn = number("--price-in", values["price-in"], false);
+  const priceOut = number("--price-out", values["price-out"], false);
+  if (priceIn === void 0 !== (priceOut === void 0)) throw new UsageError("--price-in and --price-out go together");
+  const pricing = priceIn !== void 0 && priceOut !== void 0 ? { inputPerMTok: priceIn, outputPerMTok: priceOut } : void 0;
+  const limits = {
+    maxTurns: number("--max-turns", values["max-turns"], true),
+    maxTotalTokens: number("--max-tokens", values["max-tokens"], true),
+    maxCostUsd: number("--max-cost", values["max-cost"], false),
+    maxToolCallsPerTurn: number("--max-tool-calls", values["max-tool-calls"], true)
+  };
+  for (const key of Object.keys(limits)) if (limits[key] === void 0) delete limits[key];
+  const config = {
+    tools: values.tools,
+    toolHeaderEnv: values["tools-header-env"] ?? [],
+    scopes: values.scope ?? [],
+    toolScope: values["tool-scope"],
+    toolRisk: risk,
+    provider,
+    model: values.model,
+    fallbackModel: values["fallback-model"],
+    baseUrl: values["base-url"],
+    useDefaultEndpoint: values["use-default-endpoint"] ?? false,
+    apiKeyEnv: values["api-key-env"],
+    pricing,
+    script: values.script,
+    system: values.system,
+    user: values.user ?? "cli-user",
+    limits,
+    preApproved,
+    approve
+  };
+  return { command, config, message: values.message ?? (rest.length > 0 ? rest.join(" ") : void 0), json: values.json ?? false };
+}
+function defaultIo() {
+  return {
+    out: (text) => void process.stdout.write(text),
+    err: (line) => console.error(line),
+    env: process.env,
+    readFile: readTextFile,
+    readStdin: async () => {
+      const chunks = [];
+      let size = 0;
+      for await (const chunk of process.stdin) {
+        size += chunk.length;
+        if (size > MAX_STDIN_BYTES) throw new UsageError(`the message on stdin is over ${MAX_STDIN_BYTES} bytes`);
+        chunks.push(chunk);
+      }
+      return Buffer.concat(chunks).toString("utf8");
+    },
+    isTTY: Boolean(process.stdin.isTTY),
+    ask: async (question) => {
+      const rl = createInterface({ input: process.stdin, output: process.stderr });
+      try {
+        return await rl.question(question);
+      } finally {
+        rl.close();
+      }
+    }
+  };
+}
+var oneLine = (value, max = 200) => {
+  const text = printable(typeof value === "string" ? value : JSON.stringify(value) ?? "null").replace(/\s+/g, " ");
+  const points = Array.from(text);
+  return points.length > max ? `${points.slice(0, max).join("")}...` : text;
+};
+var MAX_STDIN_BYTES = 1e6;
+var MAX_SKIPPED_LINES = 20;
+function render(event, io, state) {
+  const endText = () => {
+    if (state.inText) io.out("\n");
+    state.inText = false;
+  };
+  switch (event.type) {
+    case "text_delta":
+      if (!state.inText) io.out("Assistant (machine-made): ");
+      state.inText = true;
+      io.out(printable(event.text));
+      break;
+    case "turn_end":
+      endText();
+      if (event.answeredBy.fallback) {
+        io.err(`fallback model answered: ${oneLine(event.answeredBy.model, 100)} (first model failed: ${event.answeredBy.fallbackFor ?? "unknown"})`);
+      }
+      break;
+    case "tool_call":
+      endText();
+      io.err(`[machine-made] tool call: ${oneLine(event.name, 100)} ${oneLine(event.input)}`);
+      break;
+    case "approval_request":
+      endText();
+      io.err(`[machine-made] approval needed: ${oneLine(event.request.tool, 100)} (${event.request.risk}) ${oneLine(event.request.input)}`);
+      break;
+    case "approval_decision":
+      io.err(`approval: ${event.approved ? `approved by ${oneLine(event.decidedBy ?? "unknown", 100)}` : `not approved (${oneLine(event.reason ?? "no reason", 200)})`}`);
+      break;
+    case "tool_result":
+      io.err(`tool result (${event.isError ? "error" : "ok"}${event.denied ? `, ${event.denied}` : ""}): ${oneLine(event.content)}`);
+      break;
+    case "done":
+      endText();
+      io.err(`done: ${event.reason}. tokens in ${event.totals.inputTokens}, out ${event.totals.outputTokens}. cost $${event.totals.costUsd.toFixed(6)} (estimate)${event.error ? `. error: ${oneLine(event.error)}` : ""}`);
+      if (event.provenance !== void 0) io.err(oneLine(provenanceLabel(event.provenance), 300));
+      break;
+    default:
+      break;
+  }
+}
+async function runOnce(setup, messages, json, io) {
+  const state = { inText: false };
+  let last;
+  for await (const event of runChat(setup, messages)) {
+    if (json) io.out(`${JSON.stringify(event)}
+`);
+    else render(event, io, state);
+    if (event.type === "done") last = event;
+  }
+  return { code: last?.reason === "end_turn" ? 0 : 1, transcript: last?.messages ?? messages };
+}
+async function runCli(argv, io = defaultIo()) {
+  let parsed;
+  try {
+    parsed = parseCli(argv);
+  } catch (error) {
+    io.err(error instanceof Error ? error.message : String(error));
+    io.err('Run "agentic-assistant --help" for usage.');
+    return 2;
+  }
+  if (parsed.command === "help") {
+    io.out(HELP);
     return 0;
   }
-  if (first === "--version" || first === "-V") {
-    out(VERSION);
+  if (parsed.command === "version") {
+    io.out(`${VERSION}
+`);
     return 0;
   }
-  err(`unknown command "${first}"`);
-  err('Run "agentic-assistant --help" for usage.');
-  return 2;
+  const config = parsed.config;
+  const chatIo = { env: io.env, readFile: io.readFile, ...config.approve === "ask" && io.isTTY ? { ask: io.ask } : {} };
+  let setup;
+  try {
+    setup = await buildSetup(config, chatIo);
+    for (const skip of setup.skipped.slice(0, MAX_SKIPPED_LINES)) io.err(`skipped tool ${oneLine(skip.name, 100)}: ${oneLine(skip.reason, 200)}`);
+    if (setup.skipped.length > MAX_SKIPPED_LINES) io.err(`skipped ${setup.skipped.length - MAX_SKIPPED_LINES} more tools`);
+    if (parsed.command === "mcp") {
+      const { startAssistantMcp } = await import("./mcp-server-ZPCPYMCT.js");
+      await startAssistantMcp(setup);
+      return 0;
+    }
+    const text = parsed.message ?? (io.isTTY ? void 0 : (await io.readStdin()).trim());
+    let transcript = [];
+    if (text !== void 0 && text !== "") {
+      const { code: code2 } = await runOnce(setup, [{ role: "user", content: [{ type: "text", text }] }], parsed.json, io);
+      return code2;
+    }
+    if (!io.isTTY) throw new UsageError("give a message as an argument, with --message, or on stdin");
+    let code = 0;
+    for (; ; ) {
+      const line = (await io.ask("> ").catch(() => "exit")).trim();
+      if (line === "" || line === "exit") return code;
+      transcript = [...transcript, { role: "user", content: [{ type: "text", text: line }] }];
+      const result = await runOnce(setup, transcript, parsed.json, io);
+      transcript = result.transcript;
+      code = result.code;
+    }
+  } catch (error) {
+    if (error instanceof ConfigError || error instanceof UsageError) {
+      io.err(`${error.name}: ${oneLine(error.message, 500)}`);
+      return 2;
+    }
+    io.err(`${error instanceof Error ? error.name : "Error"}: ${oneLine(error instanceof Error ? error.message : String(error), 500)}`);
+    return 1;
+  } finally {
+    await Promise.race([setup?.close().catch(() => void 0), new Promise((resolve) => setTimeout(resolve, 5e3).unref())]);
+  }
 }
 function isMainModule() {
   const invoked = process.argv[1];
@@ -36,9 +313,16 @@ function isMainModule() {
   }
 }
 if (isMainModule()) {
-  const code = runCli(process.argv.slice(2));
-  if (code !== 0) process.exit(code);
+  runCli(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (error) => {
+      console.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  );
 }
 export {
+  UsageError,
+  parseCli,
   runCli
 };

package/dist/client.d.ts

@@ -0,0 +1,78 @@
+import { A as AssistantEvent, a as ApprovalRequest, b as Actor } from './loop-D4qWbRu6.js';
+export { D as DeniedReason, c as DoneReason, R as RunTotals } from './loop-D4qWbRu6.js';
+import './types-DGH8FS56.js';
+
+/** The error code of a failed call. The client derives it from the HTTP status and the error body. */
+type ApiErrorCode = "INVALID_INPUT" | "UNAUTHENTICATED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "CONFLICT" | "RATE_LIMITED" | "NOT_CONFIGURED" | "INTERNAL" | "UNKNOWN";
+/** Thrown for every reply that is not a success. `code` is the error code and `status` is the HTTP status. */
+declare class AssistantApiError extends Error {
+    readonly code: ApiErrorCode;
+    readonly status: number;
+    /** Seconds to wait before a new try, from `retry-after` of a 429 reply. */
+    readonly retryAfter?: number;
+    constructor(code: ApiErrorCode, status: number, message: string, retryAfter?: number);
+}
+interface ClientOptions {
+    /** The Worker origin, for example https://assistant.example.com. The client adds /api/v1. */
+    baseUrl: string;
+    /** A bearer credential that the Worker's auth accepts. */
+    token: string;
+    fetch?: typeof fetch;
+}
+/** Every method takes an optional signal. An aborted call rejects with the signal reason, not an AssistantApiError. */
+interface CallOptions {
+    signal?: AbortSignal;
+}
+interface ToolInfo {
+    name: string;
+    description: string;
+    scope: string;
+    risk: "safe" | "risky" | "irreversible";
+    inputSchema: unknown;
+}
+interface PendingApproval {
+    id: string;
+    tool: string;
+    risk: ApprovalRequest["risk"];
+    input: Record<string, unknown>;
+    /** Send this digest back to approve the exact call. */
+    digest: string;
+    proposedBy: Actor;
+    requestedBy: string;
+    /** False when this caller may not decide, for example an agent that asked for the turn. */
+    canDecide: boolean;
+}
+interface Decision {
+    requestId: string;
+    approved: boolean;
+    decidedBy: string;
+    /** True when the decider is not a person. */
+    machineMade: boolean;
+}
+interface Health {
+    ok: boolean;
+    pack: string;
+    version: string;
+}
+/** An event of the chat stream. `error` ends the stream: the run failed on the server. */
+type ChatEvent = AssistantEvent | {
+    type: "error";
+    error: string;
+};
+interface AssistantClient {
+    health(options?: CallOptions): Promise<Health>;
+    tools(options?: CallOptions): Promise<ToolInfo[]>;
+    /**
+     * Yields the events of one new conversation, ending with `done` (or `error`). The request is sent on the
+     * first read, not when you call `chat`. The stream stays open while a risky call waits for a person.
+     * Stop reading, or abort the signal, to stop the run. A stream that ends with no `done` or `error` throws.
+     */
+    chat(message: string, options?: CallOptions): AsyncGenerator<ChatEvent, void, undefined>;
+    approvals(options?: CallOptions): Promise<PendingApproval[]>;
+    /** Approves the exact call: `digest` comes from the pending call. A wrong digest is a CONFLICT. */
+    approve(id: string, digest: string, options?: CallOptions): Promise<Decision>;
+    deny(id: string, reason?: string, options?: CallOptions): Promise<Decision>;
+}
+declare function createClient(options: ClientOptions): AssistantClient;
+
+export { Actor, type ApiErrorCode, ApprovalRequest, AssistantApiError, type AssistantClient, AssistantEvent, type CallOptions, type ChatEvent, type ClientOptions, type Decision, type Health, type PendingApproval, type ToolInfo, createClient };

package/dist/client.js

@@ -0,0 +1,195 @@
+// src/client.ts
+var STATUS_CODES = {
+  400: "INVALID_INPUT",
+  401: "UNAUTHENTICATED",
+  403: "FORBIDDEN",
+  404: "NOT_FOUND",
+  405: "METHOD_NOT_ALLOWED",
+  409: "CONFLICT",
+  429: "RATE_LIMITED"
+};
+var AssistantApiError = class extends Error {
+  code;
+  status;
+  /** Seconds to wait before a new try, from `retry-after` of a 429 reply. */
+  retryAfter;
+  constructor(code, status, message, retryAfter) {
+    super(message);
+    this.name = "AssistantApiError";
+    this.code = code;
+    this.status = status;
+    this.retryAfter = retryAfter;
+  }
+};
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isString = (v) => typeof v === "string";
+var RISKS = ["safe", "risky", "irreversible"];
+var isTool = (v) => isObject(v) && isString(v.name) && isString(v.description) && isString(v.scope) && RISKS.includes(v.risk) && "inputSchema" in v;
+var isPending = (v) => isObject(v) && isString(v.id) && isString(v.tool) && RISKS.includes(v.risk) && isString(v.digest) && isObject(v.input) && isObject(v.proposedBy) && isString(v.requestedBy) && typeof v.canDecide === "boolean";
+var SHAPES = {
+  health: (v) => isObject(v) && typeof v.ok === "boolean" && isString(v.pack) && isString(v.version),
+  tools: (v) => isObject(v) && Array.isArray(v.tools) && v.tools.every(isTool),
+  approvals: (v) => isObject(v) && Array.isArray(v.approvals) && v.approvals.every(isPending),
+  decision: (v) => isObject(v) && isString(v.requestId) && typeof v.approved === "boolean" && isString(v.decidedBy) && typeof v.machineMade === "boolean"
+};
+var MAX_EVENT_CHARS = 4194304;
+var EVENT_TYPES = ["run_start", "turn_start", "text_delta", "tool_call", "approval_request", "approval_decision", "tool_result", "turn_end", "done", "error"];
+var isEvent = (v) => {
+  if (!isObject(v) || typeof v.type !== "string" || !EVENT_TYPES.includes(v.type)) return false;
+  switch (v.type) {
+    case "done":
+      return isString(v.reason) && isObject(v.totals);
+    case "error":
+      return isString(v.error);
+    case "text_delta":
+      return isString(v.text);
+    case "tool_result":
+      return isString(v.id) && isString(v.name) && isString(v.content) && typeof v.isError === "boolean";
+    case "tool_call":
+      return isString(v.id) && isString(v.name);
+    case "approval_request":
+      return isObject(v.request) && isString(v.request.id) && isString(v.request.digest);
+    case "approval_decision":
+      return isString(v.requestId) && typeof v.approved === "boolean";
+    default:
+      return true;
+  }
+};
+function createClient(options) {
+  if (typeof options.baseUrl !== "string" || options.baseUrl === "") throw new TypeError("createClient needs a baseUrl");
+  if (typeof options.token !== "string" || options.token === "") throw new TypeError("createClient needs a token");
+  let origin;
+  try {
+    origin = new URL(options.baseUrl);
+  } catch {
+    throw new TypeError("baseUrl must be an absolute URL");
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]"].includes(origin.hostname);
+  if (origin.protocol !== "https:" && !(origin.protocol === "http:" && local)) {
+    throw new TypeError("baseUrl must be an https URL, or an http URL on localhost, 127.0.0.1, or [::1]");
+  }
+  if (origin.search !== "" || origin.hash !== "" || origin.username !== "" || origin.password !== "") {
+    throw new TypeError("baseUrl must have no query, hash, or credentials");
+  }
+  const prefix = origin.pathname.replace(/\/+$/, "");
+  const root = `${origin.origin}${prefix}/api/v1`;
+  const token = options.token;
+  const send = (input, init) => {
+    const run = options.fetch ?? globalThis.fetch;
+    return run(input, init);
+  };
+  const seg = (value) => {
+    if (typeof value !== "string" || /^(?:\.|%2e){0,2}$/i.test(value)) throw new TypeError("an id must be a non-empty string that is not . or ..");
+    return encodeURIComponent(value);
+  };
+  async function request(url, method, body, callOptions, authed = true) {
+    const headers = authed ? { authorization: `Bearer ${token}` } : {};
+    if (body !== void 0) headers["content-type"] = "application/json";
+    return send(url, {
+      method,
+      headers,
+      body: body === void 0 ? void 0 : JSON.stringify(body),
+      signal: callOptions?.signal,
+      // Never follow a redirect: it would send the token to another host.
+      redirect: "manual"
+    });
+  }
+  async function failure(response) {
+    let parsed;
+    try {
+      parsed = JSON.parse(await response.text());
+    } catch {
+      parsed = void 0;
+    }
+    const error = isObject(parsed) ? parsed.error : void 0;
+    const message = isObject(parsed) && typeof parsed.message === "string" ? parsed.message : typeof error === "string" ? error : `HTTP ${response.status}`;
+    let code = STATUS_CODES[response.status] ?? (response.status >= 500 ? "INTERNAL" : "UNKNOWN");
+    if (response.status === 503 && error === "not_configured") code = "NOT_CONFIGURED";
+    if (typeof error !== "string") code = response.status >= 500 ? "INTERNAL" : "UNKNOWN";
+    const after = response.headers.get("retry-after")?.trim() ?? "";
+    return new AssistantApiError(code, response.status, message, /^\d{1,9}$/.test(after) ? Number(after) : void 0);
+  }
+  async function call(url, method, body, callOptions, shape, authed = true) {
+    const response = await request(url, method, body, callOptions, authed);
+    if (!response.ok) throw await failure(response);
+    let parsed;
+    try {
+      parsed = JSON.parse(await response.text());
+    } catch {
+      parsed = void 0;
+    }
+    if (!SHAPES[shape](parsed)) throw new AssistantApiError("UNKNOWN", response.status, `the reply is not a ${shape}`);
+    return parsed;
+  }
+  async function* chat(message, callOptions) {
+    const response = await request(`${root}/chat`, "POST", { message }, callOptions);
+    if (!response.ok) throw await failure(response);
+    if (!(response.headers.get("content-type") ?? "").startsWith("text/event-stream") || response.body === null) {
+      await response.body?.cancel();
+      throw new AssistantApiError("UNKNOWN", response.status, "the reply is not an event stream");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let ended = false;
+    function* drain(final) {
+      const text = final ? buffer : buffer.replace(/\r$/, "");
+      const normal = text.replace(/\r\n?/g, "\n");
+      const rest = buffer.slice(text.length);
+      let from = 0;
+      for (let end = normal.indexOf("\n\n", from); end >= 0; end = normal.indexOf("\n\n", from)) {
+        const event = parseBlock(normal.slice(from, end), response.status);
+        from = end + 2;
+        if (event === void 0) continue;
+        if (ended) throw new AssistantApiError("UNKNOWN", response.status, "an event came after the end of the stream");
+        ended = event.type === "done" || event.type === "error";
+        yield event;
+      }
+      buffer = normal.slice(from) + rest;
+    }
+    try {
+      for (; ; ) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        buffer += decoder.decode(chunk.value, { stream: true });
+        yield* drain(false);
+        if (buffer.length > MAX_EVENT_CHARS) throw new AssistantApiError("UNKNOWN", response.status, "an event is too long");
+      }
+      buffer += decoder.decode();
+      yield* drain(true);
+      if (!ended || buffer.trim() !== "") throw new AssistantApiError("UNKNOWN", response.status, "the stream ended before a done event");
+    } finally {
+      await reader.cancel().catch(() => void 0);
+    }
+  }
+  function parseBlock(block, status) {
+    const data = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).replace(/^ /, "")).join("\n");
+    if (data === "") return void 0;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      parsed = void 0;
+    }
+    if (!isEvent(parsed)) throw new AssistantApiError("UNKNOWN", status, "an event is not valid");
+    return parsed;
+  }
+  const decided = (id, decision) => {
+    if (decision.requestId !== id) throw new AssistantApiError("UNKNOWN", 200, "the reply is for another approval");
+    return decision;
+  };
+  const methods = {
+    // /health is outside /api/v1 and needs no token, so the client sends none.
+    health: async (o) => call(`${origin.origin}${prefix}/health`, "GET", void 0, o, "health", false),
+    tools: async (o) => (await call(`${root}/tools`, "GET", void 0, o, "tools")).tools,
+    chat,
+    approvals: async (o) => (await call(`${root}/approvals`, "GET", void 0, o, "approvals")).approvals,
+    approve: async (id, digest, o) => decided(id, await call(`${root}/approvals/${seg(id)}/approve`, "POST", { digest }, o, "decision")),
+    deny: async (id, reason, o) => decided(id, await call(`${root}/approvals/${seg(id)}/deny`, "POST", reason === void 0 ? {} : { reason }, o, "decision"))
+  };
+  return methods;
+}
+export {
+  AssistantApiError,
+  createClient
+};

package/dist/demo.d.ts

@@ -0,0 +1,21 @@
+interface DemoEnv {
+    PACK_NAME?: string;
+    /** Secret. A JSON map of bearer token (32 bytes or more) to `{ "id": "...", "scopes": ["demo:read"] }`. Unset means every call is a 401. */
+    ASSISTANT_TOKENS?: string;
+    /** Secret. The model API key. Unset means chat answers 503 "not_configured". */
+    MODEL_KEY?: string;
+    /** Base URL of the model endpoint, for example an EU-hosted gateway. */
+    MODEL_URL?: string;
+    /** Set to "1" to call api.anthropic.com, a US-hosted endpoint, when `MODEL_URL` is not set. */
+    MODEL_USE_DEFAULT_ENDPOINT?: string;
+    MODEL_NAME?: string;
+}
+/**
+ * The demo Worker. It serves a demo page at `/`, `/health`, and the `/api/v1` routes with bearer auth.
+ * It never fakes output: with no tokens every call is a 401, and with no model key chat answers 503.
+ */
+declare const _default: {
+    fetch(request: Request, env: DemoEnv): Promise<Response>;
+};
+
+export { type DemoEnv, _default as default };