@dudko.dev/agent-web 0.0.1

package/dist/index.js

@@ -0,0 +1,1298 @@
+import {
+  createWebLLMModel,
+  isWebGPUAvailable
+} from "./chunk-R7H4HSYT.js";
+
+// src/config.ts
+var resolveConfig = (c) => ({
+  clientName: c.clientName ?? "agent-web",
+  sessionId: c.sessionId ?? "default",
+  toolMode: c.toolMode ?? "auto",
+  toolSelectionStrategy: c.toolSelectionStrategy ?? "all",
+  maxIterations: c.maxIterations ?? 8,
+  maxStepsPerTask: c.maxStepsPerTask ?? 4,
+  maxRevisions: c.maxRevisions ?? 2,
+  chatTimeoutMs: c.chatTimeoutMs ?? 12e4,
+  budgets: {
+    planner: c.budgets?.planner ?? 800,
+    executor: c.budgets?.executor ?? 1200,
+    replanner: c.budgets?.replanner ?? 400,
+    synthesizer: c.budgets?.synthesizer ?? 400
+  },
+  temperature: c.temperature,
+  replan: c.replan ?? true,
+  synthesize: c.synthesize ?? true,
+  compressAfterChars: c.compressAfterChars ?? 12e3
+});
+
+// src/llm/generate.ts
+import {
+  generateObject,
+  generateText,
+  streamText
+} from "ai";
+
+// src/llm/util.ts
+var promptOf = (opts) => opts.messages ? { messages: opts.messages } : { prompt: opts.prompt ?? "" };
+var normalizeUsage = (u) => {
+  const inputTokens = u?.inputTokens ?? 0;
+  const outputTokens = u?.outputTokens ?? 0;
+  return {
+    inputTokens,
+    outputTokens,
+    totalTokens: u?.totalTokens ?? inputTokens + outputTokens
+  };
+};
+var timeoutSignal = (signal, ms) => {
+  if (!ms || ms <= 0) return signal;
+  const timeout = AbortSignal.timeout(ms);
+  if (!signal) return timeout;
+  return typeof AbortSignal.any === "function" ? AbortSignal.any([signal, timeout]) : signal;
+};
+
+// src/llm/generate.ts
+var generate = (model, opts = {}) => generateText({
+  model,
+  system: opts.system,
+  ...promptOf(opts),
+  tools: opts.tools,
+  maxOutputTokens: opts.maxOutputTokens,
+  temperature: opts.temperature,
+  abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
+});
+var stream = (model, opts = {}) => streamText({
+  model,
+  system: opts.system,
+  ...promptOf(opts),
+  tools: opts.tools,
+  maxOutputTokens: opts.maxOutputTokens,
+  temperature: opts.temperature,
+  abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
+});
+var generateStructured = (model, schema, opts = {}) => generateObject({
+  model,
+  schema,
+  system: opts.system,
+  ...promptOf(opts),
+  maxOutputTokens: opts.maxOutputTokens,
+  temperature: opts.temperature,
+  abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
+});
+
+// src/memory/compress.ts
+var totalChars = (msgs) => msgs.reduce((n, m) => n + m.content.length, 0);
+var compressHistory = async (messages, model, opts = {}) => {
+  const maxChars = opts.maxChars ?? 12e3;
+  const keepRecent = opts.keepRecent ?? 6;
+  if (maxChars <= 0 || messages.length <= keepRecent + 1 || totalChars(messages) <= maxChars) {
+    return messages;
+  }
+  const head = messages.slice(0, messages.length - keepRecent);
+  const tail = messages.slice(messages.length - keepRecent);
+  const transcript = head.map((m) => `${m.role}: ${m.content}`).join("\n").slice(0, 8e3);
+  try {
+    const result = await generate(model, {
+      system: "Summarize the following conversation into a compact set of durable facts and decisions. Output plain text only.",
+      prompt: transcript,
+      maxOutputTokens: 400
+    });
+    const clean = (result.text || "").trim();
+    if (!clean) return messages;
+    const summaryMsg = {
+      role: "system",
+      content: `Summary of earlier conversation:
+${clean}`,
+      ts: head[0]?.ts
+    };
+    return [summaryMsg, ...tail];
+  } catch {
+    return messages;
+  }
+};
+
+// src/providers/types.ts
+var isDirectModel = (m) => typeof m === "string" || typeof m === "object" && m !== null && "specificationVersion" in m;
+var isProviderSpec = (m) => typeof m === "object" && m !== null && !isDirectModel(m) && typeof m.providerType === "string";
+
+// src/providers/registry.ts
+var REQUIRES_BASE_URL = /* @__PURE__ */ new Set(["openai-compatible"]);
+var NO_KEY = /* @__PURE__ */ new Set(["web-llm"]);
+var PROVIDER_PACKAGE = {
+  openai: "@ai-sdk/openai",
+  anthropic: "@ai-sdk/anthropic",
+  google: "@ai-sdk/google",
+  "openai-compatible": "@ai-sdk/openai-compatible",
+  xai: "@ai-sdk/xai",
+  deepseek: "@ai-sdk/deepseek"
+};
+var loadProvider = async (pkg) => {
+  try {
+    return await import(
+      /* @vite-ignore */
+      pkg
+    );
+  } catch {
+    throw new Error(
+      `Provider package "${pkg}" is not installed. Add it to your app: npm install ${pkg}`
+    );
+  }
+};
+var normalizeSpec = (spec) => {
+  if (REQUIRES_BASE_URL.has(spec.providerType) && !spec.baseURL) {
+    throw new Error(`provider "${spec.providerType}" requires a baseURL (point it at your server)`);
+  }
+  return spec;
+};
+var resolveStage = (base, override, stageName) => {
+  if (override !== void 0 && isDirectModel(override)) {
+    return { type: "direct", model: override };
+  }
+  if (override !== void 0 && isProviderSpec(override)) {
+    if (isProviderSpec(base) && override.providerType !== base.providerType && !override.credentialRef && !override.apiKey && !NO_KEY.has(override.providerType)) {
+      throw new Error(
+        `${stageName}: provider "${override.providerType}" differs from the base "${base.providerType}"; set ${stageName}.credentialRef or apiKey (cross-provider key inheritance is unsafe)`
+      );
+    }
+    return { type: "spec", spec: normalizeSpec(override) };
+  }
+  if (isDirectModel(base)) {
+    if (override && Object.keys(override).length > 0) {
+      throw new Error(
+        `${stageName}: cannot layer a partial override onto a direct model \u2014 pass a full model or ProviderModelSpec for ${stageName}`
+      );
+    }
+    return { type: "direct", model: base };
+  }
+  if (!isProviderSpec(base)) {
+    throw new Error(`${stageName}: base model must be a LanguageModel or a ProviderModelSpec`);
+  }
+  const ov = override ?? {};
+  const merged = {
+    providerType: base.providerType,
+    model: ov.model ?? base.model,
+    baseURL: ov.baseURL ?? base.baseURL,
+    credentialRef: ov.credentialRef ?? base.credentialRef,
+    apiKey: ov.apiKey ?? base.apiKey,
+    headers: ov.headers ?? base.headers,
+    providerOptions: ov.providerOptions ?? base.providerOptions
+  };
+  return { type: "spec", spec: normalizeSpec(merged) };
+};
+var resolveApiKey = async (spec, credentials) => {
+  if (spec.apiKey) {
+    console.warn(
+      `[agent-web] using an inline apiKey for provider "${spec.providerType}"; prefer credentialRef so the key stays in the encrypted vault`
+    );
+    return spec.apiKey;
+  }
+  if (spec.credentialRef) {
+    if (!credentials) {
+      throw new Error(
+        `credentialRef "${spec.credentialRef}" is set but no CredentialStore was provided to the agent`
+      );
+    }
+    const key = await credentials.getApiKey(spec.credentialRef);
+    if (!key) {
+      throw new Error(
+        `no API key found in the CredentialStore for credentialRef "${spec.credentialRef}"`
+      );
+    }
+    return key;
+  }
+  return void 0;
+};
+var buildModelFromStage = async (resolved, credentials, clientName = "agent-web") => {
+  if (resolved.type === "direct") return resolved.model;
+  const spec = resolved.spec;
+  const providerOptions = spec.providerOptions ?? {};
+  const apiKey = await resolveApiKey(spec, credentials);
+  switch (spec.providerType) {
+    case "web-llm": {
+      const { createWebLLMModel: createWebLLMModel2 } = await import("./webllm-IM3UD6YI.js");
+      return createWebLLMModel2(spec.model, providerOptions);
+    }
+    case "gateway": {
+      const { createGateway } = await import("ai");
+      const provider = createGateway({
+        baseURL: spec.baseURL || void 0,
+        apiKey,
+        headers: spec.headers,
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+    case "openai": {
+      const { createOpenAI } = await loadProvider(
+        PROVIDER_PACKAGE.openai
+      );
+      const provider = createOpenAI({
+        baseURL: spec.baseURL || void 0,
+        apiKey,
+        headers: spec.headers,
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+    case "anthropic": {
+      const { createAnthropic } = await loadProvider(
+        PROVIDER_PACKAGE.anthropic
+      );
+      const provider = createAnthropic({
+        baseURL: spec.baseURL || void 0,
+        apiKey,
+        // Anthropic's SDK refuses browser calls unless this opt-in header is
+        // set; host headers may override it.
+        headers: { "anthropic-dangerous-direct-browser-access": "true", ...spec.headers },
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+    case "google": {
+      const { createGoogleGenerativeAI } = await loadProvider(
+        PROVIDER_PACKAGE.google
+      );
+      const provider = createGoogleGenerativeAI({
+        baseURL: spec.baseURL || void 0,
+        apiKey,
+        headers: spec.headers,
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+    case "openai-compatible": {
+      const { createOpenAICompatible } = await loadProvider(PROVIDER_PACKAGE["openai-compatible"]);
+      const provider = createOpenAICompatible({
+        name: clientName,
+        baseURL: spec.baseURL,
+        apiKey,
+        headers: spec.headers,
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+    case "xai": {
+      const { createXai } = await loadProvider(PROVIDER_PACKAGE.xai);
+      const provider = createXai({
+        baseURL: spec.baseURL || void 0,
+        apiKey,
+        headers: spec.headers,
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+    case "deepseek": {
+      const { createDeepSeek } = await loadProvider(
+        PROVIDER_PACKAGE.deepseek
+      );
+      const provider = createDeepSeek({
+        baseURL: spec.baseURL || void 0,
+        apiKey,
+        headers: spec.headers,
+        ...providerOptions
+      });
+      return provider(spec.model);
+    }
+  }
+};
+var resolveModel = (input, credentials, clientName) => buildModelFromStage(resolveStage(input, void 0, "model"), credentials, clientName);
+
+// src/prompts.ts
+var numbered = (items, empty) => items.length ? items.map((s, i) => `${i + 1}. ${s}`).join("\n") : empty;
+var stateBlock = (state) => state && state.trim() ? `
+
+STATE:
+${state}` : "";
+var PLANNER_NATIVE = `You are the PLANNER of a tool-using agent that changes a workspace step by step.
+Produce a brief "thought" and an ordered "steps" list (1\u20136 DISTINCT, self-contained steps) grounded in the current STATE and the available TOOLS.
+If the user only greets, thanks, makes small talk, asks a question, or is unclear: return an EMPTY steps list and put a short, friendly answer in "thought".
+Never repeat or pad steps.`;
+var PLANNER_PROMPTED = `You are the PLANNER of a tool-using agent that changes a workspace step by step.
+
+Reply with a single JSON object, nothing else:
+{ "reply": string, "plan": string[] }
+- Only produce a "plan" when the user CLEARLY asks to build, do, or change something. For a greeting, small talk, thanks, a question, or an unclear/empty request: set "plan": [] and put a short, friendly "reply".
+- For a real goal: "reply" is one short sentence; "plan" is 1\u20136 DISTINCT, self-contained steps. Never repeat or pad steps.
+- Plan realistic steps the available TOOLS can perform, grounded in the current STATE.`;
+var EXECUTOR_NATIVE = `You are the EXECUTOR of a tool-using agent. Carry out ONLY the current step by calling the provided tools.
+Build on the current STATE \u2014 do not repeat work that is already there.
+When the step is done, reply with one short human sentence describing what you did (no JSON).
+If you CANNOT complete the step (a needed tool is missing or an input is unavailable), explain why in one sentence and include the token [BLOCKER].`;
+var EXECUTOR_PROMPTED = `You are the EXECUTOR of a tool-using agent. Carry out ONLY the current step by emitting tool calls.
+
+Reply with a single JSON object, nothing else:
+{ "reply": string, "actions": [ { "tool": string, "args": object } ] }
+- "actions" are the tool calls for THIS step ([] if none are needed). Use ONLY tools from the TOOLS list; "args" must match the tool's parameters.
+- Build on the current STATE \u2014 do not repeat work that is already there.
+- "reply" is one short human sentence (no JSON) describing what you did.
+- If you CANNOT complete the step, set "actions": [] and put the token [BLOCKER] in "reply" with a short reason.`;
+var REPLANNER_NATIVE = `You are the REPLANNER. After a step that was blocked or had a failed tool call, decide whether to keep going, revise the remaining steps, or finish.
+"continue": the remaining steps still fit. "revise": provide a better "plan" for the REMAINING work (never repeat done work). "finish": the goal is already met.
+Judge from the current STATE vs the goal. Prefer "continue".`;
+var REPLANNER_PROMPTED = `You are the REPLANNER. After each executed step you decide whether to keep going, revise the remaining steps, or finish.
+
+Reply with a single JSON object, nothing else:
+{ "decision": "continue" | "revise" | "finish", "reason": string, "plan": string[] }
+- "continue": remaining steps still fit \u2014 proceed (omit "plan").
+- "revise": replace the REMAINING steps with a better list in "plan"; never repeat done work.
+- "finish": the goal is already met \u2014 stop (omit "plan").
+Judge from the current STATE vs the goal. Prefer "continue".`;
+var SYNTHESIZER_SYSTEM = `You are the SYNTHESIZER. In 1\u20133 short, friendly sentences, tell the user what was done to meet their goal. Be concrete. Output plain text only \u2014 no JSON, no code.`;
+var defaultPrompts = {
+  planner: (ctx) => ({
+    system: ctx.mode === "prompted" ? PLANNER_PROMPTED : PLANNER_NATIVE,
+    prompt: `GOAL: ${ctx.goal}${stateBlock(ctx.state)}
+
+TOOLS:
+${ctx.toolCatalog}`
+  }),
+  executor: (ctx) => ({
+    system: ctx.mode === "prompted" ? EXECUTOR_PROMPTED : EXECUTOR_NATIVE,
+    prompt: [
+      `GOAL: ${ctx.goal}`,
+      stateBlock(ctx.state).trimStart(),
+      ctx.mode === "prompted" ? `TOOLS:
+${ctx.toolCatalog}` : "",
+      ctx.done.length ? `Already done:
+${numbered(ctx.done, "")}` : "",
+      `STEP ${ctx.index}/${ctx.total}: ${ctx.step}`
+    ].filter(Boolean).join("\n\n")
+  }),
+  replanner: (ctx) => ({
+    system: ctx.mode === "prompted" ? REPLANNER_PROMPTED : REPLANNER_NATIVE,
+    prompt: [
+      `GOAL: ${ctx.goal}`,
+      stateBlock(ctx.state).trimStart(),
+      `Already done:
+${numbered(ctx.done, "(nothing yet)")}`,
+      `Remaining plan:
+${numbered(ctx.remaining, "(none)")}`,
+      "Decide: continue, revise, or finish."
+    ].filter(Boolean).join("\n\n")
+  }),
+  synthesizer: (ctx) => ({
+    system: SYNTHESIZER_SYSTEM,
+    prompt: [
+      `GOAL: ${ctx.goal}`,
+      stateBlock(ctx.state).trimStart(),
+      `What was done:
+${numbered(ctx.done, "(no changes)")}`,
+      "Write the final summary for the user."
+    ].filter(Boolean).join("\n\n")
+  })
+};
+var withSystem = (base, extra) => extra && extra.trim() ? `${extra.trim()}
+
+${base}` : base;
+
+// src/tools/mode.ts
+var modelProviderId = (model) => typeof model === "string" ? model : model.provider ?? "";
+var LOCAL_RE = /web-?llm|mlc|browser-ai|transformers|nano|built-?in/i;
+var selectToolMode = (model, mode = "auto") => {
+  if (mode === "native" || mode === "prompted") return mode;
+  return LOCAL_RE.test(modelProviderId(model)) ? "prompted" : "native";
+};
+
+// src/tools/types.ts
+var promptHintOf = (tool2) => typeof tool2.promptHint === "string" ? tool2.promptHint : void 0;
+
+// src/tools/prompted.ts
+var renderCatalog = (tools) => {
+  const names = Object.keys(tools);
+  if (names.length === 0) return "(no tools)";
+  return names.map((name) => {
+    const t = tools[name];
+    const hint = promptHintOf(t) ?? "";
+    const desc = typeof t.description === "string" ? t.description : "";
+    return `- ${name}(${hint}): ${desc}`;
+  }).join("\n");
+};
+var dispatch = async (action, tools, ctx = {}) => {
+  const t = tools[action.tool];
+  if (!t) {
+    return {
+      name: action.tool,
+      input: action.args,
+      output: `unknown tool "${action.tool}"`,
+      ok: false
+    };
+  }
+  let input = action.args;
+  const schema = t.inputSchema;
+  if (schema && typeof schema.safeParse === "function") {
+    const parsed = schema.safeParse(input);
+    if (!parsed.success) {
+      return {
+        name: action.tool,
+        input,
+        output: `invalid args for "${action.tool}": ${parsed.error?.message ?? "schema validation failed"}`,
+        ok: false
+      };
+    }
+    input = parsed.data;
+  }
+  const execute = t.execute;
+  if (typeof execute !== "function") {
+    return { name: action.tool, input, output: `tool "${action.tool}" has no execute`, ok: false };
+  }
+  try {
+    const output = await execute(input, {
+      toolCallId: ctx.toolCallId ?? `prompted-${action.tool}`,
+      messages: ctx.messages ?? [],
+      abortSignal: ctx.abortSignal
+    });
+    return { name: action.tool, input, output, ok: true };
+  } catch (err) {
+    return {
+      name: action.tool,
+      input,
+      output: err instanceof Error ? err.message : "tool error",
+      ok: false
+    };
+  }
+};
+
+// src/llm/tool-loop.ts
+import {
+  generateText as generateText2,
+  stepCountIs,
+  streamText as streamText2
+} from "ai";
+
+// src/parse.ts
+var stripFences = (text) => (text || "").replace(/```(?:json)?/gi, "").trim();
+var extractBalanced = (text, open) => {
+  const close = open === "{" ? "}" : "]";
+  const start = text.indexOf(open);
+  if (start < 0) return void 0;
+  let depth = 0;
+  let inStr = false;
+  let esc = false;
+  for (let i = start; i < text.length; i += 1) {
+    const c = text[i];
+    if (inStr) {
+      if (esc) esc = false;
+      else if (c === "\\") esc = true;
+      else if (c === '"') inStr = false;
+      continue;
+    }
+    if (c === '"') inStr = true;
+    else if (c === open) depth += 1;
+    else if (c === close) {
+      depth -= 1;
+      if (depth === 0) return text.slice(start, i + 1);
+    }
+  }
+  return void 0;
+};
+var tryParse = (s) => {
+  if (!s) return void 0;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return void 0;
+  }
+};
+var looksLikeJson = (s) => {
+  const t = (s || "").trim();
+  return t.startsWith("{") || t.startsWith("[") || /"(tool|args|plan|reply|actions|decision)"\s*:/.test(t);
+};
+var asObject = (text) => {
+  const v = tryParse(text) ?? tryParse(extractBalanced(text, "{"));
+  return v && typeof v === "object" && !Array.isArray(v) ? v : void 0;
+};
+var normalizeSteps = (arr, cap = 12) => {
+  if (!Array.isArray(arr)) return [];
+  const seen = {};
+  const out = [];
+  for (const s of arr) {
+    if (out.length >= cap || typeof s !== "string") continue;
+    const step = s.trim();
+    const key = step.toLowerCase();
+    if (!step || seen[key]) continue;
+    seen[key] = true;
+    out.push(step);
+  }
+  return out;
+};
+var salvageStringArray = (text, field) => {
+  const at = text.search(new RegExp(`"${field}"\\s*:`));
+  if (at < 0) return [];
+  const region = text.slice(at);
+  const out = [];
+  const re = /"((?:[^"\\]|\\.)*)"/g;
+  let skippedKey = false;
+  let m = re.exec(region);
+  while (m) {
+    if (skippedKey) out.push(m[1]);
+    skippedKey = true;
+    m = re.exec(region);
+  }
+  return out;
+};
+var salvageString = (text, field) => {
+  const m = text.match(new RegExp(`"${field}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`));
+  return m ? m[1].trim() : "";
+};
+var parsePlannerResponse = (raw) => {
+  const text = stripFences(raw);
+  const obj = asObject(text);
+  if (obj) {
+    const reply = typeof obj.reply === "string" ? obj.reply.trim() : "";
+    return { reply, plan: normalizeSteps(obj.plan) };
+  }
+  if (/"plan"\s*:/.test(text)) {
+    return {
+      reply: salvageString(text, "reply"),
+      plan: normalizeSteps(salvageStringArray(text, "plan"))
+    };
+  }
+  return { reply: looksLikeJson(text) ? "" : text.trim(), plan: [] };
+};
+var toActions = (value) => {
+  if (!Array.isArray(value)) return [];
+  const out = [];
+  for (const a of value) {
+    if (a && typeof a === "object" && typeof a.tool === "string") {
+      const rec = a;
+      out.push({
+        tool: rec.tool,
+        args: rec.args && typeof rec.args === "object" && !Array.isArray(rec.args) ? rec.args : {}
+      });
+    }
+  }
+  return out;
+};
+var parseExecutorResponse = (raw) => {
+  const text = stripFences(raw);
+  const obj = asObject(text);
+  if (obj) {
+    const reply = typeof obj.reply === "string" ? obj.reply.trim() : "";
+    return { reply, actions: toActions(obj.actions) };
+  }
+  const arr = tryParse(extractBalanced(text, "["));
+  if (Array.isArray(arr)) {
+    const actions = toActions(arr);
+    return { reply: "", actions };
+  }
+  return { reply: looksLikeJson(text) ? "" : text.trim(), actions: [] };
+};
+var parseReplannerResponse = (raw) => {
+  const obj = asObject(stripFences(raw));
+  const decision = obj?.decision === "revise" || obj?.decision === "finish" ? obj.decision : "continue";
+  const reason = typeof obj?.reason === "string" ? obj.reason.trim() : "";
+  return { decision, reason, plan: normalizeSteps(obj?.plan) };
+};
+var parsePlainText = (raw) => {
+  const text = stripFences(raw);
+  const obj = asObject(text);
+  if (obj && typeof obj.reply === "string") return obj.reply.trim();
+  return looksLikeJson(text) ? "" : text.trim();
+};
+
+// src/llm/tool-loop.ts
+var runToolLoop = (model, opts) => opts.mode === "prompted" ? runPrompted(model, opts) : runNative(model, opts);
+var runNative = async (model, opts) => {
+  const toolCalls = [];
+  const pending = /* @__PURE__ */ new Map();
+  const result = streamText2({
+    model,
+    tools: opts.tools,
+    ...opts.activeTools ? { activeTools: opts.activeTools } : {},
+    stopWhen: stepCountIs(opts.maxSteps ?? 4),
+    system: opts.system,
+    ...promptOf(opts),
+    maxOutputTokens: opts.maxOutputTokens,
+    temperature: opts.temperature,
+    abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
+  });
+  for await (const part of result.fullStream) {
+    switch (part.type) {
+      case "text-delta":
+        if (part.text) opts.callbacks?.onTextDelta?.(part.text);
+        break;
+      case "tool-call":
+        pending.set(part.toolCallId, { name: part.toolName, input: part.input });
+        opts.callbacks?.onToolCall?.(part.toolName, part.input);
+        break;
+      case "tool-result": {
+        const known = pending.get(part.toolCallId);
+        toolCalls.push({
+          name: part.toolName,
+          input: known?.input ?? part.input,
+          output: part.output,
+          ok: true
+        });
+        opts.callbacks?.onToolResult?.(part.toolName, part.output, true);
+        pending.delete(part.toolCallId);
+        break;
+      }
+      case "tool-error": {
+        const known = pending.get(part.toolCallId);
+        toolCalls.push({
+          name: part.toolName,
+          input: known?.input ?? part.input,
+          output: part.error,
+          ok: false
+        });
+        opts.callbacks?.onToolResult?.(part.toolName, part.error, false);
+        pending.delete(part.toolCallId);
+        break;
+      }
+      case "error":
+        throw part.error instanceof Error ? part.error : new Error(String(part.error));
+    }
+  }
+  const [text, usage] = await Promise.all([result.text, result.usage]);
+  return { text: text.trim(), toolCalls, usage: normalizeUsage(usage) };
+};
+var runPrompted = async (model, opts) => {
+  const result = await generateText2({
+    model,
+    system: opts.system,
+    ...promptOf(opts),
+    maxOutputTokens: opts.maxOutputTokens,
+    temperature: opts.temperature,
+    abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
+  });
+  if (result.text) opts.callbacks?.onTextDelta?.(result.text);
+  const parsed = parseExecutorResponse(result.text);
+  const toolCalls = [];
+  for (const action of parsed.actions) {
+    opts.callbacks?.onToolCall?.(action.tool, action.args);
+    const rec = await dispatch(action, opts.tools, { abortSignal: opts.abortSignal });
+    toolCalls.push(rec);
+    opts.callbacks?.onToolResult?.(rec.name, rec.output, rec.ok);
+  }
+  return { text: parsed.reply, toolCalls, usage: normalizeUsage(result.usage) };
+};
+
+// src/agent/internal.ts
+var systemFor = (ctx, base) => withSystem(base, ctx.raw.systemPrompt);
+
+// src/agent/executor.ts
+var BLOCKER = "[BLOCKER]";
+var splitBlocker = (raw) => {
+  if (!raw.includes(BLOCKER)) return { summary: raw.trim(), blocked: false };
+  return { summary: raw.split(BLOCKER).join("").trim(), blocked: true };
+};
+var activeToolNames = (ctx, step) => {
+  if (ctx.config.toolSelectionStrategy !== "plan-narrowed") return void 0;
+  const suggested = step.suggestedTools ?? [];
+  const known = suggested.filter((n) => ctx.tools[n]);
+  if (known.length === 0 && suggested.length > 0) return Object.keys(ctx.tools);
+  return known;
+};
+var summaryOf = (text, toolCallCount) => {
+  if (text.length > 0) return text;
+  return toolCallCount > 0 ? `Executed ${toolCallCount} tool call(s).` : "Step produced no output.";
+};
+var executeStep = async (ctx, goal, step, index, total, done) => {
+  const state = await ctx.state();
+  const parts = ctx.prompts.executor({
+    goal,
+    state,
+    step: step.description,
+    index,
+    total,
+    toolCatalog: ctx.toolCatalog,
+    done,
+    mode: ctx.executorMode
+  });
+  const loop = await runToolLoop(ctx.executorModel, {
+    mode: ctx.executorMode,
+    system: systemFor(ctx, parts.system),
+    prompt: parts.prompt,
+    tools: ctx.tools,
+    activeTools: activeToolNames(ctx, step),
+    maxSteps: ctx.config.maxStepsPerTask,
+    maxOutputTokens: ctx.config.budgets.executor,
+    temperature: ctx.config.temperature,
+    abortSignal: ctx.signal,
+    timeoutMs: ctx.config.chatTimeoutMs,
+    callbacks: {
+      onTextDelta: (delta) => ctx.emit({ type: "step.text-delta", step, delta }),
+      onToolCall: (name, input) => ctx.emit({ type: "step.tool-call", step, name, input }),
+      onToolResult: (name, output, ok) => ctx.emit({ type: "step.tool-result", step, name, output, ok })
+    }
+  });
+  const { summary, blocked } = splitBlocker(loop.text);
+  return {
+    result: {
+      step,
+      summary: summaryOf(summary, loop.toolCalls.length),
+      toolCalls: loop.toolCalls,
+      blocked
+    },
+    usage: loop.usage
+  };
+};
+var shouldReplan = (result) => result.blocked || result.toolCalls.some((c) => !c.ok);
+
+// src/agent/loop-types.ts
+var emptyUsage = () => ({ inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+var addUsage = (a, b) => ({
+  inputTokens: a.inputTokens + b.inputTokens,
+  outputTokens: a.outputTokens + b.outputTokens,
+  totalTokens: a.totalTokens + b.totalTokens
+});
+
+// src/agent/schemas.ts
+import { z } from "zod";
+var PlanStepSchema = z.object({
+  description: z.string(),
+  expectedOutcome: z.string().optional(),
+  suggestedTools: z.array(z.string()).optional()
+});
+var PlanSchema = z.object({
+  /** One short sentence. For a greeting/question/unclear request, holds the answer and steps is empty. */
+  thought: z.string(),
+  steps: z.array(PlanStepSchema)
+});
+var ReplanSchema = z.object({
+  decision: z.enum(["continue", "revise", "finish"]),
+  reason: z.string(),
+  /** Replacement for the REMAINING steps when decision is 'revise'. */
+  plan: z.array(z.string()).optional()
+});
+
+// src/agent/planner.ts
+var toSteps = (raw) => raw.filter((s) => s.description && s.description.trim()).map((s, i) => ({
+  id: `s${i + 1}`,
+  description: s.description.trim(),
+  expectedOutcome: s.expectedOutcome,
+  suggestedTools: s.suggestedTools
+}));
+var createPlan = async (ctx, goal) => {
+  const state = await ctx.state();
+  const parts = ctx.prompts.planner({
+    goal,
+    state,
+    toolCatalog: ctx.toolCatalog,
+    mode: ctx.plannerMode
+  });
+  const system = systemFor(ctx, parts.system);
+  const common = {
+    system,
+    prompt: parts.prompt,
+    maxOutputTokens: ctx.config.budgets.planner,
+    temperature: ctx.config.temperature,
+    abortSignal: ctx.signal,
+    timeoutMs: ctx.config.chatTimeoutMs
+  };
+  if (ctx.plannerMode === "native") {
+    try {
+      const result2 = await generateStructured(ctx.plannerModel, PlanSchema, common);
+      return {
+        plan: { thought: result2.object.thought, steps: toSteps(result2.object.steps) },
+        usage: normalizeUsage(result2.usage)
+      };
+    } catch (err) {
+      ctx.emit({ type: "retry", phase: "plan", attempt: 1, error: asMessage(err) });
+    }
+  }
+  const result = await generate(ctx.plannerModel, common);
+  const parsed = parsePlannerResponse(result.text);
+  return {
+    plan: {
+      thought: parsed.reply,
+      steps: toSteps(parsed.plan.map((description) => ({ description })))
+    },
+    usage: ctx.plannerMode === "native" ? emptyUsage() : normalizeUsage(result.usage)
+  };
+};
+var asMessage = (err) => err instanceof Error ? err.message : String(err);
+
+// src/agent/replanner.ts
+var decideReplan = async (ctx, goal, done, remaining) => {
+  const state = await ctx.state();
+  const parts = ctx.prompts.replanner({ goal, state, done, remaining, mode: ctx.plannerMode });
+  const common = {
+    system: systemFor(ctx, parts.system),
+    prompt: parts.prompt,
+    maxOutputTokens: ctx.config.budgets.replanner,
+    temperature: ctx.config.temperature,
+    abortSignal: ctx.signal,
+    timeoutMs: ctx.config.chatTimeoutMs
+  };
+  try {
+    if (ctx.plannerMode === "native") {
+      const result2 = await generateStructured(ctx.plannerModel, ReplanSchema, common);
+      return {
+        decision: result2.object.decision,
+        reason: result2.object.reason,
+        plan: result2.object.plan ?? [],
+        usage: normalizeUsage(result2.usage)
+      };
+    }
+    const result = await generate(ctx.plannerModel, common);
+    const parsed = parseReplannerResponse(result.text);
+    return {
+      decision: parsed.decision,
+      reason: parsed.reason,
+      plan: parsed.plan,
+      usage: normalizeUsage(result.usage)
+    };
+  } catch {
+    return { decision: "continue", reason: "replanner unavailable", plan: [], usage: emptyUsage() };
+  }
+};
+
+// src/agent/synthesizer.ts
+var synthesizeAnswer = async (ctx, goal, done) => {
+  const state = await ctx.state();
+  const parts = ctx.prompts.synthesizer({ goal, state, done });
+  const result = await generate(ctx.synthesizerModel, {
+    system: systemFor(ctx, parts.system),
+    prompt: parts.prompt,
+    maxOutputTokens: ctx.config.budgets.synthesizer,
+    temperature: ctx.config.temperature,
+    abortSignal: ctx.signal,
+    timeoutMs: ctx.config.chatTimeoutMs
+  });
+  const clean = parsePlainText(result.text);
+  return {
+    text: clean || "Done \u2014 the changes have been applied.",
+    usage: normalizeUsage(result.usage)
+  };
+};
+
+// src/agent/runner.ts
+var errMessage = (err) => err instanceof Error ? err.message : String(err);
+var createAgent = async (config) => {
+  const cfg = resolveConfig(config);
+  const [plannerModel, executorModel, synthesizerModel] = await Promise.all([
+    buildModelFromStage(
+      resolveStage(config.model, config.planner, "planner"),
+      config.credentials,
+      cfg.clientName
+    ),
+    buildModelFromStage(
+      resolveStage(config.model, void 0, "executor"),
+      config.credentials,
+      cfg.clientName
+    ),
+    buildModelFromStage(
+      resolveStage(config.model, config.synthesizer, "synthesizer"),
+      config.credentials,
+      cfg.clientName
+    )
+  ]);
+  const plannerMode = selectToolMode(plannerModel, cfg.toolMode);
+  const executorMode = selectToolMode(executorModel, cfg.toolMode);
+  const tools = config.tools ?? {};
+  const toolCatalog = renderCatalog(tools);
+  const prompts = { ...defaultPrompts, ...config.prompts };
+  const run = async (goal, opts = {}) => {
+    const emit = (event) => {
+      try {
+        opts.onEvent?.(event);
+      } catch {
+      }
+    };
+    const text = goal.trim();
+    const sessionId = opts.sessionId ?? cfg.sessionId;
+    let usage = emptyUsage();
+    const result = {
+      goal: text,
+      final: "",
+      plan: { thought: "", steps: [] },
+      trace: [],
+      steps: 0,
+      applied: 0,
+      stopped: false,
+      usage
+    };
+    if (!text) return result;
+    const state = async () => config.describeState ? config.describeState() : void 0;
+    const ctx = {
+      config: cfg,
+      raw: config,
+      plannerModel,
+      executorModel,
+      synthesizerModel,
+      plannerMode,
+      executorMode,
+      tools,
+      toolCatalog,
+      prompts,
+      emit,
+      signal: opts.signal,
+      state
+    };
+    const isAborted = () => opts.signal?.aborted === true;
+    const bumpUsage = (u, phase) => {
+      usage = addUsage(usage, u);
+      result.usage = usage;
+      emit({ type: "usage", phase, usage: u });
+    };
+    const remember = async (msg) => {
+      if (!config.memory) return;
+      try {
+        await config.memory.append(sessionId, msg);
+      } catch {
+      }
+    };
+    emit({ type: "run.start", goal: text });
+    await remember({ role: "user", content: text });
+    try {
+      const planned = await createPlan(ctx, text);
+      bumpUsage(planned.usage, "plan");
+      result.plan = planned.plan;
+      if (isAborted()) {
+        emit({ type: "stopped" });
+        result.stopped = true;
+        return result;
+      }
+      if (planned.plan.steps.length === 0) {
+        const answer = planned.plan.thought.trim() || "Tell me what you'd like to do.";
+        emit({ type: "final", text: answer });
+        await remember({ role: "assistant", content: answer });
+        result.final = answer;
+        return result;
+      }
+      emit({ type: "plan.created", plan: planned.plan });
+      planned.plan.steps.forEach((step, index) => emit({ type: "plan.step-added", step, index }));
+      const done = [];
+      let remaining = [...planned.plan.steps];
+      let iter = 0;
+      let revisions = 0;
+      while (remaining.length > 0 && iter < cfg.maxIterations) {
+        if (isAborted()) {
+          emit({ type: "stopped" });
+          result.stopped = true;
+          return result;
+        }
+        iter += 1;
+        const step = remaining.shift();
+        const stepNo = done.length + 1;
+        const total = stepNo + remaining.length;
+        emit({ type: "step.start", step, index: stepNo, total });
+        let stepResult;
+        try {
+          const out = await executeStep(ctx, text, step, stepNo, total, done);
+          bumpUsage(out.usage, "execute");
+          stepResult = out.result;
+        } catch (err) {
+          emit({ type: "error", phase: "execute", error: errMessage(err) });
+          stepResult = { step, summary: errMessage(err), toolCalls: [], blocked: true };
+        }
+        result.trace.push(stepResult);
+        const applied = stepResult.toolCalls.filter((c) => c.ok).length;
+        const failed = stepResult.toolCalls.length - applied;
+        result.applied += applied;
+        result.steps = stepNo;
+        emit({ type: "step.complete", step, result: stepResult });
+        done.push(
+          `${step.description} \u2014 ${applied} applied${failed ? `, ${failed} failed` : ""}${stepResult.blocked ? ", blocked" : ""}`
+        );
+        if (cfg.replan && remaining.length > 0 && iter < cfg.maxIterations && revisions < cfg.maxRevisions && !isAborted() && shouldReplan(stepResult)) {
+          const decision = await decideReplan(
+            ctx,
+            text,
+            done,
+            remaining.map((s) => s.description)
+          );
+          bumpUsage(decision.usage, "replan");
+          emit({ type: "replan.decision", mode: decision.decision, reason: decision.reason });
+          if (decision.decision === "finish") break;
+          if (decision.decision === "revise" && decision.plan.length > 0) {
+            revisions += 1;
+            remaining = decision.plan.slice(0, cfg.maxIterations - iter).map((description, i) => ({ id: `r${iter}-${i + 1}`, description }));
+            emit({
+              type: "plan.revised",
+              plan: { thought: planned.plan.thought, steps: remaining },
+              reason: decision.reason
+            });
+          }
+        }
+      }
+      if (isAborted()) {
+        emit({ type: "stopped" });
+        result.stopped = true;
+        return result;
+      }
+      let summary = "Done \u2014 the changes have been applied.";
+      if (cfg.synthesize) {
+        try {
+          const synth = await synthesizeAnswer(ctx, text, done);
+          bumpUsage(synth.usage, "synthesize");
+          if (synth.text) summary = synth.text;
+        } catch {
+        }
+      }
+      emit({ type: "final", text: summary });
+      await remember({ role: "assistant", content: summary });
+      result.final = summary;
+      if (config.memory && cfg.compressAfterChars > 0) {
+        try {
+          const history = await config.memory.load(sessionId);
+          const compacted = await compressHistory(history, synthesizerModel, {
+            maxChars: cfg.compressAfterChars
+          });
+          if (compacted !== history) await config.memory.replace(sessionId, compacted);
+        } catch {
+        }
+      }
+      return result;
+    } catch (err) {
+      emit({ type: "error", phase: "run", error: errMessage(err) });
+      result.final = errMessage(err);
+      return result;
+    }
+  };
+  return {
+    run,
+    models: { planner: plannerModel, executor: executorModel, synthesizer: synthesizerModel }
+  };
+};
+
+// src/providers/capabilities.ts
+var CLOUD = /* @__PURE__ */ new Set([
+  "openai",
+  "anthropic",
+  "google",
+  "openai-compatible",
+  "xai",
+  "deepseek",
+  "gateway"
+]);
+var supportsNativeTools = (p) => CLOUD.has(p);
+var supportsStructuredOutput = (p) => CLOUD.has(p);
+var directBrowserOk = (p) => p === "google" || p === "gateway" || p === "openai-compatible" || p === "anthropic";
+
+// src/storage/db.ts
+import { openDB } from "idb";
+var KEYS_STORE = "keys";
+var SECRETS_STORE = "secrets";
+var SESSIONS_STORE = "sessions";
+var cache = /* @__PURE__ */ new Map();
+var openAgentWebDB = (opts = {}) => {
+  const name = opts.dbName ?? "agent-web";
+  let p = cache.get(name);
+  if (!p) {
+    p = openDB(name, 1, {
+      upgrade(db) {
+        if (!db.objectStoreNames.contains(KEYS_STORE)) db.createObjectStore(KEYS_STORE);
+        if (!db.objectStoreNames.contains(SECRETS_STORE)) db.createObjectStore(SECRETS_STORE);
+        if (!db.objectStoreNames.contains(SESSIONS_STORE)) db.createObjectStore(SESSIONS_STORE);
+      }
+    });
+    cache.set(name, p);
+  }
+  return p;
+};
+
+// src/secrets/crypto.ts
+var KEY_ID = "vault-key-v1";
+var webcrypto = () => {
+  const c = globalThis.crypto;
+  if (!c?.subtle || !c.getRandomValues) {
+    throw new Error("WebCrypto (crypto.subtle) is unavailable in this environment");
+  }
+  return c;
+};
+var getOrCreateVaultKey = async (dbName) => {
+  const db = await openAgentWebDB({ dbName });
+  const existing = await db.get(KEYS_STORE, KEY_ID);
+  if (existing) return existing;
+  const key = await webcrypto().subtle.generateKey(
+    { name: "AES-GCM", length: 256 },
+    /* extractable */
+    false,
+    ["encrypt", "decrypt"]
+  );
+  await db.put(KEYS_STORE, key, KEY_ID);
+  return key;
+};
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var encryptJSON = async (key, value) => {
+  const c = webcrypto();
+  const iv = c.getRandomValues(new Uint8Array(12));
+  const data = textEncoder.encode(JSON.stringify(value));
+  const ciphertext = await c.subtle.encrypt({ name: "AES-GCM", iv }, key, data);
+  return { iv, ciphertext };
+};
+var decryptJSON = async (key, blob) => {
+  const iv = new Uint8Array(blob.iv);
+  const plain = await webcrypto().subtle.decrypt({ name: "AES-GCM", iv }, key, blob.ciphertext);
+  return JSON.parse(textDecoder.decode(plain));
+};
+
+// src/secrets/vault.ts
+var IndexedDBVault = class {
+  dbName;
+  constructor(opts = {}) {
+    this.dbName = opts.dbName;
+  }
+  key() {
+    return getOrCreateVaultKey(this.dbName);
+  }
+  /** Encrypt and store a secret string under `id`. */
+  async setSecret(id, value) {
+    const blob = await encryptJSON(await this.key(), value);
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    await db.put(SECRETS_STORE, blob, id);
+  }
+  /** Fetch and decrypt a secret, or undefined if absent. */
+  async getSecret(id) {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    const blob = await db.get(SECRETS_STORE, id);
+    if (!blob) return void 0;
+    return decryptJSON(await this.key(), blob);
+  }
+  async deleteSecret(id) {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    await db.delete(SECRETS_STORE, id);
+  }
+  async listSecretIds() {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    return (await db.getAllKeys(SECRETS_STORE)).map(String);
+  }
+};
+
+// src/secrets/store.ts
+var VaultCredentialStore = class {
+  vault;
+  constructor(opts = {}) {
+    this.vault = new IndexedDBVault(opts);
+  }
+  getApiKey(ref) {
+    return this.vault.getSecret(ref);
+  }
+  setApiKey(ref, key) {
+    return this.vault.setSecret(ref, key);
+  }
+  deleteApiKey(ref) {
+    return this.vault.deleteSecret(ref);
+  }
+};
+var MemoryCredentialStore = class {
+  map = /* @__PURE__ */ new Map();
+  constructor(initial) {
+    if (initial) for (const [k, v] of Object.entries(initial)) this.map.set(k, v);
+  }
+  async getApiKey(ref) {
+    return this.map.get(ref);
+  }
+  async setApiKey(ref, key) {
+    this.map.set(ref, key);
+  }
+  async deleteApiKey(ref) {
+    this.map.delete(ref);
+  }
+};
+
+// src/tools/define.ts
+import { tool } from "ai";
+var defineTool = (config) => {
+  const { promptHint, ...rest } = config;
+  const t = tool(rest);
+  if (promptHint) t.promptHint = promptHint;
+  return t;
+};
+
+// src/memory/store.ts
+var MemoryStore = class {
+  data = /* @__PURE__ */ new Map();
+  async load(sessionId) {
+    return (this.data.get(sessionId) ?? []).slice();
+  }
+  async append(sessionId, message) {
+    const arr = this.data.get(sessionId) ?? [];
+    arr.push(message);
+    this.data.set(sessionId, arr);
+  }
+  async replace(sessionId, messages) {
+    this.data.set(sessionId, messages.slice());
+  }
+  async clear(sessionId) {
+    this.data.delete(sessionId);
+  }
+};
+
+// src/memory/sessions.ts
+var IndexedDBStore = class {
+  dbName;
+  constructor(opts = {}) {
+    this.dbName = opts.dbName;
+  }
+  async load(sessionId) {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    const value = await db.get(SESSIONS_STORE, sessionId);
+    return Array.isArray(value) ? value : [];
+  }
+  async replace(sessionId, messages) {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    await db.put(SESSIONS_STORE, messages, sessionId);
+  }
+  async append(sessionId, message) {
+    const current = await this.load(sessionId);
+    current.push(message);
+    await this.replace(sessionId, current);
+  }
+  async clear(sessionId) {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    await db.delete(SESSIONS_STORE, sessionId);
+  }
+  /** List all stored session ids. */
+  async listSessions() {
+    const db = await openAgentWebDB({ dbName: this.dbName });
+    return (await db.getAllKeys(SESSIONS_STORE)).map(String);
+  }
+};
+export {
+  IndexedDBStore,
+  IndexedDBVault,
+  KEYS_STORE,
+  MemoryCredentialStore,
+  MemoryStore,
+  PlanSchema,
+  PlanStepSchema,
+  ReplanSchema,
+  SECRETS_STORE,
+  SESSIONS_STORE,
+  VaultCredentialStore,
+  buildModelFromStage,
+  compressHistory,
+  createAgent,
+  createPlan,
+  createWebLLMModel,
+  decideReplan,
+  decryptJSON,
+  defaultPrompts,
+  defineTool,
+  directBrowserOk,
+  dispatch,
+  encryptJSON,
+  executeStep,
+  generate,
+  generateStructured,
+  getOrCreateVaultKey,
+  isDirectModel,
+  isProviderSpec,
+  isWebGPUAvailable,
+  looksLikeJson,
+  normalizeSteps,
+  normalizeUsage,
+  openAgentWebDB,
+  parseExecutorResponse,
+  parsePlainText,
+  parsePlannerResponse,
+  parseReplannerResponse,
+  promptHintOf,
+  renderCatalog,
+  resolveConfig,
+  resolveModel,
+  resolveStage,
+  runToolLoop,
+  selectToolMode,
+  shouldReplan,
+  splitBlocker,
+  stream,
+  supportsNativeTools,
+  supportsStructuredOutput,
+  synthesizeAnswer,
+  withSystem
+};
+//# sourceMappingURL=index.js.map