agentic-assistant 0.1.0 → 0.3.0

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

package/dist/chunk-GLU222OQ.js

@@ -0,0 +1,302 @@
+import {
+  VERSION,
+  createPrincipal,
+  hasScope,
+  parseScope,
+  runAssistant
+} from "./chunk-3LKTJJ75.js";
+
+// src/api.ts
+var MAX_BODY_BYTES = 65536;
+var MAX_MESSAGE_CHARS = 1e4;
+var MAX_REASON_CHARS = 500;
+var DEFAULT_MAX_CONCURRENT_RUNS = 4;
+var KINDS = ["human", "agent_of_human", "agent_of_agent", "agent", "user_token"];
+var APPROVER_SCOPE = "assistant:admin";
+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 === "" || !KINDS.includes(kind)) return void 0;
+  if (!Array.isArray(chain) || chain.length === 0 || 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 = toCaller(await options.auth.authenticate(request));
+            return 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");
+      let caller;
+      try {
+        caller = toCaller(await options.auth.authenticate(request));
+      } catch {
+        caller = void 0;
+      }
+      if (caller === void 0) return fail(401, "sign in with a valid key", { "www-authenticate": "Bearer" });
+      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 (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/chunk-HYT732TN.js

@@ -0,0 +1,36 @@
+// src/testing.ts
+var ScriptedProvider = class {
+  constructor(script, pricing) {
+    this.script = script;
+    this.pricing = pricing;
+  }
+  script;
+  pricing;
+  name = "scripted";
+  model = "scripted-1";
+  requests = [];
+  next = 0;
+  async *stream(request) {
+    this.requests.push({ ...request, messages: structuredClone(request.messages) });
+    const turn = this.script[this.next++];
+    if (turn === void 0) throw new Error(`scripted provider ran out of turns at request ${this.next}`);
+    const content = [];
+    if (turn.text !== void 0) {
+      for (const word of turn.text.split(/(?<= )/)) yield { type: "text_delta", text: word };
+      content.push({ type: "text", text: turn.text });
+    }
+    for (const [index, call] of (turn.toolCalls ?? []).entries()) {
+      content.push({ type: "tool_use", id: call.id ?? `call_${this.next}_${index}`, name: call.name, input: call.input });
+    }
+    yield {
+      type: "message",
+      content,
+      stopReason: turn.stopReason ?? (turn.toolCalls?.length ? "tool_use" : "end_turn"),
+      usage: turn.usage ?? { inputTokens: 10, outputTokens: 5 }
+    };
+  }
+};
+
+export {
+  ScriptedProvider
+};

package/dist/chunk-T5WVSGYQ.js

@@ -0,0 +1,82 @@
+import {
+  runChat
+} from "./chunk-3X6KU636.js";
+import {
+  VERSION,
+  provenanceLabel,
+  provenanceMarker
+} from "./chunk-3LKTJJ75.js";
+
+// src/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var MAX_MESSAGE_CHARS = 1e4;
+var TOOL = {
+  name: "assistant_chat",
+  description: "Send one message to the assistant. It acts for a person with the scopes the host gave it. A risky action runs only if the host pre-approved that exact call. The reply says it is machine-made.",
+  inputSchema: {
+    type: "object",
+    properties: { message: { type: "string", minLength: 1, maxLength: MAX_MESSAGE_CHARS, description: "What to ask the assistant." } },
+    required: ["message"],
+    additionalProperties: false
+  },
+  annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: true }
+};
+var fail = (text) => ({ isError: true, content: [{ type: "text", text }] });
+function createAssistantMcpServer(setup, shutdown) {
+  const server = new Server({ name: "agentic-assistant", version: VERSION }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: [TOOL] }));
+  server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
+    if (request.params.name !== TOOL.name) return fail(`unknown tool "${request.params.name}"`);
+    const message = request.params.arguments?.message;
+    if (typeof message !== "string" || message.trim() === "" || message.length > MAX_MESSAGE_CHARS) {
+      return fail(`message must be a text of 1 to ${MAX_MESSAGE_CHARS} characters`);
+    }
+    const call = new AbortController();
+    const stop = () => call.abort();
+    extra.signal.addEventListener("abort", stop, { once: true });
+    shutdown?.addEventListener("abort", stop, { once: true });
+    if (extra.signal.aborted || shutdown?.aborted) stop();
+    let reply = "";
+    const toolCalls = [];
+    let outcome;
+    for await (const event of runChat(setup, [{ role: "user", content: [{ type: "text", text: message }] }], call.signal)) {
+      if (event.type === "text_delta") reply += event.text;
+      else if (event.type === "turn_start") reply = "";
+      else if (event.type === "tool_result") toolCalls.push({ name: event.name, isError: event.isError, ...event.denied ? { denied: event.denied } : {}, ...event.provenance ? { provenance: event.provenance } : {} });
+      else if (event.type === "done") outcome = { reason: event.reason, totals: event.totals, provenance: event.provenance };
+    }
+    extra.signal.removeEventListener("abort", stop);
+    shutdown?.removeEventListener("abort", stop);
+    const provenance = outcome?.provenance;
+    const result = {
+      machineMade: true,
+      reply,
+      reason: outcome?.reason ?? "unknown",
+      toolCalls,
+      totals: outcome?.totals,
+      ...provenance ? { provenance, label: provenanceLabel(provenance), marker: provenanceMarker(provenance) } : {}
+    };
+    return { ...outcome?.reason === "end_turn" ? {} : { isError: true }, content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
+  return server;
+}
+async function startAssistantMcp(setup) {
+  const shutdown = new AbortController();
+  const server = createAssistantMcpServer(setup, shutdown.signal);
+  const ended = new Promise((resolve) => {
+    server.onclose = resolve;
+    process.stdin.once("end", resolve);
+    process.stdin.once("close", resolve);
+  });
+  await server.connect(new StdioServerTransport());
+  await ended;
+  shutdown.abort();
+  await server.close().catch(() => void 0);
+}
+
+export {
+  createAssistantMcpServer,
+  startAssistantMcp
+};

package/dist/cli.d.ts

@@ -1,4 +1,29 @@
 #!/usr/bin/env node
-declare function runCli(argv: string[], out?: (line: string) => void, err?: (line: string) => void): number;
+import { C as ChatConfig } from './chat-CXbhePC5.js';
+import './loop-D4qWbRu6.js';
+import './types-DGH8FS56.js';
 
-export { runCli };
+declare class UsageError extends Error {
+    constructor(message: string);
+}
+interface Parsed {
+    command: "chat" | "mcp" | "help" | "version";
+    config?: ChatConfig;
+    message?: string;
+    json: boolean;
+}
+declare function parseCli(argv: string[]): Parsed;
+interface CliIo {
+    /** Final answer text and JSON events go here. */
+    out(text: string): void;
+    /** Progress, tool lines, and the summary go here. */
+    err(line: string): void;
+    env: Record<string, string | undefined>;
+    readFile(path: string): string;
+    readStdin(): Promise<string>;
+    isTTY: boolean;
+    ask(question: string): Promise<string>;
+}
+declare function runCli(argv: string[], io?: CliIo): Promise<number>;
+
+export { type CliIo, type Parsed, UsageError, parseCli, runCli };