@dudko.dev/agent-web 0.0.1 → 0.0.3

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) => {