agentic-assistant 0.2.0 → 0.4.0

package/dist/chunk-YMEM57LX.js

@@ -0,0 +1,305 @@
+import {
+  VERSION,
+  createPrincipal,
+  hasScope,
+  parseScope,
+  runAssistant
+} from "./chunk-C44QT474.js";
+
+// src/api.ts
+import { PRINCIPAL_KINDS } from "agentic-identity";
+import { requirePrincipal } from "agentic-identity/http";
+var MAX_BODY_BYTES = 65536;
+var MAX_MESSAGE_CHARS = 1e4;
+var MAX_REASON_CHARS = 500;
+var DEFAULT_MAX_CONCURRENT_RUNS = 4;
+var APPROVER_SCOPE = "assistant:admin";
+async function callerOf(request, auth, origins) {
+  const found = await requirePrincipal(request, auth, { origins });
+  if (found instanceof Response) return found.status === 401 ? fail(401, "sign in with a valid key", { "www-authenticate": "Bearer" }) : found;
+  return toCaller(found) ?? fail(401, "sign in with a valid key", { "www-authenticate": "Bearer" });
+}
+var json = (body, status = 200, headers = {}) => Response.json(body, { status, headers: { "cache-control": "no-store", ...headers } });
+var fail = (status, error, headers = {}) => json({ error }, status, headers);
+function toCaller(context) {
+  if (typeof context !== "object" || context === null) return void 0;
+  const { principalId, kind, chain, scopes } = context;
+  if (typeof principalId !== "string" || principalId === "" || !Array.isArray(chain) || chain.length === 0) return void 0;
+  if (!PRINCIPAL_KINDS.includes(kind)) return void 0;
+  if (chain[chain.length - 1]?.id !== principalId) return void 0;
+  if (chain[chain.length - 1]?.kind !== kind || kind === "human" && chain.length !== 1) return void 0;
+  const ids = chain.map((step) => step?.id);
+  if (ids.some((id) => typeof id !== "string" || id === "")) return void 0;
+  const rootId = ids[0];
+  if (!Array.isArray(scopes)) return void 0;
+  try {
+    for (const scope of scopes) parseScope(scope);
+  } catch {
+    return void 0;
+  }
+  return { id: principalId, kind, rootId, chain: ids, scopes: [...scopes] };
+}
+var assistantId = (caller) => `assistant:${caller.id}`;
+async function readJson(request) {
+  if (Number(request.headers.get("content-length") ?? 0) > MAX_BODY_BYTES) return void 0;
+  let text = "";
+  if (request.body !== null) {
+    const reader = request.body.getReader();
+    const decoder = new TextDecoder();
+    let bytes = 0;
+    for (; ; ) {
+      const chunk = await reader.read();
+      if (chunk.done) break;
+      bytes += chunk.value.byteLength;
+      if (bytes > MAX_BODY_BYTES) {
+        await reader.cancel();
+        return void 0;
+      }
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    text += decoder.decode();
+  }
+  try {
+    const body = JSON.parse(text);
+    return typeof body === "object" && body !== null && !Array.isArray(body) ? body : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function sseChunk(event) {
+  return new TextEncoder().encode(`event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`);
+}
+function createAssistantApi(options) {
+  const pending = /* @__PURE__ */ new Map();
+  const running = /* @__PURE__ */ new Map();
+  const maxRuns = options.maxConcurrentRuns ?? DEFAULT_MAX_CONCURRENT_RUNS;
+  function whyNotDecide(caller, entry) {
+    const { proposer } = entry;
+    if (caller.id === assistantId(proposer)) return "an agent cannot decide on its own action";
+    if (proposer.kind !== "human") {
+      if (caller.chain.includes(proposer.id) || caller.kind !== "human" && proposer.chain.includes(caller.id)) {
+        return "an agent cannot decide on its own action, or on one from an agent it made or that made it";
+      }
+    }
+    if (caller.kind !== "human" && !hasScope(caller.scopes, APPROVER_SCOPE)) {
+      return `an agent needs the ${APPROVER_SCOPE} scope to decide`;
+    }
+    const tool = options.registry.get(entry.request.tool);
+    if (tool === void 0 || !hasScope(caller.scopes, tool.scope)) return "the approver does not hold the scope of this tool";
+    return void 0;
+  }
+  const gateFor = (proposer) => ({
+    request(request, signal) {
+      return new Promise((resolve, reject) => {
+        if (signal.aborted) return reject(new Error("the request was cancelled"));
+        pending.set(request.id, { request, proposer, resolve });
+        signal.addEventListener(
+          "abort",
+          () => {
+            pending.delete(request.id);
+            reject(new Error("the request was cancelled"));
+          },
+          { once: true }
+        );
+      });
+    }
+  });
+  function chat(request, caller, message) {
+    const abort = new AbortController();
+    running.set(caller.id, (running.get(caller.id) ?? 0) + 1);
+    let released = false;
+    const release = () => {
+      if (released) return;
+      released = true;
+      const left = (running.get(caller.id) ?? 1) - 1;
+      if (left <= 0) running.delete(caller.id);
+      else running.set(caller.id, left);
+    };
+    request.signal.addEventListener(
+      "abort",
+      () => {
+        abort.abort();
+        release();
+      },
+      { once: true }
+    );
+    let events;
+    try {
+      events = runAssistant({
+        provider: options.provider(),
+        registry: options.registry,
+        // The assistant holds the caller's scopes and no more.
+        principal: createPrincipal({
+          id: assistantId(caller),
+          kind: "agent_of_human",
+          parentId: caller.id,
+          scopes: caller.scopes,
+          // Each check asks the Auth again. A key revoked during a run, or one with other scopes, stops it.
+          isRevoked: async () => {
+            const now = await callerOf(request, options.auth, options.origins);
+            return now instanceof Response || now.id !== caller.id || [...now.scopes].sort().join(" ") !== [...caller.scopes].sort().join(" ");
+          }
+        }),
+        approvals: gateFor(caller),
+        messages: [{ role: "user", content: [{ type: "text", text: message }] }],
+        system: options.system,
+        limits: options.limits,
+        signal: abort.signal
+      });
+    } catch {
+      release();
+      return fail(500, "the assistant could not start");
+    }
+    const body = new ReadableStream({
+      async pull(controller) {
+        try {
+          const next = await events.next();
+          if (next.done) {
+            release();
+            controller.close();
+          } else controller.enqueue(sseChunk(next.value));
+        } catch {
+          release();
+          controller.enqueue(sseChunk({ type: "error", error: "the run failed" }));
+          controller.close();
+        }
+      },
+      cancel() {
+        abort.abort();
+        release();
+        void events.return(void 0).catch(() => void 0);
+      }
+    });
+    return new Response(body, {
+      headers: { "content-type": "text/event-stream", "cache-control": "no-store", "x-accel-buffering": "no", "x-ai-generated": "true" }
+    });
+  }
+  async function decide(request, caller, id, approve) {
+    const body = await readJson(request);
+    if (body === void 0) return fail(400, "the body must be a JSON object");
+    const entry = pending.get(id);
+    if (entry === void 0 || entry.proposer.rootId !== caller.rootId) return fail(404, "no pending approval with this id");
+    const why = whyNotDecide(caller, entry);
+    if (why !== void 0) return fail(403, why);
+    let decision;
+    if (approve) {
+      if (body.digest !== entry.request.digest) return fail(409, "digest does not match the pending call");
+      decision = { requestId: id, approved: true, digest: entry.request.digest, decidedBy: caller.id, approverKind: caller.kind === "human" ? "human" : "agent" };
+    } else {
+      const reason = typeof body.reason === "string" ? body.reason.slice(0, MAX_REASON_CHARS) : void 0;
+      decision = { requestId: id, approved: false, decidedBy: caller.id, reason };
+    }
+    pending.delete(id);
+    entry.resolve(decision);
+    return json({ requestId: id, approved: approve, decidedBy: caller.id, machineMade: caller.kind !== "human" });
+  }
+  return {
+    async fetch(request) {
+      const url = new URL(request.url);
+      const match = /^\/api\/v1\/(tools|chat|approvals)(?:\/([^/]+)\/(approve|deny))?\/?$/.exec(url.pathname);
+      if (match === null) return fail(404, "not found");
+      const [, route, id, verb] = match;
+      const allowed = route === "chat" || verb !== void 0 ? "POST" : "GET";
+      if (request.method !== allowed) return fail(405, "method not allowed", { allow: allowed });
+      if (route !== "approvals" && id !== void 0) return fail(404, "not found");
+      const caller = await callerOf(request, options.auth, options.origins);
+      if (caller instanceof Response) return caller;
+      if (route === "tools") {
+        const tools = options.registry.list().filter((tool) => hasScope(caller.scopes, tool.scope)).map(({ name, description, scope, risk, inputSchema }) => ({ name, description, scope, risk, inputSchema }));
+        return json({ tools });
+      }
+      if (route === "approvals" && verb === void 0) {
+        const list = [...pending.values()].filter((entry) => entry.proposer.rootId === caller.rootId).filter((entry) => {
+          const tool = options.registry.get(entry.request.tool);
+          return tool !== void 0 && hasScope(caller.scopes, tool.scope);
+        }).map((entry) => ({
+          id: entry.request.id,
+          tool: entry.request.tool,
+          risk: entry.request.risk,
+          input: entry.request.input,
+          digest: entry.request.digest,
+          proposedBy: entry.request.actor,
+          requestedBy: entry.proposer.id,
+          canDecide: whyNotDecide(caller, entry) === void 0
+        }));
+        return json({ approvals: list });
+      }
+      if (route === "approvals" && id !== void 0) {
+        let requestId;
+        try {
+          requestId = decodeURIComponent(id);
+        } catch {
+          return fail(404, "no pending approval with this id");
+        }
+        return decide(request, caller, requestId, verb === "approve");
+      }
+      const body = await readJson(request);
+      const message = body?.message;
+      if (typeof message !== "string" || message.trim() === "" || message.length > MAX_MESSAGE_CHARS) {
+        return fail(400, `message must be a text of 1 to ${MAX_MESSAGE_CHARS} characters`);
+      }
+      if ((running.get(caller.id) ?? 0) >= maxRuns) return fail(429, "too many chat turns at once", { "retry-after": "5" });
+      return chat(request, caller, message);
+    }
+  };
+}
+
+// src/static-auth.ts
+var MIN_TOKEN_BYTES = 32;
+var encoder = new TextEncoder();
+async function digest(token) {
+  const hash = await crypto.subtle.digest("SHA-256", encoder.encode(token));
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function createStaticTokenAuth(tokens) {
+  const byDigest = /* @__PURE__ */ new Map();
+  for (const [token, entry] of Object.entries(tokens)) {
+    if (encoder.encode(token).length < MIN_TOKEN_BYTES) throw new Error(`tokens must hold at least ${MIN_TOKEN_BYTES} bytes`);
+    if (/\s/.test(token)) throw new Error("a token may not hold white space");
+    if (!/^[A-Za-z0-9_-]{1,512}$/.test(token)) throw new Error("a token may hold only A-Z a-z 0-9 _ - and at most 512 characters");
+    if (typeof entry !== "object" || entry === null || Object.keys(entry).some((key) => key !== "id" && key !== "scopes")) {
+      throw new Error("a token entry has only an id and scopes: every caller is a person");
+    }
+    if (typeof entry?.id !== "string" || entry.id === "" || !Array.isArray(entry.scopes) || entry.scopes.some((s) => typeof s !== "string")) {
+      throw new Error("each token needs an id and a list of scopes");
+    }
+    for (const scope of entry.scopes) parseScope(scope);
+    byDigest.set(await digest(token), {
+      principalId: entry.id,
+      kind: "human",
+      chain: [{ id: entry.id, kind: "human" }],
+      scopes: [...entry.scopes]
+    });
+  }
+  return {
+    async authenticate(request) {
+      const match = /^Bearer ([^\s]+)$/.exec(request.headers.get("authorization") ?? "");
+      const context = match ? byDigest.get(await digest(match[1])) : void 0;
+      return context ? { ...context, chain: context.chain.map((step) => ({ ...step })), scopes: [...context.scopes] } : null;
+    }
+  };
+}
+
+// src/worker.ts
+var health = (env) => Response.json({ ok: true, pack: env.PACK_NAME ?? "agentic-assistant", version: VERSION });
+function createWorker(options) {
+  const api = createAssistantApi(options);
+  return {
+    async fetch(request, env = {}) {
+      const url = new URL(request.url);
+      if (request.method === "GET" && url.pathname === "/health") return health(env);
+      if (url.pathname.startsWith("/api/v1/")) return api.fetch(request);
+      return Response.json({ error: "not found" }, { status: 404 });
+    }
+  };
+}
+
+export {
+  APPROVER_SCOPE,
+  createAssistantApi,
+  createStaticTokenAuth,
+  createWorker
+};

package/dist/cli.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { C as ChatConfig } from './chat-pBg4wRjQ.js';
-import './loop-42giKLVa.js';
+import { C as ChatConfig } from './chat-CXbhePC5.js';
+import './loop-D4qWbRu6.js';
 import './types-DGH8FS56.js';
 
 declare class UsageError extends Error {

package/dist/cli.js

@@ -4,14 +4,15 @@ import {
   buildSetup,
   readTextFile,
   runChat
-} from "./chunk-BDXAUNMR.js";
+} from "./chunk-MESH6X6N.js";
 import "./chunk-HYT732TN.js";
+import "./chunk-FQD4OK2R.js";
 import {
   TOOL_RISKS,
   VERSION,
   printable,
   provenanceLabel
-} from "./chunk-T4ZMDOB4.js";
+} from "./chunk-C44QT474.js";
 
 // src/cli.ts
 import { realpathSync } from "fs";
@@ -271,7 +272,7 @@ async function runCli(argv, io = defaultIo()) {
     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-X5VTHZVM.js");
+      const { startAssistantMcp } = await import("./mcp-server-LXGWKEHG.js");
       await startAssistantMcp(setup);
       return 0;
     }

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 };