@botbotgo/agent-harness 0.0.316 → 0.0.318

package/dist/cli/workspace.d.ts

@@ -3,4 +3,5 @@ export declare function getWorkspaceConfigPath(workspaceRoot: string): string;
 export declare function hasCliConfigYaml(configRoot: string): boolean;
 export declare function validateCliWorkspaceRoot(workspaceRoot: string, inputPath?: string): string | undefined;
 export declare function resolveCliConfigRoot(workspaceRoot: string): string;
+export declare function resolveFrameworkCliWorkspaceRoot(resolved: string): string;
 export declare function frameworkCliWorkspaceRoot(): string;

package/dist/cli/workspace.js

@@ -52,20 +52,16 @@ export function resolveCliConfigRoot(workspaceRoot) {
     }
     return path.join(workspaceRoot, "config");
 }
-export function frameworkCliWorkspaceRoot() {
-    const resolved = fileURLToPath(new URL("../..", import.meta.url));
-    const distSegment = `${path.sep}dist`;
-    if (!resolved.endsWith(distSegment)) {
-        return resolved;
-    }
-    const sourceRoot = resolved.slice(0, -distSegment.length);
-    if (!existsSync(sourceRoot)) {
+export function resolveFrameworkCliWorkspaceRoot(resolved) {
+    const baseName = path.basename(resolved);
+    if (baseName === "dist") {
         return resolved;
     }
-    try {
-        return statSync(sourceRoot).mtimeMs >= statSync(resolved).mtimeMs ? sourceRoot : resolved;
-    }
-    catch {
-        return sourceRoot;
+    if (baseName === "src") {
+        return path.dirname(resolved);
     }
+    return resolved;
+}
+export function frameworkCliWorkspaceRoot() {
+    return resolveFrameworkCliWorkspaceRoot(fileURLToPath(new URL("..", import.meta.url)));
 }

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.315";
+export declare const AGENT_HARNESS_VERSION = "0.0.317";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.315";
+export const AGENT_HARNESS_VERSION = "0.0.317";

package/dist/resources/tools/_runtime_tool_helpers.mjs

@@ -54,6 +54,13 @@ export function getRuntimeApi(context) {
   return asRecord(context?.runtime);
 }
 
+function truncatePreview(text, maxChars = 2000) {
+  if (typeof text !== "string" || text.length <= maxChars) {
+    return text;
+  }
+  return `${text.slice(0, Math.max(0, maxChars - 15))}\n...[truncated]`;
+}
+
 export function getCurrentRequestIdentity(context, toolName) {
   const runtime = getRuntimeApi(context);
   const current = asRecord(runtime.current);
@@ -96,6 +103,54 @@ export function truncateText(text, maxChars = 12000) {
   return `${text.slice(0, maxChars - 18)}\n...[truncated]`;
 }
 
+export async function maybePersistLargeToolOutput(toolName, output, context = {}, maxInlineChars = 12000) {
+  const serialized = typeof output === "string" ? output : (() => {
+    try {
+      return JSON.stringify(output, null, 2);
+    } catch {
+      return String(output);
+    }
+  })();
+  if (serialized.length <= maxInlineChars) {
+    return output;
+  }
+
+  const runtime = getRuntimeApi(context);
+  const current = asRecord(runtime.current);
+  const artifacts = asRecord(runtime.artifacts);
+  const sessionId = optionalString(current.sessionId);
+  const requestId = optionalString(current.requestId);
+  const createArtifact = typeof artifacts.create === "function" ? artifacts.create : undefined;
+  const createdAt = new Date().toISOString();
+  let artifact;
+
+  if (createArtifact && sessionId && requestId) {
+    artifact = await createArtifact({
+      sessionId,
+      requestId,
+      kind: "tool-output",
+      path: `artifacts/tool-output-${String(toolName).toLowerCase().replace(/[^a-z0-9]+/g, "-")}-${Date.now()}.json`,
+      createdAt,
+      content: {
+        toolName,
+        createdAt,
+        output,
+      },
+    });
+  }
+
+  return {
+    truncated: true,
+    toolName,
+    message: artifact
+      ? "Full tool output was stored as a request artifact because it exceeded the inline size limit."
+      : "Tool output exceeded the inline size limit and was truncated for runtime stability.",
+    originalSizeChars: serialized.length,
+    preview: truncatePreview(serialized, 2000),
+    ...(artifact ? { artifact } : {}),
+  };
+}
+
 export function truncateLines(lines, maxChars = 12000) {
   return truncateText(lines.join("\n"), maxChars);
 }

package/dist/resources/tools/fetch_url.mjs

@@ -1,5 +1,5 @@
 import { tool } from "@botbotgo/agent-harness/tools";
-import { defineSchema, formatHttpResponse, getBackend, optionalString } from "./_runtime_tool_helpers.mjs";
+import { defineSchema, formatHttpResponse, getBackend, maybePersistLargeToolOutput, optionalString } from "./_runtime_tool_helpers.mjs";
 
 export const fetch_url = tool({
   description: "Fetch a URL and return the response body.",
@@ -10,14 +10,14 @@ export const fetch_url = tool({
     const backend = getBackend(context);
     if (typeof backend.fetchUrl === "function") {
       const result = await backend.fetchUrl(input.url);
-      return typeof result === "string" ? result : formatHttpResponse(result);
+      return maybePersistLargeToolOutput("fetch_url", typeof result === "string" ? result : formatHttpResponse(result), context);
     }
     const response = await fetch(input.url);
-    return formatHttpResponse({
+    return maybePersistLargeToolOutput("fetch_url", formatHttpResponse({
       status: response.status,
       statusText: response.statusText,
       headers: Object.fromEntries(response.headers.entries()),
       body: await response.text(),
-    });
+    }), context);
   },
 });

package/dist/resources/tools/http_request.mjs

@@ -1,5 +1,5 @@
 import { tool } from "@botbotgo/agent-harness/tools";
-import { defineSchema, formatHttpResponse, getBackend, optionalString, optionalStringRecord } from "./_runtime_tool_helpers.mjs";
+import { defineSchema, formatHttpResponse, getBackend, maybePersistLargeToolOutput, optionalString, optionalStringRecord } from "./_runtime_tool_helpers.mjs";
 
 export const http_request = tool({
   description: "Send a structured HTTP request.",
@@ -13,18 +13,18 @@ export const http_request = tool({
     const backend = getBackend(context);
     if (typeof backend.httpRequest === "function") {
       const result = await backend.httpRequest(input);
-      return typeof result === "string" ? result : formatHttpResponse(result);
+      return maybePersistLargeToolOutput("http_request", typeof result === "string" ? result : formatHttpResponse(result), context);
     }
     const response = await fetch(input.url, {
       method: input.method,
       headers: input.headers,
       body: input.body,
     });
-    return formatHttpResponse({
+    return maybePersistLargeToolOutput("http_request", formatHttpResponse({
       status: response.status,
       statusText: response.statusText,
       headers: Object.fromEntries(response.headers.entries()),
       body: await response.text(),
-    });
+    }), context);
   },
 });

package/dist/runtime/adapter/direct-builtin-utility.d.ts

@@ -3,3 +3,4 @@ export declare function shouldDirectlyListWorkspaceFiles(input: string | Array<{
     type?: unknown;
     text?: unknown;
 }>): boolean;
+export declare function renderDirectWorkspaceListing(workspaceRoot: string, targetPath?: string): string;

package/dist/runtime/adapter/direct-builtin-utility.js

@@ -1,3 +1,5 @@
+import { readdirSync } from "node:fs";
+import path from "node:path";
 const DIRECT_LISTING_PATTERNS = [
     /^ls$/iu,
     /^list files$/iu,
@@ -12,6 +14,7 @@ const DIRECT_LISTING_PATTERNS = [
 ];
 const GENERIC_ASSISTANT_SUMMARY_MAX_CHARS = 180;
 const GENERIC_ASSISTANT_SUMMARY_MAX_LINES = 6;
+const DIRECT_LISTING_MAX_ENTRIES = 400;
 function parseListingEntry(line) {
     const trimmed = line.trim();
     if (!trimmed || trimmed === "...[truncated]" || trimmed === "... [truncated]") {
@@ -123,3 +126,17 @@ export function shouldDirectlyListWorkspaceFiles(input) {
     }
     return DIRECT_LISTING_PATTERNS.some((pattern) => pattern.test(normalized));
 }
+export function renderDirectWorkspaceListing(workspaceRoot, targetPath = ".") {
+    const resolvedTarget = path.resolve(workspaceRoot, targetPath);
+    const entries = readdirSync(resolvedTarget, { withFileTypes: true })
+        .sort((left, right) => left.name.localeCompare(right.name))
+        .slice(0, DIRECT_LISTING_MAX_ENTRIES + 1);
+    const lines = entries.slice(0, DIRECT_LISTING_MAX_ENTRIES).map((entry) => {
+        const renderedPath = path.join(targetPath, entry.name).replace(/\\/g, "/");
+        return entry.isDirectory() ? `${renderedPath} (directory)` : renderedPath;
+    });
+    if (entries.length > DIRECT_LISTING_MAX_ENTRIES) {
+        lines.push("...[truncated]");
+    }
+    return lines.join("\n");
+}

package/dist/runtime/adapter/stream-event-projection.js

@@ -1,5 +1,5 @@
 import { sanitizeVisibleText } from "../parsing/output-parsing.js";
-import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, sanitizeStreamPayload, } from "../parsing/stream-event-parsing.js";
+import { computeIncrementalOutput, extractInterruptPayload, extractReasoningStreamOutput, sanitizeRetainedUpstreamEvent, extractStateStreamOutput, extractTerminalStreamOutput, extractToolResult, extractVisibleStreamOutput, normalizeTerminalOutputKey, } from "../parsing/stream-event-parsing.js";
 import { resolveModelFacingToolName } from "./tool/tool-name-mapping.js";
 export function createStreamEventProjectionState() {
     return {
@@ -13,7 +13,7 @@ export function projectRuntimeStreamEvent(params) {
     const { event, allowVisibleStreamDeltas, includeStateStreamOutput, toolNameMapping, primaryTools, state, } = params;
     const chunks = [{
             kind: "upstream-event",
-            event: sanitizeStreamPayload(event),
+            event: sanitizeRetainedUpstreamEvent(event),
         }];
     const interruptPayload = extractInterruptPayload(event);
     if (interruptPayload) {

package/dist/runtime/agent-runtime-adapter.js

@@ -11,7 +11,7 @@ import { applyToolRecoveryInstruction as applyToolRecoveryInstructionHelper, app
 import { invokeBuiltinTaskTool as invokeBuiltinTaskToolHelper, materializeAutomaticSummarizationMiddleware as materializeAutomaticSummarizationMiddlewareHelper, resolveBuiltinMiddlewareBackend as resolveBuiltinMiddlewareBackendHelper, resolveBuiltinMiddlewareTools as resolveBuiltinMiddlewareToolsHelper, resolveLangChainRuntimeExtensionMiddleware as resolveLangChainRuntimeExtensionMiddlewareHelper, resolveMiddleware as resolveMiddlewareHelper, resolveSubagents as resolveSubagentsHelper, } from "./adapter/middleware-assembly.js";
 import { resolveBindingTimeout, resolveStreamIdleTimeout, } from "./adapter/resilience.js";
 import { createResolvedModel } from "./adapter/model/model-providers.js";
-import { shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
+import { renderDirectWorkspaceListing, shouldDirectlyListWorkspaceFiles } from "./adapter/direct-builtin-utility.js";
 import { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
@@ -178,23 +178,19 @@ export class AgentRuntimeAdapter {
         if (!shouldDirectlyListWorkspaceFiles(input)) {
             return undefined;
         }
-        const builtinTools = await this.resolveBuiltinMiddlewareTools(binding, {
-            context: options.context,
-            state: options.state,
-            files: options.files,
-            sessionId: options.sessionId,
-            requestId: options.requestId,
-        });
-        const listTool = builtinTools.get("list_files") ?? builtinTools.get("ls");
-        if (!listTool) {
+        const workspaceRoot = binding.harnessRuntime.workspaceRoot ?? process.cwd();
+        let output = "";
+        try {
+            output = renderDirectWorkspaceListing(workspaceRoot, ".");
+        }
+        catch {
             return undefined;
         }
-        const output = await listTool.invoke({ path: "." });
-        if (typeof output !== "string" || output.trim().length === 0) {
+        if (output.trim().length === 0) {
             return undefined;
         }
         return {
-            toolName: listTool.name,
+            toolName: "list_files",
             output,
         };
     }

package/dist/runtime/parsing/stream-event-parsing.d.ts

@@ -24,6 +24,7 @@ export type RuntimeStreamChunk = {
     step: RequestExecutionStep;
 };
 export declare function sanitizeStreamPayload(value: unknown): unknown;
+export declare function sanitizeRetainedUpstreamEvent(event: unknown): unknown;
 export declare function extractTerminalStreamOutput(event: unknown): string;
 export declare function extractReasoningStreamOutput(event: unknown): string;
 export declare function extractVisibleStreamOutput(event: unknown): string;

package/dist/runtime/parsing/stream-event-parsing.js

@@ -5,6 +5,17 @@ const STREAM_PREVIEW_TEXT_CHARS = 2_000;
 const MAX_STREAM_OBJECT_KEYS = 64;
 const MAX_STREAM_ARRAY_ITEMS = 64;
 const MAX_STREAM_SANITIZE_DEPTH = 6;
+const LARGE_CONTEXT_KEYS = new Set([
+    "input",
+    "inputs",
+    "messages",
+    "history",
+    "context",
+    "attachments",
+    "files",
+    "conversation",
+    "transcript",
+]);
 function truncatePreview(value, maxChars) {
     if (value.length <= maxChars) {
         return value;
@@ -75,6 +86,65 @@ function sanitizeStreamPayloadValue(value, depth) {
 export function sanitizeStreamPayload(value) {
     return sanitizeStreamPayloadValue(value, 0);
 }
+function summarizeOpaquePayload(value) {
+    if (value === null || value === undefined) {
+        return value;
+    }
+    if (typeof value === "string") {
+        return {
+            truncated: true,
+            reason: "omitted-large-context",
+            originalSizeChars: value.length,
+            preview: truncatePreview(value, STREAM_PREVIEW_TEXT_CHARS),
+        };
+    }
+    let serialized = "";
+    try {
+        serialized = JSON.stringify(value);
+    }
+    catch {
+        serialized = String(value);
+    }
+    return {
+        truncated: true,
+        reason: "omitted-large-context",
+        originalSizeChars: serialized.length,
+        preview: truncatePreview(serialized, STREAM_PREVIEW_TEXT_CHARS),
+    };
+}
+function sanitizeRetainedEventDataField(key, value) {
+    if (LARGE_CONTEXT_KEYS.has(key)) {
+        if (key === "input" && typeof value === "object" && value && !Array.isArray(value)) {
+            const typed = value;
+            const taskSubagentType = typeof typed.subagent_type === "string"
+                ? typed.subagent_type
+                : typeof typed.subagentType === "string"
+                    ? typed.subagentType
+                    : undefined;
+            if (taskSubagentType) {
+                return { subagent_type: taskSubagentType };
+            }
+        }
+        return summarizeOpaquePayload(value);
+    }
+    return sanitizeStreamPayload(value);
+}
+export function sanitizeRetainedUpstreamEvent(event) {
+    if (typeof event !== "object" || !event || Array.isArray(event)) {
+        return sanitizeStreamPayload(event);
+    }
+    const typed = event;
+    const retained = {};
+    for (const [key, value] of Object.entries(typed)) {
+        if (key === "data" && typeof value === "object" && value && !Array.isArray(value)) {
+            const data = value;
+            retained.data = Object.fromEntries(Object.entries(data).map(([dataKey, dataValue]) => [dataKey, sanitizeRetainedEventDataField(dataKey, dataValue)]));
+            continue;
+        }
+        retained[key] = sanitizeStreamPayload(value);
+    }
+    return retained;
+}
 function parseMaybeJson(value) {
     const trimmed = value.trim();
     if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {

package/dist/workspace/object-loader-paths.d.ts

@@ -7,5 +7,6 @@ export declare function moduleRootForSourcePath(sourcePath: string, kind: "agent
 export declare function conventionalConfigRoot(root: string): string | null;
 export declare function conventionalPackageRoots(root: string, relativeDir: "tools" | "skills"): string[];
 export declare function conventionalObjectRoots(root: string): string[];
+export declare function resolveFrameworkWorkspaceRoot(resolved: string): string;
 export declare function frameworkWorkspaceRoot(): string;
 export declare function resolveModuleRelativePath(value: string, moduleRoot: string | undefined): string;

package/dist/workspace/object-loader-paths.js

@@ -47,22 +47,18 @@ export function conventionalPackageRoots(root, relativeDir) {
 export function conventionalObjectRoots(root) {
     return CONVENTIONAL_OBJECT_DIRECTORIES.flatMap((directory) => conventionalDirectoryRoots(root, directory));
 }
-export function frameworkWorkspaceRoot() {
-    const resolved = fileURLToPath(new URL("../..", import.meta.url));
-    const distSegment = `${path.sep}dist`;
-    if (!resolved.endsWith(distSegment)) {
-        return resolved;
-    }
-    const sourceRoot = resolved.slice(0, -distSegment.length);
-    if (!existsSync(sourceRoot)) {
+export function resolveFrameworkWorkspaceRoot(resolved) {
+    const baseName = path.basename(resolved);
+    if (baseName === "dist") {
         return resolved;
     }
-    try {
-        return statSync(sourceRoot).mtimeMs >= statSync(resolved).mtimeMs ? sourceRoot : resolved;
-    }
-    catch {
-        return sourceRoot;
+    if (baseName === "src") {
+        return path.dirname(resolved);
     }
+    return resolved;
+}
+export function frameworkWorkspaceRoot() {
+    return resolveFrameworkWorkspaceRoot(fileURLToPath(new URL("..", import.meta.url)));
 }
 function isModuleRelativePathCandidate(value) {
     return !path.isAbsolute(value) && !isExternalSourceLocator(value) && !value.includes("://");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbotgo/agent-harness",
-  "version": "0.0.316",
+  "version": "0.0.318",
   "description": "Workspace runtime for multi-agent applications",
   "license": "MIT",
   "type": "module",