@dudko.dev/agent-web 0.0.1 → 0.0.2

package/dist/index.d.cts

@@ -105,6 +105,11 @@ interface PlannerPromptContext {
     state?: string;
     toolCatalog: string;
     mode: ToolCallMode;
+    /** Prior session messages (oldest first), for resolving references to earlier turns. */
+    history?: {
+        role: string;
+        content: string;
+    }[];
 }
 interface ExecutorPromptContext {
     goal: string;
@@ -242,7 +247,9 @@ interface BrowserAgentConfig {
     clientName?: string;
     /** Host tools the executor may call (an AI SDK ToolSet; use defineTool). */
     tools?: AgentToolSet;
+    /** Whitelist: only these tool names from `tools` are mounted (default: all). */
     availableTools?: string[];
+    /** Blacklist: these tool names are removed after the whitelist is applied. */
     excludedTools?: string[];
     /** Force native/prompted tool-calling; 'auto' picks per model (default 'auto'). */
     toolMode?: ToolMode;
@@ -253,7 +260,11 @@ interface BrowserAgentConfig {
     prompts?: Partial<Prompts>;
     /** Serialize the host's current world state into prompt context (grounding). */
     describeState?: () => string | Promise<string>;
-    /** Persist the transcript (e.g. new IndexedDBStore()). */
+    /**
+     * Persist the transcript (e.g. new IndexedDBStore()). The last few messages
+     * are also read back into the planner prompt, so follow-up goals can refer
+     * to earlier turns.
+     */
     memory?: ContextStore;
     sessionId?: string;
     /** Hard cap on executed steps incl. replans (default 8). */
@@ -486,6 +497,8 @@ interface AgentContext {
     signal?: AbortSignal;
     /** Current world state for grounding, or undefined when no describeState is configured. */
     state: () => Promise<string | undefined>;
+    /** Session transcript loaded from memory BEFORE this run's goal was appended. */
+    history?: StoredMessage[];
 }
 
 /**
@@ -570,8 +583,10 @@ interface ReplanOutcome {
 declare const decideReplan: (ctx: AgentContext, goal: string, done: string[], remaining: string[]) => Promise<ReplanOutcome>;
 
 /**
- * Write the final natural-language summary of what the run accomplished. Plain
- * text only (parsePlainText strips any stray JSON). Falls back to a default
+ * Write the final natural-language summary of what the run accomplished,
+ * streaming it as `final.text-delta` events. Plain text only (parsePlainText
+ * strips any stray JSON; deltas are suppressed entirely when the model drifts
+ * into JSON, so raw structure never reaches a UI). Falls back to a default
  * sentence if the model returns nothing usable.
  */
 declare const synthesizeAnswer: (ctx: AgentContext, goal: string, done: string[]) => Promise<{
@@ -646,6 +661,10 @@ declare const directBrowserOk: (p: ProviderType) => boolean;
  * ever being exposed to JavaScript. Not even in-page script can read it out; it
  * can only be used to encrypt / decrypt. That is what makes at-rest storage of
  * the secrets meaningful (see IndexedDBVault's threat model).
+ *
+ * Concurrent callers share one in-flight promise per DB, and creation is
+ * double-checked in a single IDB transaction, so two racing writers can never
+ * end up encrypting under different keys.
  */
 declare const getOrCreateVaultKey: (dbName?: string) => Promise<CryptoKey>;
 interface EncryptedBlob {
@@ -716,7 +735,10 @@ interface ToolLoopOptions {
     messages?: ModelMessage[];
     /** In native mode: the callable tools. In prompted mode: used to dispatch salvaged calls. */
     tools: ToolSet;
-    /** Native mode: restrict callable tools to these names (plan-narrowed). */
+    /**
+     * Restrict callable tools to these names (plan-narrowed). Native mode passes
+     * them to the SDK's `activeTools`; prompted mode bounds `dispatch` to them.
+     */
     activeTools?: string[];
     /** Native mode: cap on internal tool-calling steps (default 4). */
     maxSteps?: number;
@@ -795,6 +817,8 @@ declare const dispatch: (action: RawAction, tools: ToolSet, ctx?: DispatchContex
  * Decide the tool-calling strategy for a resolved model. An explicit
  * config.toolMode of 'native'/'prompted' always wins; 'auto' (default) inspects
  * the model's provider id — local/on-device runtimes → 'prompted', cloud → 'native'.
+ * A string model is a gateway model id ("openai/gpt-4o") — always cloud; the
+ * LOCAL_RE must not see it, or model names like "gpt-5-nano" would match `nano`.
  */
 declare const selectToolMode: (model: LanguageModel, mode?: ToolMode) => "native" | "prompted";
 
@@ -823,6 +847,9 @@ interface CompressOptions {
     maxChars?: number;
     /** How many most-recent messages to keep verbatim. */
     keepRecent?: number;
+    /** Time-box the summarisation call so it can never hang the caller. */
+    timeoutMs?: number;
+    abortSignal?: AbortSignal;
 }
 /**
  * When the transcript grows too long, summarise everything except the last

package/dist/index.d.ts

@@ -105,6 +105,11 @@ interface PlannerPromptContext {
     state?: string;
     toolCatalog: string;
     mode: ToolCallMode;
+    /** Prior session messages (oldest first), for resolving references to earlier turns. */
+    history?: {
+        role: string;
+        content: string;
+    }[];
 }
 interface ExecutorPromptContext {
     goal: string;
@@ -242,7 +247,9 @@ interface BrowserAgentConfig {
     clientName?: string;
     /** Host tools the executor may call (an AI SDK ToolSet; use defineTool). */
     tools?: AgentToolSet;
+    /** Whitelist: only these tool names from `tools` are mounted (default: all). */
     availableTools?: string[];
+    /** Blacklist: these tool names are removed after the whitelist is applied. */
     excludedTools?: string[];
     /** Force native/prompted tool-calling; 'auto' picks per model (default 'auto'). */
     toolMode?: ToolMode;
@@ -253,7 +260,11 @@ interface BrowserAgentConfig {
     prompts?: Partial<Prompts>;
     /** Serialize the host's current world state into prompt context (grounding). */
     describeState?: () => string | Promise<string>;
-    /** Persist the transcript (e.g. new IndexedDBStore()). */
+    /**
+     * Persist the transcript (e.g. new IndexedDBStore()). The last few messages
+     * are also read back into the planner prompt, so follow-up goals can refer
+     * to earlier turns.
+     */
     memory?: ContextStore;
     sessionId?: string;
     /** Hard cap on executed steps incl. replans (default 8). */
@@ -486,6 +497,8 @@ interface AgentContext {
     signal?: AbortSignal;
     /** Current world state for grounding, or undefined when no describeState is configured. */
     state: () => Promise<string | undefined>;
+    /** Session transcript loaded from memory BEFORE this run's goal was appended. */
+    history?: StoredMessage[];
 }
 
 /**
@@ -570,8 +583,10 @@ interface ReplanOutcome {
 declare const decideReplan: (ctx: AgentContext, goal: string, done: string[], remaining: string[]) => Promise<ReplanOutcome>;
 
 /**
- * Write the final natural-language summary of what the run accomplished. Plain
- * text only (parsePlainText strips any stray JSON). Falls back to a default
+ * Write the final natural-language summary of what the run accomplished,
+ * streaming it as `final.text-delta` events. Plain text only (parsePlainText
+ * strips any stray JSON; deltas are suppressed entirely when the model drifts
+ * into JSON, so raw structure never reaches a UI). Falls back to a default
  * sentence if the model returns nothing usable.
  */
 declare const synthesizeAnswer: (ctx: AgentContext, goal: string, done: string[]) => Promise<{
@@ -646,6 +661,10 @@ declare const directBrowserOk: (p: ProviderType) => boolean;
  * ever being exposed to JavaScript. Not even in-page script can read it out; it
  * can only be used to encrypt / decrypt. That is what makes at-rest storage of
  * the secrets meaningful (see IndexedDBVault's threat model).
+ *
+ * Concurrent callers share one in-flight promise per DB, and creation is
+ * double-checked in a single IDB transaction, so two racing writers can never
+ * end up encrypting under different keys.
  */
 declare const getOrCreateVaultKey: (dbName?: string) => Promise<CryptoKey>;
 interface EncryptedBlob {
@@ -716,7 +735,10 @@ interface ToolLoopOptions {
     messages?: ModelMessage[];
     /** In native mode: the callable tools. In prompted mode: used to dispatch salvaged calls. */
     tools: ToolSet;
-    /** Native mode: restrict callable tools to these names (plan-narrowed). */
+    /**
+     * Restrict callable tools to these names (plan-narrowed). Native mode passes
+     * them to the SDK's `activeTools`; prompted mode bounds `dispatch` to them.
+     */
     activeTools?: string[];
     /** Native mode: cap on internal tool-calling steps (default 4). */
     maxSteps?: number;
@@ -795,6 +817,8 @@ declare const dispatch: (action: RawAction, tools: ToolSet, ctx?: DispatchContex
  * Decide the tool-calling strategy for a resolved model. An explicit
  * config.toolMode of 'native'/'prompted' always wins; 'auto' (default) inspects
  * the model's provider id — local/on-device runtimes → 'prompted', cloud → 'native'.
+ * A string model is a gateway model id ("openai/gpt-4o") — always cloud; the
+ * LOCAL_RE must not see it, or model names like "gpt-5-nano" would match `nano`.
  */
 declare const selectToolMode: (model: LanguageModel, mode?: ToolMode) => "native" | "prompted";
 
@@ -823,6 +847,9 @@ interface CompressOptions {
     maxChars?: number;
     /** How many most-recent messages to keep verbatim. */
     keepRecent?: number;
+    /** Time-box the summarisation call so it can never hang the caller. */
+    timeoutMs?: number;
+    abortSignal?: AbortSignal;
 }
 /**
  * When the transcript grows too long, summarise everything except the last

package/dist/index.js

@@ -94,7 +94,9 @@ var compressHistory = async (messages, model, opts = {}) => {
     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
+      maxOutputTokens: 400,
+      timeoutMs: opts.timeoutMs,
+      abortSignal: opts.abortSignal
     });
     const clean = (result.text || "").trim();
     if (!clean) return messages;
@@ -302,9 +304,19 @@ var stateBlock = (state) => state && state.trim() ? `
 
 STATE:
 ${state}` : "";
+var clip = (s, max) => s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+var historyBlock = (history) => {
+  if (!history || history.length === 0) return "";
+  const lines = history.slice(-8).map((m) => `${m.role}: ${clip(m.content, 400)}`);
+  return `
+
+CONVERSATION SO FAR:
+${lines.join("\n")}`;
+};
 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".
+If a CONVERSATION SO FAR section is present, use it to resolve references to earlier turns.
 Never repeat or pad steps.`;
 var PLANNER_PROMPTED = `You are the PLANNER of a tool-using agent that changes a workspace step by step.
 
@@ -312,7 +324,8 @@ 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.`;
+- Plan realistic steps the available TOOLS can perform, grounded in the current STATE.
+- If a CONVERSATION SO FAR section is present, use it to resolve references to earlier turns.`;
 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).
@@ -340,7 +353,7 @@ var SYNTHESIZER_SYSTEM = `You are the SYNTHESIZER. In 1\u20133 short, friendly s
 var defaultPrompts = {
   planner: (ctx) => ({
     system: ctx.mode === "prompted" ? PLANNER_PROMPTED : PLANNER_NATIVE,
-    prompt: `GOAL: ${ctx.goal}${stateBlock(ctx.state)}
+    prompt: `GOAL: ${ctx.goal}${historyBlock(ctx.history)}${stateBlock(ctx.state)}
 
 TOOLS:
 ${ctx.toolCatalog}`
@@ -385,11 +398,12 @@ 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";
+  if (typeof model === "string") return "native";
+  const provider = model.provider ?? "";
+  return LOCAL_RE.test(provider) ? "prompted" : "native";
 };
 
 // src/tools/types.ts
@@ -514,24 +528,35 @@ var normalizeSteps = (arr, cap = 12) => {
   }
   return out;
 };
+var decodeJsonString = (body) => {
+  const v = tryParse(`"${body}"`);
+  return typeof v === "string" ? v : body;
+};
 var salvageStringArray = (text, field) => {
-  const at = text.search(new RegExp(`"${field}"\\s*:`));
-  if (at < 0) return [];
-  const region = text.slice(at);
+  const m = new RegExp(`"${field}"\\s*:\\s*\\[`).exec(text);
+  if (!m) return [];
   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);
+  let i = m.index + m[0].length;
+  while (i < text.length && text[i] !== "]") {
+    if (text[i] !== '"') {
+      i += 1;
+      continue;
+    }
+    let j = i + 1;
+    let esc = false;
+    while (j < text.length && (esc || text[j] !== '"')) {
+      esc = !esc && text[j] === "\\";
+      j += 1;
+    }
+    if (j >= text.length) break;
+    out.push(decodeJsonString(text.slice(i + 1, j)));
+    i = j + 1;
   }
   return out;
 };
 var salvageString = (text, field) => {
   const m = text.match(new RegExp(`"${field}"\\s*:\\s*"((?:[^"\\\\]|\\\\.)*)"`));
-  return m ? m[1].trim() : "";
+  return m ? decodeJsonString(m[1]).trim() : "";
 };
 var parsePlannerResponse = (raw) => {
   const text = stripFences(raw);
@@ -654,12 +679,14 @@ var runPrompted = async (model, opts) => {
     temperature: opts.temperature,
     abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
   });
-  if (result.text) opts.callbacks?.onTextDelta?.(result.text);
   const parsed = parseExecutorResponse(result.text);
+  if (parsed.reply) opts.callbacks?.onTextDelta?.(parsed.reply);
+  const active = opts.activeTools;
+  const tools = active ? Object.fromEntries(Object.entries(opts.tools).filter(([name]) => active.includes(name))) : opts.tools;
   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 });
+    const rec = await dispatch(action, tools, { abortSignal: opts.abortSignal });
     toolCalls.push(rec);
     opts.callbacks?.onToolResult?.(rec.name, rec.output, rec.ok);
   }
@@ -688,13 +715,15 @@ var summaryOf = (text, toolCallCount) => {
 };
 var executeStep = async (ctx, goal, step, index, total, done) => {
   const state = await ctx.state();
+  const active = activeToolNames(ctx, step);
+  const toolCatalog = active === void 0 ? ctx.toolCatalog : renderCatalog(Object.fromEntries(active.map((name) => [name, ctx.tools[name]])));
   const parts = ctx.prompts.executor({
     goal,
     state,
     step: step.description,
     index,
     total,
-    toolCatalog: ctx.toolCatalog,
+    toolCatalog,
     done,
     mode: ctx.executorMode
   });
@@ -703,7 +732,7 @@ var executeStep = async (ctx, goal, step, index, total, done) => {
     system: systemFor(ctx, parts.system),
     prompt: parts.prompt,
     tools: ctx.tools,
-    activeTools: activeToolNames(ctx, step),
+    activeTools: active,
     maxSteps: ctx.config.maxStepsPerTask,
     maxOutputTokens: ctx.config.budgets.executor,
     temperature: ctx.config.temperature,
@@ -764,24 +793,26 @@ var toSteps = (raw) => raw.filter((s) => s.description && s.description.trim()).
 }));
 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
+  const commonFor = (mode) => {
+    const parts = ctx.prompts.planner({
+      goal,
+      state,
+      toolCatalog: ctx.toolCatalog,
+      mode,
+      history: ctx.history
+    });
+    return {
+      system: systemFor(ctx, parts.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);
+      const result2 = await generateStructured(ctx.plannerModel, PlanSchema, commonFor("native"));
       return {
         plan: { thought: result2.object.thought, steps: toSteps(result2.object.steps) },
         usage: normalizeUsage(result2.usage)
@@ -790,14 +821,14 @@ var createPlan = async (ctx, goal) => {
       ctx.emit({ type: "retry", phase: "plan", attempt: 1, error: asMessage(err) });
     }
   }
-  const result = await generate(ctx.plannerModel, common);
+  const result = await generate(ctx.plannerModel, commonFor("prompted"));
   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)
+    usage: normalizeUsage(result.usage)
   };
 };
 var asMessage = (err) => err instanceof Error ? err.message : String(err);
@@ -805,26 +836,31 @@ 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
+  const commonFor = (mode) => {
+    const parts = ctx.prompts.replanner({ goal, state, done, remaining, mode });
+    return {
+      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);
+  if (ctx.plannerMode === "native") {
+    try {
+      const result = await generateStructured(ctx.plannerModel, ReplanSchema, commonFor("native"));
       return {
-        decision: result2.object.decision,
-        reason: result2.object.reason,
-        plan: result2.object.plan ?? [],
-        usage: normalizeUsage(result2.usage)
+        decision: result.object.decision,
+        reason: result.object.reason,
+        plan: result.object.plan ?? [],
+        usage: normalizeUsage(result.usage)
       };
+    } catch {
     }
-    const result = await generate(ctx.plannerModel, common);
+  }
+  try {
+    const result = await generate(ctx.plannerModel, commonFor("prompted"));
     const parsed = parseReplannerResponse(result.text);
     return {
       decision: parsed.decision,
@@ -841,7 +877,7 @@ var decideReplan = async (ctx, goal, done, remaining) => {
 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, {
+  const result = stream(ctx.synthesizerModel, {
     system: systemFor(ctx, parts.system),
     prompt: parts.prompt,
     maxOutputTokens: ctx.config.budgets.synthesizer,
@@ -849,37 +885,54 @@ var synthesizeAnswer = async (ctx, goal, done) => {
     abortSignal: ctx.signal,
     timeoutMs: ctx.config.chatTimeoutMs
   });
-  const clean = parsePlainText(result.text);
+  let text = "";
+  let verdict = "unknown";
+  for await (const delta of result.textStream) {
+    text += delta;
+    if (verdict === "unknown") {
+      const lead = text.trimStart();
+      if (!lead) continue;
+      verdict = looksLikeJson(lead) ? "suppress" : "emit";
+      if (verdict === "emit") ctx.emit({ type: "final.text-delta", delta: text });
+    } else if (verdict === "emit") {
+      ctx.emit({ type: "final.text-delta", delta });
+    }
+  }
+  const clean = parsePlainText(text);
   return {
     text: clean || "Done \u2014 the changes have been applied.",
-    usage: normalizeUsage(result.usage)
+    usage: normalizeUsage(await result.usage)
   };
 };
 
 // src/agent/runner.ts
 var errMessage = (err) => err instanceof Error ? err.message : String(err);
+var filterTools = (all, available, excluded) => {
+  let entries = Object.entries(all);
+  if (available && available.length > 0) entries = entries.filter(([n]) => available.includes(n));
+  if (excluded && excluded.length > 0) entries = entries.filter(([n]) => !excluded.includes(n));
+  return Object.fromEntries(entries);
+};
 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 buildStage = (override, stageName) => buildModelFromStage(
+    resolveStage(config.model, override, stageName),
+    config.credentials,
+    cfg.clientName
+  );
+  const executorP = buildStage(void 0, "executor");
+  const [executorModel, plannerModel, synthesizerModel] = await Promise.all([
+    executorP,
+    config.planner === void 0 ? executorP : buildStage(config.planner, "planner"),
+    config.synthesizer === void 0 ? executorP : buildStage(config.synthesizer, "synthesizer")
   ]);
   const plannerMode = selectToolMode(plannerModel, cfg.toolMode);
   const executorMode = selectToolMode(executorModel, cfg.toolMode);
-  const tools = config.tools ?? {};
+  const tools = filterTools(
+    config.tools ?? {},
+    config.availableTools,
+    config.excludedTools
+  );
   const toolCatalog = renderCatalog(tools);
   const prompts = { ...defaultPrompts, ...config.prompts };
   const run = async (goal, opts = {}) => {
@@ -904,21 +957,6 @@ var createAgent = async (config) => {
     };
     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);
@@ -933,6 +971,29 @@ var createAgent = async (config) => {
       }
     };
     emit({ type: "run.start", goal: text });
+    let history = [];
+    if (config.memory) {
+      try {
+        history = await config.memory.load(sessionId);
+      } catch {
+      }
+    }
+    const ctx = {
+      config: cfg,
+      raw: config,
+      plannerModel,
+      executorModel,
+      synthesizerModel,
+      plannerMode,
+      executorMode,
+      tools,
+      toolCatalog,
+      prompts,
+      emit,
+      signal: opts.signal,
+      state,
+      history
+    };
     await remember({ role: "user", content: text });
     try {
       const planned = await createPlan(ctx, text);
@@ -973,6 +1034,11 @@ var createAgent = async (config) => {
           bumpUsage(out.usage, "execute");
           stepResult = out.result;
         } catch (err) {
+          if (isAborted()) {
+            emit({ type: "stopped" });
+            result.stopped = true;
+            return result;
+          }
           emit({ type: "error", phase: "execute", error: errMessage(err) });
           stepResult = { step, summary: errMessage(err), toolCalls: [], blocked: true };
         }
@@ -985,7 +1051,7 @@ var createAgent = async (config) => {
         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)) {
+        if (cfg.replan && iter < cfg.maxIterations && revisions < cfg.maxRevisions && !isAborted() && shouldReplan(stepResult)) {
           const decision = await decideReplan(
             ctx,
             text,
@@ -1025,11 +1091,13 @@ var createAgent = async (config) => {
       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
+          const transcript = await config.memory.load(sessionId);
+          const compacted = await compressHistory(transcript, synthesizerModel, {
+            maxChars: cfg.compressAfterChars,
+            timeoutMs: cfg.chatTimeoutMs,
+            abortSignal: opts.signal
           });
-          if (compacted !== history) await config.memory.replace(sessionId, compacted);
+          if (compacted !== transcript) await config.memory.replace(sessionId, compacted);
         } catch {
         }
       }
@@ -1078,6 +1146,9 @@ var openAgentWebDB = (opts = {}) => {
       }
     });
     cache.set(name, p);
+    p.catch(() => {
+      if (cache.get(name) === p) cache.delete(name);
+    });
   }
   return p;
 };
@@ -1091,7 +1162,7 @@ var webcrypto = () => {
   }
   return c;
 };
-var getOrCreateVaultKey = async (dbName) => {
+var loadOrCreateKey = async (dbName) => {
   const db = await openAgentWebDB({ dbName });
   const existing = await db.get(KEYS_STORE, KEY_ID);
   if (existing) return existing;
@@ -1101,9 +1172,29 @@ var getOrCreateVaultKey = async (dbName) => {
     false,
     ["encrypt", "decrypt"]
   );
-  await db.put(KEYS_STORE, key, KEY_ID);
+  const tx = db.transaction(KEYS_STORE, "readwrite");
+  const winner = await tx.store.get(KEY_ID);
+  if (winner) {
+    await tx.done;
+    return winner;
+  }
+  await tx.store.put(key, KEY_ID);
+  await tx.done;
   return key;
 };
+var keyCache = /* @__PURE__ */ new Map();
+var getOrCreateVaultKey = (dbName) => {
+  const cacheKey = dbName ?? "agent-web";
+  let p = keyCache.get(cacheKey);
+  if (!p) {
+    p = loadOrCreateKey(dbName);
+    keyCache.set(cacheKey, p);
+    p.catch(() => {
+      if (keyCache.get(cacheKey) === p) keyCache.delete(cacheKey);
+    });
+  }
+  return p;
+};
 var textEncoder = new TextEncoder();
 var textDecoder = new TextDecoder();
 var encryptJSON = async (key, value) => {