agentic-assistant 0.3.0 → 0.5.0

package/dist/chunk-QTIEDY3V.js

@@ -0,0 +1,196 @@
+// 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/{chunk-3LKTJJ75.js → chunk-RHGVOR6N.js}

@@ -1,6 +1,6 @@
 // src/version.ts
 import { createRequire } from "module";
-var VERSION = true ? "0.3.0" : readPackageVersion();
+var VERSION = true ? "0.5.0" : readPackageVersion();
 
 // src/approvals.ts
 import { createHash, randomUUID } from "crypto";

package/dist/{chunk-DXTIEMOT.js → chunk-XSRGG7SB.js}

@@ -1,6 +1,6 @@
 import {
   ProviderError
-} from "./chunk-3LKTJJ75.js";
+} from "./chunk-RHGVOR6N.js";
 
 // src/providers/anthropic.ts
 import Anthropic from "@anthropic-ai/sdk";

package/dist/cli.d.ts

@@ -1,14 +1,35 @@
 #!/usr/bin/env node
-import { C as ChatConfig } from './chat-CXbhePC5.js';
-import './loop-D4qWbRu6.js';
+import { C as ChatConfig } from './chat-CGITyrxg.js';
+import './loop-B6aowbyz.js';
 import './types-DGH8FS56.js';
 
+interface RemoteConfig {
+    api: string;
+    apiTokenEnv: string;
+}
+type RemoteCommand = {
+    name: "tools";
+} | {
+    name: "approvals";
+} | {
+    name: "approve";
+    id: string;
+    digest: string;
+} | {
+    name: "deny";
+    id: string;
+    reason?: string;
+};
+
 declare class UsageError extends Error {
     constructor(message: string);
 }
 interface Parsed {
-    command: "chat" | "mcp" | "help" | "version";
+    command: "chat" | "mcp" | "help" | "version" | "remote";
     config?: ChatConfig;
+    remote?: RemoteConfig;
+    allowApprove?: boolean;
+    remoteCommand?: RemoteCommand;
     message?: string;
     json: boolean;
 }

package/dist/cli.js

@@ -2,17 +2,21 @@
 import {
   ConfigError,
   buildSetup,
+  clientFor,
+  describeFailure,
   readTextFile,
-  runChat
-} from "./chunk-3X6KU636.js";
+  runChat,
+  runRemote
+} from "./chunk-KSVH5NNA.js";
 import "./chunk-HYT732TN.js";
-import "./chunk-DXTIEMOT.js";
+import "./chunk-XSRGG7SB.js";
 import {
   TOOL_RISKS,
   VERSION,
   printable,
   provenanceLabel
-} from "./chunk-3LKTJJ75.js";
+} from "./chunk-RHGVOR6N.js";
+import "./chunk-QTIEDY3V.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";
@@ -30,9 +34,22 @@ 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.
+  agentic-assistant mcp [flags]              Start an MCP server with the tool assistant_chat. With --api it adds three more.
+  agentic-assistant tools [flags]            List the tools of a running assistant API, with scope and risk.
+  agentic-assistant approvals [flags]        List the calls that wait for a person.
+  agentic-assistant approve <id> --digest <d> [flags]   Approve the exact call. Copy the digest from "approvals".
+  agentic-assistant deny <id> [--reason <text>] [flags] Deny the call. A denial is final.
+
+Flags for tools, approvals, approve, and deny:
+  --api <url>               The assistant API origin, like https://assistant.example.com. https, or localhost. Required.
+  --api-token-env <NAME>    Read the bearer token from this environment variable. Required. Tokens never go in arguments.
+  --digest <digest>         approve only: the digest of the pending call.
+  --reason <text>           deny only: why.
+  --json                    Print the result as JSON on stdout.
 
 Flags for chat and mcp:
+  --api <url> --api-token-env <NAME>   mcp only: also serve assistant_tools, assistant_approvals, assistant_deny.
+  --allow-approve           mcp only, with --api: also serve assistant_approve. Use an agent token (it needs assistant:admin).
   --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.
@@ -82,6 +99,11 @@ var OPTIONS = {
   "max-tokens": { type: "string" },
   "max-cost": { type: "string" },
   "max-tool-calls": { type: "string" },
+  api: { type: "string" },
+  "api-token-env": { type: "string" },
+  "allow-approve": { type: "boolean" },
+  digest: { type: "string" },
+  reason: { type: "string" },
   json: { type: "boolean" },
   message: { type: "string" },
   help: { type: "boolean", short: "h" },
@@ -106,7 +128,26 @@ function parseCli(argv) {
   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}"`);
+  const remoteNames = ["tools", "approvals", "approve", "deny"];
+  if (command !== "chat" && command !== "mcp" && !remoteNames.includes(command)) throw new UsageError(`unknown command "${command}"`);
+  if (values.api === "" || values["api-token-env"] === "") throw new UsageError("--api needs a URL, and --api-token-env a variable name");
+  if (values.api === void 0 !== (values["api-token-env"] === void 0)) throw new UsageError("--api and --api-token-env go together");
+  const remote = values.api !== void 0 && values["api-token-env"] !== void 0 ? { api: values.api, apiTokenEnv: values["api-token-env"] } : void 0;
+  if (command !== "mcp" && command !== "chat" && remote === void 0) throw new UsageError("--api and --api-token-env are required");
+  if (command === "chat" && remote !== void 0) throw new UsageError("--api works with mcp and the approval commands, not chat");
+  const wantsId = command === "approve" || command === "deny";
+  if (remoteNames.includes(command) && rest.length !== (wantsId ? 1 : 0)) throw new UsageError(wantsId ? `${command} needs one approval id` : `${command} takes no arguments`);
+  if (values["allow-approve"] && (command !== "mcp" || remote === void 0)) throw new UsageError("--allow-approve works with mcp and --api only");
+  if (command !== "approve" && values.digest !== void 0) throw new UsageError("--digest works with approve only");
+  if (command !== "deny" && values.reason !== void 0) throw new UsageError("--reason works with deny only");
+  if (remoteNames.includes(command)) {
+    const chatOnly = Object.keys(values).filter((key) => !["api", "api-token-env", "digest", "reason", "json", "help", "version"].includes(key));
+    if (chatOnly.length > 0) throw new UsageError(`--${chatOnly[0]} does not work with ${command}`);
+    const id = rest[0];
+    if (command === "approve" && !values.digest) throw new UsageError("approve needs --digest <digest>");
+    const remoteCommand = command === "approve" ? { name: "approve", id, digest: values.digest } : command === "deny" ? { name: "deny", id, ...values.reason !== void 0 ? { reason: values.reason } : {} } : { name: command };
+    return { command: "remote", remote, remoteCommand, json: values.json ?? false };
+  }
   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";
@@ -159,7 +200,7 @@ function parseCli(argv) {
     preApproved,
     approve
   };
-  return { command, config, message: values.message ?? (rest.length > 0 ? rest.join(" ") : void 0), json: values.json ?? false };
+  return { command, config, remote, allowApprove: values["allow-approve"] ?? false, message: values.message ?? (rest.length > 0 ? rest.join(" ") : void 0), json: values.json ?? false };
 }
 function defaultIo() {
   return {
@@ -264,16 +305,30 @@ async function runCli(argv, io = defaultIo()) {
 `);
     return 0;
   }
+  if (parsed.command === "remote") {
+    try {
+      const client = clientFor(parsed.remote, io.env);
+      const { data, text } = await runRemote(client, parsed.remoteCommand);
+      io.out(parsed.json ? `${JSON.stringify(data)}
+` : `${text}
+`);
+      return 0;
+    } catch (error) {
+      io.err(error instanceof ConfigError ? `${error.name}: ${oneLine(error.message, 500)}` : describeFailure(error));
+      return error instanceof ConfigError ? 2 : 1;
+    }
+  }
   const config = parsed.config;
   const chatIo = { env: io.env, readFile: io.readFile, ...config.approve === "ask" && io.isTTY ? { ask: io.ask } : {} };
   let setup;
   try {
+    const remote = parsed.command === "mcp" && parsed.remote !== void 0 ? clientFor(parsed.remote, io.env) : void 0;
     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);
+      const { startAssistantMcp } = await import("./mcp-server-U3UQIB7H.js");
+      await startAssistantMcp(setup, remote, { approve: parsed.allowApprove ?? false });
       return 0;
     }
     const text = parsed.message ?? (io.isTTY ? void 0 : (await io.readStdin()).trim());

package/dist/client.d.ts

@@ -1,5 +1,5 @@
-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 { h as AssistantEvent, e as ApprovalRequest, b as Actor } from './loop-B6aowbyz.js';
+export { j as DeniedReason, k as DoneReason, p as RunTotals } from './loop-B6aowbyz.js';
 import './types-DGH8FS56.js';
 
 /** The error code of a failed call. The client derives it from the HTTP status and the error body. */

package/dist/client.js

@@ -1,194 +1,7 @@
-// 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;
-}
+import {
+  AssistantApiError,
+  createClient
+} from "./chunk-QTIEDY3V.js";
 export {
   AssistantApiError,
   createClient

package/dist/demo.js

@@ -1,14 +1,15 @@
 import {
   createStaticTokenAuth,
   createWorker
-} from "./chunk-GLU222OQ.js";
+} from "./chunk-PRQTL5VS.js";
 import {
   AnthropicProvider
-} from "./chunk-DXTIEMOT.js";
+} from "./chunk-XSRGG7SB.js";
 import {
   ToolRegistry,
-  VERSION
-} from "./chunk-3LKTJJ75.js";
+  VERSION,
+  hasScope
+} from "./chunk-RHGVOR6N.js";
 
 // src/demo-page.ts
 var DEMO_CSP = "default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'";
@@ -103,6 +104,7 @@ var demoRegistry = () => new ToolRegistry().register({
   risk: "safe",
   handler: () => ({ now: (/* @__PURE__ */ new Date()).toISOString() })
 });
+var DEMO_SCOPE = "demo:read";
 var DEMO_SYSTEM = "You are a demo assistant. You may use the demo_time tool. Answer in short, plain text.";
 function modelOptions(env) {
   if (!env.MODEL_KEY) return void 0;
@@ -117,6 +119,8 @@ async function buildDemo(env) {
   const auth = await createStaticTokenAuth(tokens);
   const worker = createWorker({
     auth,
+    // A token without `demo:read` signs in but may use no route.
+    routeScopes: { tools: DEMO_SCOPE, chat: DEMO_SCOPE, approvals: DEMO_SCOPE },
     registry: demoRegistry(),
     system: DEMO_SYSTEM,
     limits: { maxTurns: 4, maxTotalTokens: 2e4, maxOutputTokensPerTurn: 1024 },
@@ -148,7 +152,8 @@ var demo_default = {
       return notConfigured("this demo is not set up");
     }
     if (request.method === "POST" && url.pathname.replace(/\/$/, "") === "/api/v1/chat" && modelOptions(env) === void 0) {
-      if (await demo.auth.authenticate(request.clone()) !== null) return notConfigured("this demo has no model key or model endpoint set");
+      const who = await demo.auth.authenticate(request.clone());
+      if (who !== null && hasScope(who.scopes, DEMO_SCOPE)) return notConfigured("this demo has no model key or model endpoint set");
     }
     return demo.worker.fetch(request, env);
   }