@dudko.dev/agent-web 0.0.4 → 0.0.5

package/dist/chunk-IT65EW77.js

@@ -0,0 +1,38 @@
+// src/providers/webllm.ts
+import { generateText } from "ai";
+var isWebGPUAvailable = () => typeof navigator !== "undefined" && "gpu" in navigator;
+var preloadWebLLMModel = async (model) => {
+  await generateText({ model, prompt: "ok", maxOutputTokens: 1 });
+};
+var unloadWebLLMModel = async (model) => {
+  const engine = model.engine;
+  try {
+    await engine?.unload?.();
+  } catch {
+  }
+};
+var createWebLLMModel = async (model, options) => {
+  let mod;
+  try {
+    mod = await import("@browser-ai/web-llm");
+  } catch {
+    throw new Error(
+      'Local models require "@browser-ai/web-llm" and its peer "@mlc-ai/web-llm". Install: npm install @browser-ai/web-llm @mlc-ai/web-llm'
+    );
+  }
+  const { preload = true, ...settings } = options ?? {};
+  const languageModel = mod.webLLM(
+    model,
+    settings
+  );
+  if (preload) await preloadWebLLMModel(languageModel);
+  return languageModel;
+};
+
+export {
+  isWebGPUAvailable,
+  preloadWebLLMModel,
+  unloadWebLLMModel,
+  createWebLLMModel
+};
+//# sourceMappingURL=chunk-IT65EW77.js.map

package/dist/chunk-IT65EW77.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/providers/webllm.ts"],"sourcesContent":["import { generateText, type LanguageModel } from 'ai'\n\n/** WebGPU feature-detect — WebLLM requires it. Call before offering local models. */\nexport const isWebGPUAvailable = (): boolean =>\n  typeof navigator !== 'undefined' && 'gpu' in navigator\n\nexport interface WebLLMModelOptions {\n  /**\n   * Progress callback for weight download / engine init. `report.progress` is\n   * 0..1. Forwarded to WebLLM's `initProgressCallback`.\n   */\n  initProgressCallback?: (report: { progress: number; text: string }) => void\n  /**\n   * Download the weights and initialize the engine NOW (default true).\n   *\n   * The underlying provider initializes lazily on the first generation — with\n   * a multi-GB model that means the download would silently happen on the\n   * user's first message, with `initProgressCallback` never firing at a moment\n   * the host can show it. Preloading runs a 1-token warm-up so the returned\n   * model is truly ready and progress is reported during creation. Re-creating\n   * an already-downloaded model is fast (weights live in the browser cache).\n   *\n   * Set to `false` to keep the lazy behavior.\n   */\n  preload?: boolean\n  /** Any other @browser-ai/web-llm setting (temperature, worker handler, …). */\n  [k: string]: unknown\n}\n\n/**\n * Force a model to download its weights and initialize its engine by running\n * a 1-token generation. Exposed for hosts that create models with\n * `preload: false` and want to warm them up later (e.g. behind their own UI).\n */\nexport const preloadWebLLMModel = async (model: LanguageModel): Promise<void> => {\n  await generateText({ model, prompt: 'ok', maxOutputTokens: 1 })\n}\n\n/**\n * Best-effort release of a model's GPU memory (call when switching models —\n * an abandoned engine otherwise holds its buffers until the page reloads).\n *\n * `@browser-ai/web-llm` keeps its MLCEngine private and exposes no public\n * `unload()`, so this reaches into the instance defensively; it is a no-op on\n * an uninitialized model or if the provider's internals change shape.\n */\nexport const unloadWebLLMModel = async (model: LanguageModel): Promise<void> => {\n  const engine = (model as { engine?: { unload?: () => Promise<void> } }).engine\n  try {\n    await engine?.unload?.()\n  } catch {\n    /* best-effort */\n  }\n}\n\n/**\n * Build an AI SDK `LanguageModel` backed by WebLLM (WebGPU) via the community\n * provider `@browser-ai/web-llm` (an optional peer, dynamically imported so it\n * is code-split and never loads until a local model is actually used). Accepts\n * any WebLLM prebuilt model id, e.g. \"Llama-3.2-3B-Instruct-q4f16_1-MLC\".\n *\n * By default the weights are downloaded eagerly with progress (see\n * `WebLLMModelOptions.preload`).\n */\nexport const createWebLLMModel = async (\n  model: string,\n  options?: WebLLMModelOptions,\n): Promise<LanguageModel> => {\n  let mod: typeof import('@browser-ai/web-llm')\n  try {\n    mod = await import('@browser-ai/web-llm')\n  } catch {\n    throw new Error(\n      'Local models require \"@browser-ai/web-llm\" and its peer \"@mlc-ai/web-llm\". Install: npm install @browser-ai/web-llm @mlc-ai/web-llm',\n    )\n  }\n  const { preload = true, ...settings } = options ?? {}\n  // webLLM(modelId, settings) returns a LanguageModel. The model id is a strict\n  // union in the provider's types; we accept any string and cast at the seam.\n  const languageModel = mod.webLLM(\n    model as Parameters<typeof mod.webLLM>[0],\n    settings as Parameters<typeof mod.webLLM>[1],\n  )\n  if (preload) await preloadWebLLMModel(languageModel)\n  return languageModel\n}\n"],"mappings":";AAAA,SAAS,oBAAwC;AAG1C,IAAM,oBAAoB,MAC/B,OAAO,cAAc,eAAe,SAAS;AA8BxC,IAAM,qBAAqB,OAAO,UAAwC;AAC/E,QAAM,aAAa,EAAE,OAAO,QAAQ,MAAM,iBAAiB,EAAE,CAAC;AAChE;AAUO,IAAM,oBAAoB,OAAO,UAAwC;AAC9E,QAAM,SAAU,MAAwD;AACxE,MAAI;AACF,UAAM,QAAQ,SAAS;AAAA,EACzB,QAAQ;AAAA,EAER;AACF;AAWO,IAAM,oBAAoB,OAC/B,OACA,YAC2B;AAC3B,MAAI;AACJ,MAAI;AACF,UAAM,MAAM,OAAO,qBAAqB;AAAA,EAC1C,QAAQ;AACN,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,QAAM,EAAE,UAAU,MAAM,GAAG,SAAS,IAAI,WAAW,CAAC;AAGpD,QAAM,gBAAgB,IAAI;AAAA,IACxB;AAAA,IACA;AAAA,EACF;AACA,MAAI,QAAS,OAAM,mBAAmB,aAAa;AACnD,SAAO;AACT;","names":[]}

package/dist/index.cjs

@@ -34,13 +34,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var webllm_exports = {};
 __export(webllm_exports, {
   createWebLLMModel: () => createWebLLMModel,
-  isWebGPUAvailable: () => isWebGPUAvailable
+  isWebGPUAvailable: () => isWebGPUAvailable,
+  preloadWebLLMModel: () => preloadWebLLMModel,
+  unloadWebLLMModel: () => unloadWebLLMModel
 });
-var isWebGPUAvailable, createWebLLMModel;
+var import_ai2, isWebGPUAvailable, preloadWebLLMModel, unloadWebLLMModel, createWebLLMModel;
 var init_webllm = __esm({
   "src/providers/webllm.ts"() {
     "use strict";
+    import_ai2 = require("ai");
     isWebGPUAvailable = () => typeof navigator !== "undefined" && "gpu" in navigator;
+    preloadWebLLMModel = async (model) => {
+      await (0, import_ai2.generateText)({ model, prompt: "ok", maxOutputTokens: 1 });
+    };
+    unloadWebLLMModel = async (model) => {
+      const engine = model.engine;
+      try {
+        await engine?.unload?.();
+      } catch {
+      }
+    };
     createWebLLMModel = async (model, options) => {
       let mod;
       try {
@@ -50,10 +63,13 @@ var init_webllm = __esm({
           'Local models require "@browser-ai/web-llm" and its peer "@mlc-ai/web-llm". Install: npm install @browser-ai/web-llm @mlc-ai/web-llm'
         );
       }
-      return mod.webLLM(
+      const { preload = true, ...settings } = options ?? {};
+      const languageModel = mod.webLLM(
         model,
-        options
+        settings
       );
+      if (preload) await preloadWebLLMModel(languageModel);
+      return languageModel;
     };
   }
 });
@@ -75,6 +91,7 @@ __export(src_exports, {
   buildModelFromStage: () => buildModelFromStage,
   compressHistory: () => compressHistory,
   createAgent: () => createAgent,
+  createLogger: () => createLogger,
   createPlan: () => createPlan,
   createWebLLMModel: () => createWebLLMModel,
   decideReplan: () => decideReplan,
@@ -99,6 +116,7 @@ __export(src_exports, {
   parsePlainText: () => parsePlainText,
   parsePlannerResponse: () => parsePlannerResponse,
   parseReplannerResponse: () => parseReplannerResponse,
+  preloadWebLLMModel: () => preloadWebLLMModel,
   promptHintOf: () => promptHintOf,
   renderCatalog: () => renderCatalog,
   resolveConfig: () => resolveConfig,
@@ -112,6 +130,7 @@ __export(src_exports, {
   supportsNativeTools: () => supportsNativeTools,
   supportsStructuredOutput: () => supportsStructuredOutput,
   synthesizeAnswer: () => synthesizeAnswer,
+  unloadWebLLMModel: () => unloadWebLLMModel,
   withSystem: () => withSystem
 });
 module.exports = __toCommonJS(src_exports);
@@ -135,7 +154,8 @@ var resolveConfig = (c) => ({
   temperature: c.temperature,
   replan: c.replan ?? true,
   synthesize: c.synthesize ?? true,
-  compressAfterChars: c.compressAfterChars ?? 12e3
+  compressAfterChars: c.compressAfterChars ?? 12e3,
+  logLevel: c.logLevel ?? "warn"
 });
 
 // src/llm/generate.ts
@@ -576,7 +596,7 @@ var dispatch = async (action, tools, ctx = {}) => {
 };
 
 // src/llm/tool-loop.ts
-var import_ai2 = require("ai");
+var import_ai3 = require("ai");
 
 // src/parse.ts
 var stripFences = (text) => (text || "").replace(/```(?:json)?/gi, "").trim();
@@ -725,11 +745,11 @@ var runToolLoop = (model, opts) => opts.mode === "prompted" ? runPrompted(model,
 var runNative = async (model, opts) => {
   const toolCalls = [];
   const pending = /* @__PURE__ */ new Map();
-  const result = (0, import_ai2.streamText)({
+  const result = (0, import_ai3.streamText)({
     model,
     tools: opts.tools,
     ...opts.activeTools ? { activeTools: opts.activeTools } : {},
-    stopWhen: (0, import_ai2.stepCountIs)(opts.maxSteps ?? 4),
+    stopWhen: (0, import_ai3.stepCountIs)(opts.maxSteps ?? 4),
     system: opts.system,
     ...promptOf(opts),
     maxOutputTokens: opts.maxOutputTokens,
@@ -777,7 +797,7 @@ var runNative = async (model, opts) => {
   return { text: text.trim(), toolCalls, usage: normalizeUsage(usage) };
 };
 var runPrompted = async (model, opts) => {
-  const result = await (0, import_ai2.generateText)({
+  const result = await (0, import_ai3.generateText)({
     model,
     system: opts.system,
     ...promptOf(opts),
@@ -846,10 +866,17 @@ var executeStep = async (ctx, goal, step, index, total, done) => {
     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 })
+      onToolCall: (name, input) => {
+        ctx.log.info(`tool call: ${name}`, input);
+        ctx.emit({ type: "step.tool-call", step, name, input });
+      },
+      onToolResult: (name, output, ok) => {
+        ctx.log.debug(`tool result: ${name} ${ok ? "ok" : "FAILED"}`, output);
+        ctx.emit({ type: "step.tool-result", step, name, output, ok });
+      }
     }
   });
+  ctx.log.debug("executor text:", loop.text);
   const { summary, blocked } = splitBlocker(loop.text);
   return {
     result: {
@@ -897,11 +924,14 @@ var toSteps = (raw) => raw.filter((s) => s.description && s.description.trim()).
   expectedOutcome: s.expectedOutcome,
   suggestedTools: s.suggestedTools
 }));
-var createPlan = async (ctx, goal) => {
+var createPlan = async (ctx, goal, nudge) => {
   const state = await ctx.state();
+  const effectiveGoal = nudge ? `${goal}
+
+${nudge}` : goal;
   const commonFor = (mode) => {
     const parts = ctx.prompts.planner({
-      goal,
+      goal: effectiveGoal,
       state,
       toolCatalog: ctx.toolCatalog,
       mode,
@@ -919,16 +949,20 @@ var createPlan = async (ctx, goal) => {
   if (ctx.plannerMode === "native") {
     try {
       const result2 = await generateStructured(ctx.plannerModel, PlanSchema, commonFor("native"));
+      ctx.log.debug("planner (native):", result2.object);
       return {
         plan: { thought: result2.object.thought, steps: toSteps(result2.object.steps) },
         usage: normalizeUsage(result2.usage)
       };
     } catch (err) {
+      ctx.log.warn("planner: native structured output failed, salvaging:", asMessage(err));
       ctx.emit({ type: "retry", phase: "plan", attempt: 1, error: asMessage(err) });
     }
   }
   const result = await generate(ctx.plannerModel, commonFor("prompted"));
   const parsed = parsePlannerResponse(result.text);
+  ctx.log.debug("planner (prompted) raw:", result.text);
+  ctx.log.debug("planner (prompted) parsed:", parsed);
   return {
     plan: {
       thought: parsed.reply,
@@ -1011,6 +1045,27 @@ var synthesizeAnswer = async (ctx, goal, done) => {
   };
 };
 
+// src/logger.ts
+var WEIGHT = {
+  silent: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  debug: 4
+};
+var PREFIX = "[agent-web]";
+var noop = () => void 0;
+var createLogger = (level = "warn", sink = console) => {
+  const at = (min, fn) => WEIGHT[level] >= WEIGHT[min] ? (...args) => fn.call(sink, PREFIX, ...args) : noop;
+  return {
+    level,
+    error: at("error", sink.error),
+    warn: at("warn", sink.warn),
+    info: at("info", sink.info),
+    debug: at("debug", sink.debug)
+  };
+};
+
 // src/agent/runner.ts
 var errMessage = (err) => err instanceof Error ? err.message : String(err);
 var filterTools = (all, available, excluded) => {
@@ -1041,6 +1096,10 @@ var createAgent = async (config) => {
   );
   const toolCatalog = renderCatalog(tools);
   const prompts = { ...defaultPrompts, ...config.prompts };
+  const log = createLogger(cfg.logLevel, config.logger);
+  log.info(
+    `agent ready \u2014 tools: [${Object.keys(tools).join(", ") || "none"}], planner mode: ${plannerMode}, executor mode: ${executorMode}`
+  );
   const run = async (goal, opts = {}) => {
     const emit = (event) => {
       try {
@@ -1096,14 +1155,34 @@ var createAgent = async (config) => {
       toolCatalog,
       prompts,
       emit,
+      log,
       signal: opts.signal,
       state,
       history
     };
     await remember({ role: "user", content: text });
+    log.info("run:", text);
     try {
-      const planned = await createPlan(ctx, text);
+      let planned = await createPlan(ctx, text);
       bumpUsage(planned.usage, "plan");
+      if (isAborted()) {
+        emit({ type: "stopped" });
+        result.stopped = true;
+        return result;
+      }
+      if (planned.plan.steps.length === 0 && text.split(/\s+/).length > 2) {
+        log.warn(
+          "planner returned no steps for a multi-word goal \u2014 retrying with a nudge. thought:",
+          planned.plan.thought
+        );
+        const retried = await createPlan(
+          ctx,
+          text,
+          "NOTE: If the message above asks to build, add, change, clear or delete ANYTHING, you MUST output 1-6 concrete steps. Output an empty plan ONLY for a pure greeting or question."
+        );
+        bumpUsage(retried.usage, "plan");
+        if (retried.plan.steps.length > 0) planned = retried;
+      }
       result.plan = planned.plan;
       if (isAborted()) {
         emit({ type: "stopped" });
@@ -1111,12 +1190,17 @@ var createAgent = async (config) => {
         return result;
       }
       if (planned.plan.steps.length === 0) {
+        log.info("no plan \u2014 answering directly (no tools will run)");
         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;
       }
+      log.info(
+        `plan (${planned.plan.steps.length} steps):`,
+        planned.plan.steps.map((s) => s.description)
+      );
       emit({ type: "plan.created", plan: planned.plan });
       planned.plan.steps.forEach((step, index) => emit({ type: "plan.step-added", step, index }));
       const done = [];
@@ -1153,6 +1237,14 @@ var createAgent = async (config) => {
         const failed = stepResult.toolCalls.length - applied;
         result.applied += applied;
         result.steps = stepNo;
+        log.info(
+          `step ${stepNo}/${total} "${step.description}" \u2014 ${stepResult.toolCalls.length} tool call(s), ${applied} ok${failed ? `, ${failed} FAILED` : ""}${stepResult.blocked ? ", BLOCKED" : ""}`
+        );
+        if (stepResult.toolCalls.length === 0) {
+          log.warn(`step ${stepNo} made no tool calls \u2014 nothing changed in this step`);
+        }
+        stepResult.toolCalls.filter((c) => !c.ok).forEach((c) => log.warn(`tool ${c.name} failed:`, c.output));
+        log.debug(`step ${stepNo} detail:`, stepResult);
         emit({ type: "step.complete", step, result: stepResult });
         done.push(
           `${step.description} \u2014 ${applied} applied${failed ? `, ${failed} failed` : ""}${stepResult.blocked ? ", blocked" : ""}`
@@ -1192,6 +1284,7 @@ var createAgent = async (config) => {
         } catch {
         }
       }
+      log.info(`done \u2014 ${result.applied} tool call(s) applied over ${result.steps} step(s)`);
       emit({ type: "final", text: summary });
       await remember({ role: "assistant", content: summary });
       result.final = summary;
@@ -1384,10 +1477,10 @@ var MemoryCredentialStore = class {
 };
 
 // src/tools/define.ts
-var import_ai3 = require("ai");
+var import_ai4 = require("ai");
 var defineTool = (config) => {
   const { promptHint, ...rest } = config;
-  const t = (0, import_ai3.tool)(rest);
+  const t = (0, import_ai4.tool)(rest);
   if (promptHint) t.promptHint = promptHint;
   return t;
 };
@@ -1457,6 +1550,7 @@ var IndexedDBStore = class {
   buildModelFromStage,
   compressHistory,
   createAgent,
+  createLogger,
   createPlan,
   createWebLLMModel,
   decideReplan,
@@ -1481,6 +1575,7 @@ var IndexedDBStore = class {
   parsePlainText,
   parsePlannerResponse,
   parseReplannerResponse,
+  preloadWebLLMModel,
   promptHintOf,
   renderCatalog,
   resolveConfig,
@@ -1494,6 +1589,7 @@ var IndexedDBStore = class {
   supportsNativeTools,
   supportsStructuredOutput,
   synthesizeAnswer,
+  unloadWebLLMModel,
   withSystem
 });
 //# sourceMappingURL=index.cjs.map