agentic-assistant 0.1.0 → 0.2.0

package/dist/{loop-CDbbDwSs.d.ts → loop-42giKLVa.d.ts}

@@ -1,4 +1,4 @@
-import { J as JsonSchema, U as Usage, c as Message, M as ModelProvider } from './types-C47SyHH5.js';
+import { J as JsonSchema, U as Usage, A as AnsweredBy, c as Message, M as ModelProvider } from './types-DGH8FS56.js';
 
 declare const ACTIONS: readonly ["read", "comment", "write", "admin"];
 type Action = (typeof ACTIONS)[number];
@@ -65,11 +65,14 @@ interface ApprovalRequest {
     digest: string;
     actor: Actor;
 }
+/** Who gave an approval. The gate says it. `human` means a signed-in person, `host` means a rule the host set up, `agent` means another agent. */
+type ApproverKind = "human" | "agent" | "host";
 type ApprovalDecision = {
     requestId: string;
     approved: true;
     digest: string;
-    decidedBy: string;
+    decidedBy: string; /** Leave it out when you do not know. The record then says "unknown". */
+    approverKind?: ApproverKind;
 } | {
     requestId: string;
     approved: false;
@@ -100,11 +103,57 @@ declare class QueueApprovalGate implements ApprovalGate {
     private readonly waiting;
     pending(): ApprovalRequest[];
     request(request: ApprovalRequest, signal: AbortSignal): Promise<ApprovalDecision>;
-    approve(id: string, decidedBy: string): void;
+    approve(id: string, decidedBy: string, approverKind?: ApproverKind): void;
     reject(id: string, decidedBy?: string, reason?: string): void;
     private take;
 }
 
+/** Says that a machine made an output, and which one. Attach it to every result and every edit. */
+interface Provenance {
+    generator: "ai";
+    /** The model that answered. After a fallback, this is the fallback model. */
+    model: string;
+    provider: string;
+    /** ISO 8601 time, in UTC. */
+    createdAt: string;
+    /** The id of the assistant principal that acted. */
+    actor: string;
+    /** The person the assistant acts for. */
+    onBehalfOf: string;
+    /** The tool that ran. Set on a tool result. */
+    tool?: string;
+    /** The risk of that tool. A host may mark only `risky` and `irreversible` results as edits. */
+    risk?: "safe" | "risky" | "irreversible";
+    /** Who approved the action, and what kind of approver it was. Check `kind` before you say a person approved. */
+    approvedBy?: Approver[];
+}
+interface Approver {
+    id: string;
+    /** `unknown` when the approval gate did not say. */
+    kind: ApproverKind | "unknown";
+}
+interface ProvenanceInput {
+    model: string;
+    provider: string;
+    /** Epoch milliseconds. */
+    createdAt: number;
+    actor: string;
+    onBehalfOf: string;
+    tool?: string;
+    risk?: Provenance["risk"];
+    approvedBy?: readonly Approver[];
+}
+/** The IPTC digital source type for content made by a model. */
+declare const TRAINED_ALGORITHMIC_MEDIA = "http://cv.iptc.org/newscodes/digitalsourcetype/trainedAlgorithmicMedia";
+declare function createProvenance(input: ProvenanceInput): Provenance;
+/**
+ * A JSON-LD marker for a document or a file. Store it next to the content the assistant made.
+ * It uses schema.org terms and the IPTC `trainedAlgorithmicMedia` source type.
+ */
+declare function provenanceMarker(provenance: Provenance): Record<string, unknown>;
+/** A short text for a person to read, such as "AI-generated by model-1 (acme), approved by ana". */
+declare function provenanceLabel(provenance: Provenance): string;
+
 interface ToolContext {
     principal: AssistantPrincipal;
     toolUseId: string;
@@ -191,7 +240,8 @@ type AssistantEvent = {
 } | {
     type: "approval_decision";
     requestId: string;
-    approved: boolean;
+    approved: boolean; /** True only when the approver said no. A timeout or a gate failure is not a decline. */
+    declined: boolean;
     decidedBy?: string;
     reason?: string;
 } | {
@@ -206,18 +256,22 @@ type AssistantEvent = {
     /** The raw failure text. It stays in the event and never goes to the model. */
     detail?: string;
     actor: Actor;
+    /** Marks the result as machine-made. Set when the tool ran. */
+    provenance?: Provenance;
 } | {
     type: "turn_end";
     turn: number;
     usage: Usage;
-    totals: RunTotals;
+    totals: RunTotals; /** The model that answered this turn. */
+    answeredBy: AnsweredBy;
 } | {
     type: "done";
     reason: DoneReason;
     totals: RunTotals;
     actor: Actor;
     messages: Message[];
-    error?: string;
+    error?: string; /** Marks the answer as machine-made. Set once a model has answered. */
+    provenance?: Provenance;
 };
 /** Sent with every request. Tool output is data, never an instruction. */
 declare const DATA_NOTICE: string;
@@ -228,4 +282,4 @@ declare const DATA_NOTICE: string;
  */
 declare function runAssistant(options: RunOptions): AsyncGenerator<AssistantEvent>;
 
-export { ACTIONS as A, DATA_NOTICE as D, PrincipalError as P, QueueApprovalGate as Q, type RunLimits as R, type Scope as S, type ToolRisk as T, type ToolDefinition as a, type Action as b, type Actor as c, type ApprovalDecision as d, type ApprovalGate as e, type ApprovalRequest as f, type AssistantEvent as g, type AssistantPrincipal as h, type DeniedReason as i, type DoneReason as j, type PrincipalInput as k, type RunOptions as l, type RunTotals as m, TOOL_RISKS as n, type ToolContext as o, ToolRegistry as p, actorOf as q, assertPrincipal as r, canonicalJson as s, createPrincipal as t, defineTool as u, digestCall as v, hasScope as w, parseScope as x, runAssistant as y, scopeCovers as z };
+export { ACTIONS as A, defineTool as B, digestCall as C, DATA_NOTICE as D, hasScope as E, parseScope as F, provenanceLabel as G, provenanceMarker as H, runAssistant as I, scopeCovers as J, PrincipalError as P, QueueApprovalGate as Q, type RunLimits as R, type Scope as S, TOOL_RISKS as T, type Action as a, type Actor as b, type ApprovalDecision as c, type ApprovalGate as d, type ApprovalRequest as e, type Approver as f, type ApproverKind as g, type AssistantEvent as h, type AssistantPrincipal as i, type DeniedReason as j, type DoneReason as k, type PrincipalInput as l, type Provenance as m, type ProvenanceInput as n, type RunOptions as o, type RunTotals as p, TRAINED_ALGORITHMIC_MEDIA as q, type ToolContext as r, type ToolDefinition as s, ToolRegistry as t, type ToolRisk as u, actorOf as v, assertPrincipal as w, canonicalJson as x, createPrincipal as y, createProvenance as z };

package/dist/mcp-server-X5VTHZVM.js

@@ -0,0 +1,11 @@
+import {
+  createAssistantMcpServer,
+  startAssistantMcp
+} from "./chunk-6UD2QQA4.js";
+import "./chunk-BDXAUNMR.js";
+import "./chunk-HYT732TN.js";
+import "./chunk-T4ZMDOB4.js";
+export {
+  createAssistantMcpServer,
+  startAssistantMcp
+};

package/dist/react.d.ts

@@ -1,6 +1,6 @@
 import * as react from 'react';
-import { g as AssistantEvent, T as ToolRisk } from './loop-CDbbDwSs.js';
-import { c as Message } from './types-C47SyHH5.js';
+import { h as AssistantEvent, u as ToolRisk } from './loop-42giKLVa.js';
+import { c as Message } from './types-DGH8FS56.js';
 
 type PanelItem = {
     kind: "user";

package/dist/react.js

@@ -41,6 +41,7 @@ function useAssistant(options) {
     const sent = [...history.current, userMessage];
     let streamingId = null;
     let finished = false;
+    let failed = false;
     const toolItems = /* @__PURE__ */ new Map();
     let lastToolItem = null;
     try {
@@ -81,7 +82,7 @@ function useAssistant(options) {
               event.requestId,
               (item) => item.kind === "approval" ? {
                 ...item,
-                status: event.approved ? "approved" : event.reason === "the person declined" ? "declined" : "unavailable",
+                status: event.approved ? "approved" : event.declined ? "declined" : "unavailable",
                 busy: false,
                 decidedBy: event.decidedBy
               } : item
@@ -109,11 +110,16 @@ function useAssistant(options) {
         }
       }
     } catch {
-      add({ kind: "notice", id: nextId(), text: RUN_FAILED });
+      failed = true;
     } finally {
-      if (!finished) history.current = sent;
+      if (!finished) {
+        history.current = sent;
+        if (!failed) failed = true;
+      }
+      if (failed) add({ kind: "notice", id: nextId(), text: RUN_FAILED });
       setItems(
         (current) => current.map((item) => {
+          if (item.kind === "assistant" && item.streaming) return { ...item, streaming: false };
           if (item.kind === "approval" && item.status === "pending") return { ...item, status: "expired", busy: false };
           if (item.kind === "tool" && (item.status === "running" || item.status === "waiting")) return { ...item, status: "not_run" };
           return item;

package/dist/testing.d.ts

@@ -1,4 +1,4 @@
-import { M as ModelProvider, P as Pricing, a as ModelRequest, S as StopReason, U as Usage, b as ModelEvent } from './types-C47SyHH5.js';
+import { M as ModelProvider, P as Pricing, a as ModelRequest, S as StopReason, U as Usage, b as ModelEvent } from './types-DGH8FS56.js';
 
 interface ScriptedTurn {
     text?: string;
@@ -19,7 +19,7 @@ declare class ScriptedProvider implements ModelProvider {
     private readonly script;
     readonly pricing?: Pricing | undefined;
     readonly name = "scripted";
-    readonly model = "scripted-1";
+    readonly model: string;
     readonly requests: ModelRequest[];
     private next;
     constructor(script: readonly ScriptedTurn[], pricing?: Pricing | undefined);

package/dist/testing.js

@@ -1,35 +1,6 @@
-// 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 }
-    };
-  }
-};
+import {
+  ScriptedProvider
+} from "./chunk-HYT732TN.js";
 export {
   ScriptedProvider
 };

package/dist/{types-C47SyHH5.d.ts → types-DGH8FS56.d.ts}

@@ -41,6 +41,15 @@ interface ModelRequest {
     maxOutputTokens: number;
     signal?: AbortSignal;
 }
+/** Which model gave an answer. A provider that picks between models sets it on the final message. */
+interface AnsweredBy {
+    provider: string;
+    model: string;
+    /** True when a fallback model answered. */
+    fallback: boolean;
+    /** Why the first model did not answer. Set only when `fallback` is true. */
+    fallbackFor?: "refusal" | "error";
+}
 type ModelEvent = {
     type: "text_delta";
     text: string;
@@ -49,6 +58,7 @@ type ModelEvent = {
     content: ContentBlock[];
     stopReason: StopReason;
     usage: Usage;
+    answeredBy?: AnsweredBy;
 };
 /** Prices in US dollars per million tokens. */
 interface Pricing {
@@ -63,10 +73,12 @@ interface ModelProvider {
     readonly name: string;
     readonly model: string;
     readonly pricing?: Pricing;
+    /** Most requests one `stream` call may send to a model. Default 1. The loop counts the input of each in its caps. */
+    readonly maxAsks?: number;
     stream(request: ModelRequest): AsyncIterable<ModelEvent>;
 }
 declare class ProviderError extends Error {
     constructor(message: string);
 }
 
-export { type ContentBlock as C, type JsonSchema as J, type ModelProvider as M, type Pricing as P, type StopReason as S, type ToolSpec as T, type Usage as U, type ModelRequest as a, type ModelEvent as b, type Message as c, ProviderError as d };
+export { type AnsweredBy as A, type ContentBlock as C, type JsonSchema as J, type ModelProvider as M, type Pricing as P, type StopReason as S, type ToolSpec as T, type Usage as U, type ModelRequest as a, type ModelEvent as b, type Message as c, ProviderError as d };

package/dist/worker.d.ts

@@ -1,8 +1,41 @@
+import { Auth } from 'agentic-identity';
+import { t as ToolRegistry, R as RunLimits } from './loop-42giKLVa.js';
+import { M as ModelProvider } from './types-DGH8FS56.js';
+
+interface AssistantApiOptions {
+    /** Reads the credential on a request. Use an `agentic-identity` Auth, such as `createStoreAuth`. */
+    auth: Auth;
+    /** Makes the model for one chat turn. Called once per request, so a provider may keep state. */
+    provider(): ModelProvider;
+    /** The tools the assistant may use. Each one has a scope and a risk. */
+    registry: ToolRegistry;
+    system?: string;
+    limits?: RunLimits;
+    /** Most chat turns one principal may run at once. Default 4. */
+    maxConcurrentRuns?: number;
+}
+/** An agent needs this scope before it may decide on a tool call. A person needs no extra scope. */
+declare const APPROVER_SCOPE = "assistant:admin";
+/**
+ * The hosted API, under `/api/v1`: `GET /tools`, `POST /chat` (a stream of server-sent events),
+ * `GET /approvals`, and `POST /approvals/:id/approve` or `/deny`. Every route needs a principal.
+ *
+ * A pending approval lives in the memory of this object. Run chat and approval on one instance.
+ */
+declare function createAssistantApi(options: AssistantApiOptions): {
+    fetch(request: Request): Promise<Response>;
+};
+
 interface WorkerEnv {
     PACK_NAME?: string;
 }
+/** A Worker that serves `/health` and the `/api/v1` routes. Build the options in your own entry file. */
+declare function createWorker(options: AssistantApiOptions): {
+    fetch(request: Request, env?: WorkerEnv): Promise<Response>;
+};
+/** The sample Worker has no auth, tools, or model, so it serves `/health` only. Use `createWorker` for the API. */
 declare const _default: {
     fetch(request: Request, env: WorkerEnv): Promise<Response>;
 };
 
-export { type WorkerEnv, _default as default };
+export { APPROVER_SCOPE, type AssistantApiOptions, type WorkerEnv, createAssistantApi, createWorker, _default as default };

package/dist/worker.js

@@ -1,17 +1,276 @@
 import {
-  VERSION
-} from "./chunk-4QE7E5UQ.js";
+  VERSION,
+  createPrincipal,
+  hasScope,
+  parseScope,
+  runAssistant
+} from "./chunk-T4ZMDOB4.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" }
+    });
+  }
+  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/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 });
+    }
+  };
+}
 var worker_default = {
   async fetch(request, env) {
     const url = new URL(request.url);
-    if (request.method === "GET" && url.pathname === "/health") {
-      return Response.json({ ok: true, pack: env.PACK_NAME ?? "agentic-assistant", version: VERSION });
+    if (request.method === "GET" && url.pathname === "/health") return health(env);
+    if (url.pathname.startsWith("/api/v1/")) {
+      return Response.json({ error: "the API is not set up: build the Worker with createWorker" }, { status: 503 });
     }
     return Response.json({ error: "not found" }, { status: 404 });
   }
 };
 export {
+  APPROVER_SCOPE,
+  createAssistantApi,
+  createWorker,
   worker_default as default
 };

package/llms.txt

@@ -5,6 +5,9 @@ An AI assistant that acts inside your apps with the user's own permissions.
 Keywords: assistant,ai,agent,tools,mcp,sdk,side-panel,approvals,eu,model-port.
 
 - SDK: import { runAssistant, ToolRegistry, createPrincipal } from "agentic-assistant".
+- CLI: agentic-assistant chat --tools <mcp-url> --scope <s> --tool-scope <s> "message". MCP server: agentic-assistant mcp.
+- HTTP API: import { createWorker } from "agentic-assistant/worker". Routes under /api/v1: GET /tools, POST /chat (SSE), GET /approvals, POST /approvals/:id/approve|deny. Sign-in with agentic-identity principals.
+- AI marking: events carry `provenance`; use provenanceLabel and provenanceMarker (JSON-LD, IPTC trainedAlgorithmicMedia). Also in HTTP, CLI --json and MCP results.
 - Panel: import { AssistantPanel } from "agentic-assistant/react"; import "agentic-assistant/react.css".
 - Test provider: import { ScriptedProvider } from "agentic-assistant/testing".
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-assistant",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "An AI assistant that acts inside your apps with the user's own permissions.",
   "keywords": [
     "assistant",
@@ -28,7 +28,8 @@
   "files": [
     "dist",
     "llms.txt",
-    "SKILL.md"
+    "SKILL.md",
+    "CHANGELOG.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -40,6 +41,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js"
+    },
     "./testing": {
       "types": "./dist/testing.d.ts",
       "import": "./dist/testing.js"
@@ -58,11 +63,13 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "clean": "rm -rf dist",
+    "prepack": "npm run build",
     "ci:local": "npm run build && npm run typecheck && npm test"
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^1.3.0",
     "@modelcontextprotocol/sdk": "^1.32.2",
+    "agentic-identity": "^0.3.0",
     "ajv": "^8.20.0"
   },
   "devDependencies": {

package/dist/chunk-4QE7E5UQ.js

@@ -1,7 +0,0 @@
-// src/version.ts
-import { createRequire } from "module";
-var VERSION = true ? "0.1.0" : readPackageVersion();
-
-export {
-  VERSION
-};