agentic-assistant 0.1.0 → 0.3.0

package/dist/chunk-3X6KU636.js

@@ -0,0 +1,569 @@
+import {
+  ScriptedProvider
+} from "./chunk-HYT732TN.js";
+import {
+  AnthropicProvider,
+  checkBaseUrl,
+  isLoopback
+} from "./chunk-DXTIEMOT.js";
+import {
+  PrincipalError,
+  ProviderError,
+  TOOL_RISKS,
+  ToolRegistry,
+  VERSION,
+  createPrincipal,
+  cutText,
+  digestCall,
+  printable,
+  runAssistant
+} from "./chunk-3LKTJJ75.js";
+
+// src/sources/mcp.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+var MAX_PAGES = 20;
+var MAX_SCHEMA_CHARS = 2e4;
+function positive(name, value, fallback, max = Number.MAX_SAFE_INTEGER) {
+  const chosen = value ?? fallback;
+  if (!Number.isInteger(chosen) || chosen <= 0 || chosen > max) throw new RangeError(`${name} must be a positive integer of at most ${max}`);
+  return chosen;
+}
+var MAX_TIMER_MS = 2147483647;
+function boundedFetch(limit) {
+  return async (input, init) => {
+    const response = await fetch(input, { ...init, redirect: "error" });
+    const declared = Number(response.headers.get("content-length"));
+    if (Number.isFinite(declared) && declared > limit) {
+      await response.body?.cancel();
+      throw new Error(`the tool server sent a response over the size limit of ${limit} bytes`);
+    }
+    if (response.body === null) return response;
+    let seen = 0;
+    const counted = response.body.pipeThrough(
+      new TransformStream({
+        transform(chunk, controller) {
+          seen += chunk.byteLength;
+          if (seen > limit) controller.error(new Error(`the tool server sent a response over the size limit of ${limit} bytes`));
+          else controller.enqueue(chunk);
+        }
+      })
+    );
+    return new Response(counted, { status: response.status, statusText: response.statusText, headers: response.headers });
+  };
+}
+var SCHEMA_NAME_MAPS = /* @__PURE__ */ new Set(["properties", "$defs", "definitions", "dependentSchemas"]);
+var SCHEMA_TEXT_KEYS = /* @__PURE__ */ new Set(["description", "title", "$comment"]);
+var SCHEMA_VALUE_KEYS = /* @__PURE__ */ new Set(["default", "const", "enum"]);
+function cutStrings(value, max) {
+  if (typeof value === "string") return cut(value, max);
+  if (Array.isArray(value)) return value.map((item) => cutStrings(item, max));
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, cutStrings(child, max)]));
+  }
+  return value;
+}
+function limitSchemaText(value, max, namesMap = false) {
+  if (Array.isArray(value)) return value.map((item) => limitSchemaText(item, max));
+  if (typeof value !== "object" || value === null) return value;
+  const out = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (namesMap) out[key] = limitSchemaText(child, max);
+    else if (key === "examples") continue;
+    else if (SCHEMA_TEXT_KEYS.has(key) && typeof child === "string") out[key] = cut(child, max);
+    else if (SCHEMA_VALUE_KEYS.has(key)) out[key] = cutStrings(child, max);
+    else out[key] = limitSchemaText(child, max, SCHEMA_NAME_MAPS.has(key));
+  }
+  return out;
+}
+function makeTransport(config, maxResponseBytes) {
+  if (config.type === "stdio") {
+    return new StdioClientTransport({ command: config.command, args: config.args, env: config.env, cwd: config.cwd, stderr: "ignore" });
+  }
+  const { url } = checkBaseUrl(config.url);
+  return new StreamableHTTPClientTransport(url, {
+    fetch: boundedFetch(maxResponseBytes),
+    ...config.headers ? { requestInit: { headers: config.headers } } : {}
+  });
+}
+var cut = cutText;
+function flatten(result, max) {
+  const parts = (result.content ?? []).map((block) => block.type === "text" && typeof block.text === "string" ? block.text : `[${block.type} content omitted]`);
+  let text = parts.join("\n");
+  if (text === "" && result.structuredContent !== void 0) text = JSON.stringify(result.structuredContent);
+  return cut(text, max);
+}
+async function connectMcpTools(options) {
+  const maxOutput = positive("maxOutputChars", options.maxOutputChars, 32768);
+  const maxTools = positive("maxTools", options.maxTools, 200);
+  const maxDescription = positive("maxDescriptionChars", options.maxDescriptionChars, 1e3);
+  const callTimeout = positive("callTimeoutMs", options.callTimeoutMs, 3e4, MAX_TIMER_MS);
+  const loadTimeout = positive("loadTimeoutMs", options.loadTimeoutMs, 3e4, MAX_TIMER_MS);
+  const maxResponseBytes = positive("maxResponseBytes", options.maxResponseBytes, 4e6);
+  const prefix = options.prefix ?? "";
+  const client = new Client({ name: "agentic-assistant", version: VERSION });
+  const loading = AbortSignal.timeout(loadTimeout);
+  try {
+    await client.connect(makeTransport(options.transport, maxResponseBytes), { signal: loading, timeout: loadTimeout });
+    const listed = [];
+    let cursor;
+    for (let page = 0; page < MAX_PAGES; page++) {
+      const response = await client.listTools(cursor === void 0 ? void 0 : { cursor }, { signal: loading, timeout: loadTimeout });
+      listed.push(...response.tools);
+      cursor = response.nextCursor;
+      if (cursor === void 0) break;
+    }
+    const tools = [];
+    const skipped = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const info of listed) {
+      if (seen.has(info.name)) {
+        skipped.push({ name: info.name, reason: "duplicate name" });
+        continue;
+      }
+      seen.add(info.name);
+      if (tools.length >= maxTools) {
+        skipped.push({ name: info.name, reason: "too many tools" });
+        continue;
+      }
+      try {
+        if (JSON.stringify(info.inputSchema).length > MAX_SCHEMA_CHARS) throw new Error("input schema is too large");
+        const scope = typeof options.scope === "function" ? options.scope(info) : options.scope;
+        const risk = typeof options.risk === "function" ? options.risk(info) : options.risk;
+        const definition = {
+          name: `${prefix}${info.name}`,
+          description: cut(info.description ?? "", maxDescription),
+          inputSchema: limitSchemaText(info.inputSchema, maxDescription),
+          scope,
+          risk,
+          handler: async (input, context) => {
+            const result = await client.callTool({ name: info.name, arguments: input }, void 0, {
+              signal: context.signal,
+              timeout: callTimeout
+            });
+            const text = flatten(result, maxOutput);
+            if (result.isError) throw new Error(text === "" ? "the tool reported an error" : text);
+            return text;
+          }
+        };
+        new ToolRegistry().register(definition);
+        tools.push(definition);
+      } catch (error) {
+        skipped.push({ name: info.name, reason: error instanceof Error ? error.message : String(error) });
+      }
+    }
+    return { tools, skipped, close: () => client.close() };
+  } catch (error) {
+    await client.close().catch(() => void 0);
+    throw error;
+  }
+}
+
+// src/providers/openai-compatible.ts
+import { randomUUID } from "crypto";
+var FINISH_REASONS = {
+  stop: "end_turn",
+  tool_calls: "tool_use",
+  length: "max_tokens",
+  content_filter: "refusal"
+};
+function toChatMessages(system, messages) {
+  const out = system !== void 0 ? [{ role: "system", content: system }] : [];
+  for (const message of messages) {
+    const text = message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+    if (message.role === "user") {
+      for (const block of message.content) {
+        if (block.type === "tool_result") out.push({ role: "tool", tool_call_id: block.toolUseId, content: block.content });
+      }
+      if (text.length > 0) out.push({ role: "user", content: text });
+      continue;
+    }
+    const toolCalls = message.content.filter((block) => block.type === "tool_use").map((block) => ({ id: block.id, type: "function", function: { name: block.name, arguments: JSON.stringify(block.input ?? {}) } }));
+    out.push({
+      role: "assistant",
+      content: text.length > 0 ? text : null,
+      ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+    });
+  }
+  return out;
+}
+var OpenAICompatibleProvider = class {
+  name;
+  model;
+  pricing;
+  baseUrl;
+  apiKey;
+  maxResponseBytes;
+  constructor(options) {
+    this.name = options.name ?? "openai-compatible";
+    this.model = options.model;
+    this.pricing = options.pricing;
+    this.apiKey = options.apiKey;
+    const limit = options.maxResponseBytes ?? 4e6;
+    if (!Number.isInteger(limit) || limit <= 0) throw new ProviderError("maxResponseBytes must be a positive integer");
+    this.maxResponseBytes = limit;
+    const { url, text } = checkBaseUrl(options.baseUrl);
+    this.baseUrl = text;
+    if (options.apiKey === "" || options.apiKey === void 0 && !isLoopback(url)) {
+      throw new ProviderError("apiKey must be a non-empty string for a remote host");
+    }
+  }
+  async *stream(request) {
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: "POST",
+      signal: request.signal,
+      headers: {
+        "content-type": "application/json",
+        ...this.apiKey !== void 0 ? { authorization: `Bearer ${this.apiKey}` } : {}
+      },
+      body: JSON.stringify({
+        model: this.model,
+        stream: true,
+        stream_options: { include_usage: true },
+        max_tokens: request.maxOutputTokens,
+        messages: toChatMessages(request.system, request.messages),
+        ...request.tools.length > 0 ? {
+          tools: request.tools.map((tool) => ({
+            type: "function",
+            function: { name: tool.name, description: tool.description, parameters: tool.inputSchema }
+          }))
+        } : {}
+      })
+    });
+    if (!response.ok || response.body === null) {
+      throw new ProviderError(`${this.name} request failed with status ${response.status}`);
+    }
+    let text = "";
+    let received = 0;
+    const limit = this.maxResponseBytes;
+    const calls = /* @__PURE__ */ new Map();
+    let finish;
+    let usage;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const handle = function* (line) {
+      if (!line.startsWith("data:")) return;
+      const data = line.slice(5).trim();
+      if (data === "" || data === "[DONE]") return;
+      let chunk;
+      try {
+        chunk = JSON.parse(data);
+      } catch {
+        throw new ProviderError("provider sent a stream chunk that is not JSON");
+      }
+      if (chunk.usage) usage = chunk.usage;
+      const choice = chunk.choices?.[0];
+      if (!choice) return;
+      if (choice.finish_reason) finish = choice.finish_reason;
+      const delta = choice.delta;
+      if (typeof delta?.content === "string" && delta.content.length > 0) {
+        text += delta.content;
+        yield { type: "text_delta", text: delta.content };
+      }
+      for (const part of delta?.tool_calls ?? []) {
+        const call = calls.get(part.index) ?? { id: "", name: "", args: "" };
+        if (part.id) call.id = part.id;
+        if (part.function?.name) call.name += part.function.name;
+        if (part.function?.arguments) call.args += part.function.arguments;
+        calls.set(part.index, call);
+      }
+    };
+    const reader = response.body.getReader();
+    try {
+      for (; ; ) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        received += value.byteLength;
+        if (received > limit) throw new ProviderError(`${this.name} response passed the size limit of ${limit} bytes`);
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) yield* handle(line.trimEnd());
+      }
+    } finally {
+      await reader.cancel().catch(() => void 0);
+    }
+    if (buffer.length > 0) yield* handle(buffer.trimEnd());
+    if (!Number.isInteger(usage?.prompt_tokens) || !Number.isInteger(usage?.completion_tokens)) {
+      throw new ProviderError(`${this.name} reported no token usage, so token and cost caps cannot be enforced`);
+    }
+    const content = [];
+    if (text.length > 0) content.push({ type: "text", text });
+    for (const [, call] of [...calls.entries()].sort((a, b) => a[0] - b[0])) {
+      let input = null;
+      try {
+        input = call.args.length > 0 ? JSON.parse(call.args) : {};
+      } catch {
+        input = null;
+      }
+      content.push({ type: "tool_use", id: call.id.length > 0 ? call.id : `call_${randomUUID()}`, name: call.name, input });
+    }
+    yield {
+      type: "message",
+      content,
+      stopReason: FINISH_REASONS[finish ?? ""] ?? "other",
+      usage: { inputTokens: usage?.prompt_tokens, outputTokens: usage?.completion_tokens }
+    };
+  }
+};
+
+// src/providers/fallback.ts
+var CHARS_PER_TOKEN = 3;
+function checkUsage(usage) {
+  for (const value of [usage.inputTokens, usage.outputTokens]) {
+    if (!Number.isInteger(value) || value < 0) throw new ProviderError("provider reported invalid token usage; caps cannot be enforced");
+  }
+}
+var FallbackProvider = class {
+  constructor(primary, fallback) {
+    this.primary = primary;
+    this.fallback = fallback;
+    this.name = primary.name;
+    this.model = primary.model;
+    this.maxAsks = (primary.maxAsks ?? 1) + (fallback.maxAsks ?? 1);
+    if (primary.pricing !== void 0 && fallback.pricing !== void 0) {
+      this.pricing = {
+        inputPerMTok: Math.max(primary.pricing.inputPerMTok, fallback.pricing.inputPerMTok),
+        outputPerMTok: Math.max(primary.pricing.outputPerMTok, fallback.pricing.outputPerMTok)
+      };
+    }
+  }
+  primary;
+  fallback;
+  name;
+  model;
+  pricing;
+  maxAsks;
+  async *stream(request) {
+    const held = [];
+    let heldChars = 0;
+    let started = false;
+    let final;
+    let failure;
+    try {
+      for await (const event of this.primary.stream(request)) {
+        started = true;
+        if (event.type === "message") final = event;
+        else {
+          held.push(event);
+          heldChars += event.text.length;
+        }
+      }
+      if (final === void 0) throw new ProviderError(`provider "${this.primary.name}" ended without a final message`);
+    } catch (error) {
+      failure = error;
+    }
+    const answered = (provider, fallbackFor) => ({
+      provider: provider.name,
+      model: provider.model,
+      fallback: fallbackFor !== void 0,
+      ...fallbackFor !== void 0 ? { fallbackFor } : {}
+    });
+    if (failure === void 0 && final !== void 0 && final.stopReason !== "refusal") {
+      for (const event of held) yield event;
+      yield { ...final, answeredBy: final.answeredBy ?? answered(this.primary) };
+      return;
+    }
+    if (request.signal?.aborted) {
+      if (failure !== void 0 || final === void 0) throw failure;
+      for (const event of held) yield event;
+      yield { ...final, answeredBy: final.answeredBy ?? answered(this.primary) };
+      return;
+    }
+    let spent = { inputTokens: 0, outputTokens: 0 };
+    if (final !== void 0) {
+      checkUsage(final.usage);
+      spent = final.usage;
+    } else if (started) {
+      const { system, messages, tools } = request;
+      spent = { inputTokens: Math.ceil(JSON.stringify({ system, messages, tools }).length / CHARS_PER_TOKEN), outputTokens: Math.ceil(heldChars / CHARS_PER_TOKEN) };
+    }
+    const left = request.maxOutputTokens - spent.outputTokens;
+    if (!(left > 0)) {
+      if (final !== void 0) {
+        for (const event of held) yield event;
+        yield { ...final, answeredBy: final.answeredBy ?? answered(this.primary) };
+        return;
+      }
+      throw failure;
+    }
+    let second;
+    for await (const event of this.fallback.stream({ ...request, maxOutputTokens: left })) {
+      if (event.type === "message") second = event;
+      else yield event;
+    }
+    if (second === void 0) throw new ProviderError(`provider "${this.fallback.name}" ended without a final message`);
+    checkUsage(second.usage);
+    yield {
+      ...second,
+      usage: {
+        inputTokens: spent.inputTokens + second.usage.inputTokens,
+        outputTokens: spent.outputTokens + second.usage.outputTokens
+      },
+      // A pair inside this one has already named the model that answered. Keep that name.
+      answeredBy: { ...second.answeredBy ?? answered(this.fallback), fallback: true, fallbackFor: failure === void 0 ? "refusal" : "error" }
+    };
+  }
+};
+
+// src/chat.ts
+import { readFileSync } from "fs";
+var ConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+function isSecureUrl(target) {
+  let url;
+  try {
+    url = new URL(target);
+  } catch {
+    return false;
+  }
+  if (url.protocol === "https:") return true;
+  return ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+}
+function parseTarget(target, headerEnv, env) {
+  if (/^https?:\/\//i.test(target)) {
+    if (!isSecureUrl(target)) throw new ConfigError("--tools needs an https URL, or http on localhost only");
+    const headers = {};
+    for (const entry of headerEnv) {
+      const at = entry.indexOf("=");
+      const name = at < 0 ? "" : entry.slice(0, at);
+      const variable = at < 0 ? "" : entry.slice(at + 1);
+      if (!name || !variable || variable.includes("=")) throw new ConfigError(`--tools-header-env needs header=ENV_NAME, got "${entry}"`);
+      const value = env[variable];
+      if (!value) throw new ConfigError(`environment variable ${variable} is not set`);
+      headers[name] = value;
+    }
+    return { type: "http", url: target, ...Object.keys(headers).length > 0 ? { headers } : {} };
+  }
+  if (headerEnv.length > 0) throw new ConfigError("--tools-header-env works with an http(s) --tools URL only");
+  let words;
+  if (target.trimStart().startsWith("[")) {
+    try {
+      const parsed = JSON.parse(target);
+      if (!Array.isArray(parsed) || parsed.some((word) => typeof word !== "string")) throw new Error("not strings");
+      words = parsed;
+    } catch {
+      throw new ConfigError("--tools looks like a JSON list but is not a list of strings");
+    }
+  } else {
+    words = target.split(/\s+/).filter(Boolean);
+  }
+  const [command, ...args] = words;
+  if (!command) throw new ConfigError("--tools is empty");
+  return { type: "stdio", command, args };
+}
+function buildProvider(config, io, model = config.model) {
+  const key = config.apiKeyEnv === void 0 ? void 0 : io.env[config.apiKeyEnv];
+  if (config.apiKeyEnv !== void 0 && !key) throw new ConfigError(`environment variable ${config.apiKeyEnv} is not set`);
+  switch (config.provider) {
+    case "anthropic":
+      return new AnthropicProvider({
+        model,
+        baseUrl: config.baseUrl,
+        useDefaultEndpoint: config.useDefaultEndpoint,
+        pricing: config.pricing,
+        apiKey: key ?? io.env.ANTHROPIC_API_KEY
+      });
+    case "openai-compatible":
+      if (!config.baseUrl || !model) throw new ConfigError("--provider openai-compatible needs --base-url and --model");
+      return new OpenAICompatibleProvider({ baseUrl: config.baseUrl, model, apiKey: key, pricing: config.pricing });
+    case "scripted": {
+      if (!config.script) throw new ConfigError("--provider scripted needs --script <file>");
+      let script;
+      try {
+        script = JSON.parse(io.readFile(config.script));
+      } catch {
+        throw new ConfigError("--script must be a JSON file with a list of turns");
+      }
+      if (!Array.isArray(script)) throw new ConfigError("--script must be a JSON file with a list of turns");
+      return new ScriptedProvider(script, config.pricing);
+    }
+  }
+}
+var MAX_QUESTION_ARGUMENT_CHARS = 500;
+var CommandLineGate = class {
+  constructor(preApproved, principal, mode, user, ask) {
+    this.mode = mode;
+    this.user = user;
+    this.ask = ask;
+    this.unused = preApproved.map((call) => digestCall({ tool: call.tool, input: call.input, principalId: principal.id, onBehalfOf: principal.parentId }));
+  }
+  mode;
+  user;
+  ask;
+  unused;
+  async request(request) {
+    const index = this.unused.indexOf(request.digest);
+    if (index >= 0) {
+      this.unused.splice(index, 1);
+      return { requestId: request.id, approved: true, digest: request.digest, decidedBy: "cli:pre-approved", approverKind: "host" };
+    }
+    if (this.mode === "ask" && this.ask !== void 0) {
+      const args = cutText(printable(JSON.stringify(request.input)), MAX_QUESTION_ARGUMENT_CHARS);
+      const answer = await this.ask(`[machine-made request] Approve ${printable(request.tool)} (${request.risk}) with ${args}? [y/N] `);
+      if (/^y(es)?$/i.test(answer.trim())) return { requestId: request.id, approved: true, digest: request.digest, decidedBy: `cli:${this.user}`, approverKind: "human" };
+    }
+    return { requestId: request.id, approved: false, reason: "not approved on the command line" };
+  }
+};
+async function buildSetup(config, io) {
+  if (config.scopes.length === 0) throw new ConfigError("give at least one --scope, or the assistant can do nothing");
+  if (!TOOL_RISKS.includes(config.toolRisk)) throw new ConfigError(`--tool-risk must be one of ${TOOL_RISKS.join(", ")}`);
+  if (config.approve === "ask" && io.ask === void 0) throw new ConfigError("--approve ask needs a terminal");
+  const principalOptions = { id: "cli-agent", parentId: config.user, scopes: config.scopes };
+  let provider;
+  try {
+    createPrincipal({ ...principalOptions, kind: "agent_of_human" });
+    provider = buildProvider(config, io);
+    if (config.fallbackModel !== void 0) {
+      if (config.provider === "scripted") throw new ConfigError("--fallback-model does not work with --provider scripted");
+      provider = new FallbackProvider(provider, buildProvider(config, io, config.fallbackModel));
+    }
+  } catch (error) {
+    if (error instanceof PrincipalError || error instanceof ProviderError) throw new ConfigError(error.message);
+    throw error;
+  }
+  const transport = parseTarget(config.tools, config.toolHeaderEnv, io.env);
+  const mcp = await connectMcpTools({ transport, scope: config.toolScope, risk: config.toolRisk });
+  return {
+    provider,
+    registry: new ToolRegistry().registerAll(mcp.tools),
+    gate: new CommandLineGate(config.preApproved, principalOptions, config.approve, config.user, io.ask),
+    principalOptions,
+    limits: config.limits,
+    system: config.system,
+    skipped: mcp.skipped,
+    close: () => mcp.close()
+  };
+}
+function runChat(setup, messages, signal) {
+  return runAssistant({
+    provider: setup.provider,
+    registry: setup.registry,
+    principal: createPrincipal({ ...setup.principalOptions, kind: "agent_of_human" }),
+    approvals: setup.gate,
+    messages,
+    system: setup.system,
+    limits: setup.limits,
+    signal
+  });
+}
+function readTextFile(path) {
+  return readFileSync(path, "utf8");
+}
+
+export {
+  connectMcpTools,
+  OpenAICompatibleProvider,
+  FallbackProvider,
+  ConfigError,
+  parseTarget,
+  buildSetup,
+  runChat,
+  readTextFile
+};