@dudko.dev/agent-web 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -119,6 +119,7 @@ __export(src_exports, {
   preloadWebLLMModel: () => preloadWebLLMModel,
   promptHintOf: () => promptHintOf,
   renderCatalog: () => renderCatalog,
+  replanWanted: () => replanWanted,
   resolveConfig: () => resolveConfig,
   resolveModel: () => resolveModel,
   resolveStage: () => resolveStage,
@@ -153,6 +154,7 @@ var resolveConfig = (c) => ({
   },
   temperature: c.temperature,
   replan: c.replan ?? true,
+  replanAfter: c.replanAfter ?? "failure",
   synthesize: c.synthesize ?? true,
   compressAfterChars: c.compressAfterChars ?? 12e3,
   logLevel: c.logLevel ?? "warn"
@@ -162,6 +164,7 @@ var resolveConfig = (c) => ({
 var import_ai = require("ai");
 
 // src/llm/util.ts
+var clip = (s, max) => s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
 var promptOf = (opts) => opts.messages ? { messages: opts.messages } : { prompt: opts.prompt ?? "" };
 var normalizeUsage = (u) => {
   const inputTokens = u?.inputTokens ?? 0;
@@ -434,7 +437,6 @@ 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)}`);
@@ -467,8 +469,9 @@ Reply with a single JSON object, nothing else:
 - "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.
+- After your actions run you will see their TOOL RESULTS and may continue the same step; finish with "actions": [] once it is done.
 - 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.
+var REPLANNER_NATIVE = `You are the REPLANNER. After an executed step, 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.
@@ -598,6 +601,15 @@ var dispatch = async (action, tools, ctx = {}) => {
 // src/llm/tool-loop.ts
 var import_ai3 = require("ai");
 
+// src/agent/loop-types.ts
+var BLOCKER = "[BLOCKER]";
+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/parse.ts
 var stripFences = (text) => (text || "").replace(/```(?:json)?/gi, "").trim();
 var extractBalanced = (text, open) => {
@@ -796,34 +808,74 @@ var runNative = async (model, opts) => {
   const [text, usage] = await Promise.all([result.text, result.usage]);
   return { text: text.trim(), toolCalls, usage: normalizeUsage(usage) };
 };
+var asJson = (value) => {
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var toolResultsPrompt = (results) => {
+  const lines = results.map(
+    (r) => `- ${r.name} ${clip(asJson(r.input), 160)} \u2192 ${r.ok ? "ok" : "FAILED"}: ${clip(asJson(r.output), 400)}`
+  );
+  return `TOOL RESULTS:
+${lines.join("\n")}
+
+Continue THIS step using the results above. Reply with a single JSON object, nothing else:
+{ "reply": string, "actions": [ { "tool": string, "args": object } ] }
+- If the step is now complete: "actions": [] and a short outcome in "reply".
+- Otherwise emit ONLY the remaining or corrective calls \u2014 never repeat a successful call.`;
+};
 var runPrompted = async (model, opts) => {
-  const result = await (0, import_ai3.generateText)({
-    model,
-    system: opts.system,
-    ...promptOf(opts),
-    maxOutputTokens: opts.maxOutputTokens,
-    temperature: opts.temperature,
-    abortSignal: timeoutSignal(opts.abortSignal, opts.timeoutMs)
-  });
-  const parsed = parseExecutorResponse(result.text);
-  if (parsed.reply) opts.callbacks?.onTextDelta?.(parsed.reply);
+  const maxRounds = Math.max(1, opts.maxSteps ?? 4);
   const active = opts.activeTools;
   const tools = active ? Object.fromEntries(Object.entries(opts.tools).filter(([name]) => active.includes(name))) : opts.tools;
+  const signal = timeoutSignal(opts.abortSignal, opts.timeoutMs);
+  const messages = opts.messages ? [...opts.messages] : [{ role: "user", content: opts.prompt ?? "" }];
   const toolCalls = [];
-  for (const action of parsed.actions) {
-    opts.callbacks?.onToolCall?.(action.tool, action.args);
-    const rec = await dispatch(action, tools, { abortSignal: opts.abortSignal });
-    toolCalls.push(rec);
-    opts.callbacks?.onToolResult?.(rec.name, rec.output, rec.ok);
+  const seen = /* @__PURE__ */ new Set();
+  let usage = emptyUsage();
+  let text = "";
+  for (let round = 1; round <= maxRounds; round += 1) {
+    if (signal?.aborted) break;
+    const result = await (0, import_ai3.generateText)({
+      model,
+      system: opts.system,
+      messages,
+      maxOutputTokens: opts.maxOutputTokens,
+      temperature: opts.temperature,
+      abortSignal: signal
+    });
+    usage = addUsage(usage, normalizeUsage(result.usage));
+    const parsed = parseExecutorResponse(result.text);
+    text = parsed.reply;
+    if (parsed.reply.includes(BLOCKER)) break;
+    if (parsed.actions.length === 0) break;
+    const batch = asJson(parsed.actions);
+    if (seen.has(batch)) break;
+    seen.add(batch);
+    const results = [];
+    for (const action of parsed.actions) {
+      if (signal?.aborted) break;
+      opts.callbacks?.onToolCall?.(action.tool, action.args);
+      const rec = await dispatch(action, tools, { abortSignal: signal });
+      toolCalls.push(rec);
+      results.push(rec);
+      opts.callbacks?.onToolResult?.(rec.name, rec.output, rec.ok);
+    }
+    if (round === maxRounds || signal?.aborted) break;
+    messages.push({ role: "assistant", content: result.text });
+    messages.push({ role: "user", content: toolResultsPrompt(results) });
   }
-  return { text: parsed.reply, toolCalls, usage: normalizeUsage(result.usage) };
+  if (text) opts.callbacks?.onTextDelta?.(text);
+  return { text, toolCalls, 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 };
@@ -888,15 +940,35 @@ var executeStep = async (ctx, goal, step, index, total, done) => {
     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
-});
+var shouldReplan = (result) => {
+  if (result.blocked) return true;
+  const { toolCalls } = result;
+  return toolCalls.some(
+    (c, i) => !c.ok && !toolCalls.slice(i + 1).some((later) => later.ok && later.name === c.name)
+  );
+};
+var replanWanted = async (trigger, result, opts = {}) => {
+  if (trigger === "always") return true;
+  if (typeof trigger !== "function") return shouldReplan(result);
+  const fallback = () => shouldReplan(result);
+  const decided = (async () => {
+    try {
+      return Boolean(await trigger(result));
+    } catch (err) {
+      opts.onError?.(err);
+      return fallback();
+    }
+  })();
+  const guard = timeoutSignal(opts.signal, opts.timeoutMs);
+  if (!guard) return decided;
+  return Promise.race([
+    decided,
+    new Promise((resolve) => {
+      if (guard.aborted) resolve(fallback());
+      else guard.addEventListener("abort", () => resolve(fallback()), { once: true });
+    })
+  ]);
+};
 
 // src/agent/schemas.ts
 var import_zod = require("zod");
@@ -1249,7 +1321,12 @@ var createAgent = async (config) => {
         done.push(
           `${step.description} \u2014 ${applied} applied${failed ? `, ${failed} failed` : ""}${stepResult.blocked ? ", blocked" : ""}`
         );
-        if (cfg.replan && iter < cfg.maxIterations && revisions < cfg.maxRevisions && !isAborted() && shouldReplan(stepResult)) {
+        const wantReplan = cfg.replan && iter < cfg.maxIterations && revisions < cfg.maxRevisions && !isAborted() && await replanWanted(cfg.replanAfter, stepResult, {
+          signal: ctx.signal,
+          timeoutMs: cfg.chatTimeoutMs,
+          onError: (err) => log.warn("replanAfter predicate threw \u2014 using the failure rule", err)
+        });
+        if (wantReplan && !isAborted()) {
           const decision = await decideReplan(
             ctx,
             text,
@@ -1578,6 +1655,7 @@ var IndexedDBStore = class {
   preloadWebLLMModel,
   promptHintOf,
   renderCatalog,
+  replanWanted,
   resolveConfig,
   resolveModel,
   resolveStage,