@lazyingart/agintiflow 0.1.0 → 0.2.0

package/src/agent-runner.js

@@ -8,12 +8,103 @@ import { SessionStore } from "./session-store.js";
 import { captureSnapshot } from "./snapshot.js";
 import { checkToolUse } from "./guardrails.js";
 import { ensureDockerSandboxReady, runDockerSandboxCommand } from "./docker-sandbox.js";
-import { runAgentWrapper, wrapperStatusText } from "./tool-wrappers.js";
+import { normalizeWrapperName, runAgentWrapper, wrapperStatusText } from "./tool-wrappers.js";
 import { evaluateCommandPolicy } from "./command-policy.js";
 import { redactSensitiveText, redactValue } from "./redaction.js";
+import { executeWorkspaceTool, summarizeWorkspaceTools, WORKSPACE_TOOL_NAMES } from "./workspace-tools.js";
+import { normalizeCanvasPayload } from "./artifact-tunnel.js";
 
 const exec = promisify(execCallback);
 const BROWSER_TOOLS = new Set(["open_url", "click", "type", "scroll", "press", "back"]);
+const WORKSPACE_TOOLS = new Set(WORKSPACE_TOOL_NAMES);
+
+function preserveAssistantMessage(message) {
+  const preserved = {
+    role: "assistant",
+    content: message.content || "",
+    tool_calls: message.tool_calls,
+  };
+
+  const reasoningContent = message.reasoning_content || message.reasoningContent;
+  if (reasoningContent) {
+    preserved.reasoning_content = reasoningContent;
+  }
+
+  return preserved;
+}
+
+export function repairModelMessageHistory(state, config = {}) {
+  if (config.provider !== "deepseek" || !Array.isArray(state?.messages)) {
+    return { changed: false, droppedAssistantMessages: 0, convertedAssistantMessages: 0, droppedToolMessages: 0 };
+  }
+
+  const repaired = [];
+  const droppedToolCallIds = new Set();
+  let droppedAssistantMessages = 0;
+  let convertedAssistantMessages = 0;
+  let droppedToolMessages = 0;
+
+  for (const message of state.messages) {
+    if (message.role === "assistant") {
+      const hasReasoningContent = Boolean(message.reasoning_content || message.reasoningContent);
+      const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+      const content = String(message.content || "");
+
+      if (!hasReasoningContent) {
+        if (content.startsWith("Execution plan:")) {
+          droppedAssistantMessages += 1;
+          continue;
+        }
+
+        if (toolCalls.length > 0) {
+          for (const call of toolCalls) {
+            if (call?.id) droppedToolCallIds.add(call.id);
+          }
+          droppedAssistantMessages += 1;
+          continue;
+        }
+
+        if (content.trim()) {
+          repaired.push({
+            role: "user",
+            content: `Previous assistant response retained as compacted history for DeepSeek thinking mode:\n${content}`,
+          });
+          convertedAssistantMessages += 1;
+        } else {
+          droppedAssistantMessages += 1;
+        }
+        continue;
+      }
+
+      repaired.push(preserveAssistantMessage(message));
+      continue;
+    }
+
+    if (message.role === "tool" && droppedToolCallIds.has(message.tool_call_id)) {
+      droppedToolMessages += 1;
+      continue;
+    }
+
+    repaired.push(message);
+  }
+
+  const changed =
+    droppedAssistantMessages > 0 ||
+    convertedAssistantMessages > 0 ||
+    droppedToolMessages > 0 ||
+    repaired.length !== state.messages.length;
+
+  if (changed) {
+    state.messages = repaired;
+  }
+
+  return {
+    changed,
+    droppedAssistantMessages,
+    convertedAssistantMessages,
+    droppedToolMessages,
+  };
+}
 
 function createInitialState(config, sessionId) {
   const now = new Date().toISOString();
@@ -54,9 +145,15 @@ function createInitialState(config, sessionId) {
               ? `A shell command tool is available inside Docker sandbox mode ${config.sandboxMode}. Read-only commands have no network. Package installs or environment setup require approved package policy and Docker workspace-write mode.`
               : "A read-only host shell command tool is available for short local inspection tasks."
             : "No shell command tool is available.",
+          config.allowFileTools
+            ? `Workspace file tools are available in ${config.commandCwd}: list_files, read_file, search_files, write_file, and apply_patch. Always use workspace-relative paths such as plot_fx.svg or docs/report.tex, never absolute host paths. Secret paths, .git internals, node_modules writes, and huge files are blocked.`
+            : "No workspace file tools are available.",
           config.allowWrapperTools
-            ? `External coding-agent wrappers are available as advisory tools only. Wrapper status: ${wrapperStatusText()}.`
+            ? `External coding-agent wrappers are available as advisory tools only. Use the selected wrapper only: ${normalizeWrapperName(config.preferredWrapper)}. Wrapper status: ${wrapperStatusText()}.`
             : "External coding-agent wrappers are disabled.",
+          "A frontend canvas/artifacts tunnel exists. Use send_to_canvas when important markdown, diffs, screenshots, images, or workspace files should be highlighted in the UI. It is optional and ordinary final text can still go directly to finish.",
+          "For visual-output requests such as draw, plot, graph, chart, diagram, figure, image, or visualization, proactively publish a canvas artifact even when the user does not mention canvas. If workspace file tools are enabled, prefer creating a small SVG or markdown artifact and call send_to_canvas with selected=true.",
+          "For LaTeX/PDF requests, create the needed source/assets, compile with the available allowlisted TeX toolchain, and publish the resulting PDF through send_to_canvas. For subfolder documents, keep outputs beside the source. Use pdflatex-compatible figure formats such as PDF or PNG.",
           "When done, call finish with a concise result.",
         ].join(" "),
       },
@@ -68,10 +165,16 @@ function createInitialState(config, sessionId) {
           config.allowedDomains.length > 0 ? `Allowed domains: ${config.allowedDomains.join(", ")}` : "",
           config.allowShellTool
             ? config.useDockerSandbox
-              ? `Shell working directory mounted into Docker: ${config.commandCwd}. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
+              ? `Shell working directory mounted into Docker as /workspace from ${config.commandCwd}. Use relative paths or /workspace paths, not absolute host temp paths. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
               : `Shell working directory: ${config.commandCwd}`
             : "",
-          config.allowWrapperTools ? `Agent wrappers: ${wrapperStatusText()}` : "",
+          config.allowFileTools ? `Workspace file tools enabled in: ${config.commandCwd}. Use workspace-relative paths.` : "",
+          config.allowWrapperTools
+            ? `Agent wrappers: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
+            : "",
+          "Canvas/artifacts tunnel: available through send_to_canvas for optional frontend rendering.",
+          "Visual-output requests should produce a canvas artifact without requiring the user to ask for canvas explicitly.",
+          "LaTeX/PDF requests should produce source artifacts and, when possible, a compiled PDF artifact. For subfolder documents, keep outputs beside the source. For figure-in-document tasks, create PDF/PNG figures that pdflatex can include.",
         ]
           .filter(Boolean)
           .join("\n"),
@@ -161,10 +264,13 @@ function applyContinuationPrompt(state, config, observers) {
       config.allowedDomains.length > 0 ? `Allowed domains: ${config.allowedDomains.join(", ")}` : "",
       config.allowShellTool
         ? config.useDockerSandbox
-          ? `Shell working directory mounted into Docker: ${config.commandCwd}. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
+          ? `Shell working directory mounted into Docker as /workspace from ${config.commandCwd}. Use relative paths or /workspace paths. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
           : `Shell working directory: ${config.commandCwd}`
         : "",
-      config.allowWrapperTools ? `Agent wrappers: ${wrapperStatusText()}` : "",
+      config.allowFileTools ? `Workspace file tools enabled in: ${config.commandCwd}. Use workspace-relative paths.` : "",
+      config.allowWrapperTools
+        ? `Agent wrappers: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
+        : "",
     ]
       .filter(Boolean)
       .join("\n"),
@@ -218,6 +324,44 @@ function safeExecutionEnv() {
   };
 }
 
+function hashForLog(value) {
+  return crypto.createHash("sha256").update(String(value ?? "")).digest("hex");
+}
+
+function sanitizeToolArgs(toolName, args) {
+  const safeArgs = redactValue(args);
+  if (toolName === "write_file" && typeof args.content === "string") {
+    return {
+      ...safeArgs,
+      content: `[${Buffer.byteLength(args.content, "utf8")} bytes sha256=${hashForLog(args.content)}]`,
+    };
+  }
+  if (toolName === "send_to_canvas" && typeof args.content === "string") {
+    return {
+      ...safeArgs,
+      content: `[${Buffer.byteLength(args.content, "utf8")} bytes sha256=${hashForLog(args.content)}]`,
+    };
+  }
+  if (toolName === "apply_patch") {
+    return {
+      ...safeArgs,
+      search: typeof args.search === "string" ? redactSensitiveText(args.search).slice(0, 160) : safeArgs.search,
+      replace: typeof args.replace === "string" ? redactSensitiveText(args.replace).slice(0, 160) : safeArgs.replace,
+    };
+  }
+  return safeArgs;
+}
+
+function sanitizeToolResult(result) {
+  const safeResult = redactValue(result);
+  if (typeof safeResult.content === "string") {
+    safeResult.contentPreview = safeResult.content.slice(0, 600);
+    safeResult.contentBytes = Buffer.byteLength(safeResult.content, "utf8");
+    delete safeResult.content;
+  }
+  return safeResult;
+}
+
 async function runShellCommand(command, config, policy = evaluateCommandPolicy(command, config)) {
   if (config.useDockerSandbox) {
     return runDockerSandboxCommand(command, config, policy);
@@ -246,10 +390,18 @@ async function captureSyntheticSnapshot(store, step, config) {
       config.startUrl ? `Suggested start URL: ${config.startUrl}` : "",
       config.allowShellTool
         ? config.useDockerSandbox
-          ? `Shell tool available in Docker with mounted workspace: ${config.commandCwd}. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
+          ? `Shell tool available in Docker with mounted workspace /workspace from ${config.commandCwd}. Use relative paths or /workspace paths. Sandbox mode: ${config.sandboxMode}. Package install policy: ${config.packageInstallPolicy}.`
           : `Shell tool available in: ${config.commandCwd}`
         : "Shell tool disabled.",
-      config.allowWrapperTools ? `Agent wrappers available: ${wrapperStatusText()}` : "Agent wrappers disabled.",
+      config.allowFileTools
+        ? `Workspace file tools available in: ${config.commandCwd}. Use workspace-relative paths.`
+        : "Workspace file tools disabled.",
+      config.allowWrapperTools
+        ? `Agent wrappers available: selected=${normalizeWrapperName(config.preferredWrapper)}; ${wrapperStatusText()}`
+        : "Agent wrappers disabled.",
+      "Canvas/artifacts tunnel available through send_to_canvas.",
+      "For draw/plot/graph/chart/diagram/figure requests, publish a canvas artifact proactively.",
+      "For LaTeX/PDF requests, publish the source and compiled PDF artifacts when available. Keep subfolder outputs beside their source and use pdflatex-compatible figure formats.",
       "Use open_url only if the task actually needs the web.",
     ]
       .filter(Boolean)
@@ -274,7 +426,7 @@ async function buildSnapshot(browserState, store, step, config) {
 
 async function executeTool(browserState, toolCall, snapshot, config, store, observers, state) {
   const args = JSON.parse(toolCall.function.arguments || "{}");
-  const safeArgs = redactValue(args);
+  const safeArgs = sanitizeToolArgs(toolCall.function.name, args);
   const guard = checkToolUse({
     toolName: toolCall.function.name,
     args,
@@ -301,7 +453,10 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
       ok: false,
       blocked: true,
       reason: guard.reason,
+      category: guard.category,
+      needsApproval: guard.needsApproval,
       toolName: toolCall.function.name,
+      args: safeArgs,
     };
   }
 
@@ -361,6 +516,42 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
           await new Promise((resolve) => setTimeout(resolve, Number.isFinite(args.ms) ? Number(args.ms) : 1000));
         }
         break;
+      case "list_files":
+      case "read_file":
+      case "search_files":
+      case "write_file":
+      case "apply_patch": {
+        const result = await executeWorkspaceTool(toolCall.function.name, args, config);
+        const eventResult = sanitizeToolResult(result);
+        if (result.blocked) {
+          await store.appendEvent("tool.blocked", {
+            toolName: toolCall.function.name,
+            args: safeArgs,
+            reason: result.reason,
+            category: result.category,
+          });
+          observers.event("tool.blocked", {
+            toolName: toolCall.function.name,
+            args: safeArgs,
+            reason: result.reason,
+            category: result.category,
+          });
+          return result;
+        }
+
+        await store.appendEvent("tool.completed", eventResult);
+        observers.event("tool.completed", eventResult);
+        if (result.change) {
+          const change = {
+            ...result.change,
+            toolName: toolCall.function.name,
+            commandCwd: config.commandCwd,
+          };
+          await store.appendEvent("file.changed", change);
+          observers.event("file.changed", change);
+        }
+        return result;
+      }
       case "run_command": {
         const policy = evaluateCommandPolicy(String(args.command), config);
         if (config.useDockerSandbox) {
@@ -403,6 +594,63 @@ async function executeTool(browserState, toolCall, snapshot, config, store, obse
         observers.event("tool.completed", result);
         return result;
       }
+      case "send_to_canvas": {
+        const normalized = normalizeCanvasPayload(args, config);
+        if (!normalized.ok) {
+          await store.appendEvent("tool.blocked", {
+            toolName: "send_to_canvas",
+            args: safeArgs,
+            reason: normalized.reason,
+            category: "canvas",
+          });
+          observers.event("tool.blocked", {
+            toolName: "send_to_canvas",
+            args: safeArgs,
+            reason: normalized.reason,
+            category: "canvas",
+          });
+          return {
+            ok: false,
+            blocked: true,
+            reason: normalized.reason,
+            toolName: "send_to_canvas",
+          };
+        }
+
+        const canvasItem = {
+          ...normalized.payload,
+          toolName: "send_to_canvas",
+          commandCwd: config.commandCwd,
+        };
+        await store.appendEvent("canvas.item", canvasItem);
+        observers.event("canvas.item", canvasItem);
+        if (canvasItem.selected) {
+          await store.appendEvent("canvas.selected", {
+            artifactId: canvasItem.artifactId,
+            title: canvasItem.title,
+            source: "agent",
+          });
+          observers.event("canvas.selected", {
+            artifactId: canvasItem.artifactId,
+            title: canvasItem.title,
+            source: "agent",
+          });
+        }
+
+        const result = {
+          ok: true,
+          toolName: "send_to_canvas",
+          args: safeArgs,
+          artifactId: canvasItem.artifactId,
+          title: canvasItem.title,
+          kind: canvasItem.kind,
+          path: canvasItem.path,
+          selected: canvasItem.selected,
+        };
+        await store.appendEvent("tool.completed", result);
+        observers.event("tool.completed", result);
+        return result;
+      }
       case "finish":
         return { ok: true, done: true, result: String(args.result || ""), toolName: "finish" };
       default:
@@ -445,6 +693,9 @@ export async function runAgent(config) {
   const observers = createObservers(config);
   const browserState = createBrowserState();
 
+  if (config.allowFileTools || config.allowShellTool) {
+    await fs.mkdir(config.commandCwd, { recursive: true });
+  }
   await store.ensure();
 
   let state = await store.loadState();
@@ -484,16 +735,19 @@ export async function runAgent(config) {
     if (!state.plan) {
       const plan = await createPlan(client, config, state);
       state.plan = plan;
-      state.messages.push({
-        role: "assistant",
-        content: `Execution plan:\n${plan}`,
-      });
       await store.savePlan(plan);
       await store.appendEvent("plan.created", { plan });
       await store.saveState(state);
       observers.event("plan.created", { plan });
     }
 
+    const repair = repairModelMessageHistory(state, config);
+    if (repair.changed) {
+      await store.appendEvent("history.repaired", repair);
+      observers.event("history.repaired", repair);
+      await store.saveState(state);
+    }
+
     observers.log("session.context", {
       sessionId,
       provider: config.provider,
@@ -503,7 +757,9 @@ export async function runAgent(config) {
       commandCwd: config.commandCwd,
       allowShellTool: config.allowShellTool,
       allowWrapperTools: config.allowWrapperTools,
+      preferredWrapper: normalizeWrapperName(config.preferredWrapper),
       wrappers: config.allowWrapperTools ? wrapperStatusText() : "",
+      workspaceFileTools: summarizeWorkspaceTools(config),
       shellSandbox: config.useDockerSandbox ? "docker" : "host",
       sandboxMode: config.sandboxMode,
       packageInstallPolicy: config.packageInstallPolicy,
@@ -549,13 +805,18 @@ export async function runAgent(config) {
           elements: snapshot.elements,
           browserOpen: Boolean(browserState.page),
           shellToolAvailable: config.allowShellTool,
+          fileToolsAvailable: config.allowFileTools,
+          workspaceFileTools: summarizeWorkspaceTools(config),
           agentWrappersAvailable: config.allowWrapperTools,
+          preferredWrapper: normalizeWrapperName(config.preferredWrapper),
           agentWrappers: config.allowWrapperTools ? wrapperStatusText() : "",
           shellSandbox: config.useDockerSandbox ? "docker" : "host",
           sandboxMode: config.sandboxMode,
           packageInstallPolicy: config.packageInstallPolicy,
           commandCwd: config.commandCwd,
+          plan: state.plan || "",
           suggestedStartUrl: config.startUrl || "",
+          canvasArtifactsAvailable: true,
         })}`,
       });
 
@@ -565,11 +826,7 @@ export async function runAgent(config) {
         throw new Error("Model returned no assistant message.");
       }
 
-      state.messages.push({
-        role: "assistant",
-        content: assistantMessage.content || "",
-        tool_calls: assistantMessage.tool_calls,
-      });
+      state.messages.push(preserveAssistantMessage(assistantMessage));
 
       await store.appendEvent("model.responded", {
         step,
@@ -618,13 +875,19 @@ export async function runAgent(config) {
 
         if (toolResult.toolName === "run_command") {
           observers.log("command.output", {
-            command: redactSensitiveText(toolResult.args.command),
-            stdout: toolResult.stdout,
-            stderr: toolResult.stderr,
+            command: redactSensitiveText(toolResult.args?.command || ""),
+            stdout: toolResult.stdout || "",
+            stderr: toolResult.stderr || "",
             commandPolicy: toolResult.commandPolicy,
+            blocked: Boolean(toolResult.blocked),
+            error: toolResult.error || toolResult.reason || "",
           });
         }
 
+        if (WORKSPACE_TOOLS.has(toolResult.toolName)) {
+          observers.log("workspace.output", sanitizeToolResult(toolResult));
+        }
+
         if (toolResult.toolName === "delegate_agent") {
           observers.log("wrapper.output", {
             wrapper: toolResult.wrapper,
@@ -679,6 +942,8 @@ export async function runAgent(config) {
     return {
       sessionId,
       result: "",
+      stopped: true,
+      reason: "max_steps_reached",
     };
   } finally {
     await closeBrowser(browserState, store);