@botbotgo/agent-harness 0.0.313 → 0.0.315

package/dist/package-version.d.ts

@@ -1 +1 @@
-export declare const AGENT_HARNESS_VERSION = "0.0.312";
+export declare const AGENT_HARNESS_VERSION = "0.0.314";

package/dist/package-version.js

@@ -1 +1 @@
-export const AGENT_HARNESS_VERSION = "0.0.312";
+export const AGENT_HARNESS_VERSION = "0.0.314";

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

@@ -1 +1,5 @@
 export declare function summarizeAssistantText(text: string): string;
+export declare function shouldDirectlyListWorkspaceFiles(input: string | Array<{
+    type?: unknown;
+    text?: unknown;
+}>): boolean;

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

@@ -1,3 +1,15 @@
+const DIRECT_LISTING_PATTERNS = [
+    /^ls$/iu,
+    /^list files$/iu,
+    /^list the files$/iu,
+    /^list files in (?:the )?(?:current )?directory$/iu,
+    /^show files$/iu,
+    /^show me the files$/iu,
+    /^show the files$/iu,
+    /^列出文件$/u,
+    /^列出当前目录(?:下)?文件$/u,
+    /^查看文件列表$/u,
+];
 const GENERIC_ASSISTANT_SUMMARY_MAX_CHARS = 180;
 const GENERIC_ASSISTANT_SUMMARY_MAX_LINES = 6;
 function parseListingEntry(line) {
@@ -88,3 +100,26 @@ export function summarizeAssistantText(text) {
     }
     return summarizeGenericAssistantResponse(normalized);
 }
+function extractPlainTextInput(input) {
+    if (typeof input === "string") {
+        const normalized = input.trim();
+        return normalized.length > 0 ? normalized : undefined;
+    }
+    if (!Array.isArray(input)) {
+        return undefined;
+    }
+    const text = input
+        .filter((part) => part?.type === "text" && typeof part.text === "string")
+        .map((part) => part.text.trim())
+        .filter((part) => part.length > 0)
+        .join("\n")
+        .trim();
+    return text.length > 0 ? text : undefined;
+}
+export function shouldDirectlyListWorkspaceFiles(input) {
+    const normalized = extractPlainTextInput(input);
+    if (!normalized) {
+        return false;
+    }
+    return DIRECT_LISTING_PATTERNS.some((pattern) => pattern.test(normalized));
+}

package/dist/runtime/adapter/flow/invocation-flow.d.ts

@@ -22,6 +22,7 @@ export declare function executeRequestInvocation(options: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         memoryContext?: string;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => Promise<Map<string, ExecutableTool>>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
 }): Promise<RequestResult>;

package/dist/runtime/adapter/flow/invocation-flow.js

@@ -34,6 +34,7 @@ export async function executeRequestInvocation(options) {
         executableTools,
         builtinExecutableTools: builtinExecutableTools,
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+        toolRuntimeContext: invokeOptions.toolRuntimeContext,
     });
     const result = localOrUpstreamInvocation.result;
     const executedToolResults = [...localOrUpstreamInvocation.executedToolResults];

package/dist/runtime/adapter/flow/invoke-runtime.d.ts

@@ -16,6 +16,7 @@ export declare function invokeRuntimeWithLocalTools(options: {
     executableTools: Map<string, ExecutableTool>;
     builtinExecutableTools: Map<string, ExecutableTool>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+    toolRuntimeContext?: Record<string, unknown>;
 }): Promise<{
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];

package/dist/runtime/adapter/flow/invoke-runtime.js

@@ -14,5 +14,6 @@ export async function invokeRuntimeWithLocalTools(options) {
         executableTools: options.executableTools,
         builtinExecutableTools: options.builtinExecutableTools,
         callRuntimeWithToolParseRecovery: options.callRuntimeWithToolParseRecovery,
+        toolRuntimeContext: options.toolRuntimeContext,
     });
 }

package/dist/runtime/adapter/local-tool-invocation.d.ts

@@ -14,10 +14,11 @@ type LocalToolInvocationParams = {
     executableTools: Map<string, ExecutableTool>;
     builtinExecutableTools: Map<string, ExecutableTool>;
     callRuntimeWithToolParseRecovery: (request: unknown) => Promise<Record<string, unknown>>;
+    toolRuntimeContext?: Record<string, unknown>;
 };
 type LocalToolInvocationResult = {
     result: Record<string, unknown>;
     executedToolResults: ExecutedToolResult[];
 };
-export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
+export declare function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, }: LocalToolInvocationParams): Promise<LocalToolInvocationResult>;
 export {};

package/dist/runtime/adapter/local-tool-invocation.js

@@ -3,6 +3,7 @@ import { createModelFacingToolNameLookupCandidates, resolveModelFacingToolName }
 import { canReplayToolCallsLocally } from "./tool/tool-replay.js";
 import { extractToolCallsFromResult, normalizeToolArgsForSchema, stringifyToolOutput } from "./tool/tool-arguments.js";
 import { extractMemoryCandidatesFromToolOutput } from "../harness/system/runtime-memory-candidates.js";
+import { maybePersistLargeToolOutput } from "./tool/tool-output-artifacts.js";
 const TOOL_FOLLOW_UP_INSTRUCTION = "One or more tool results are already available in this conversation. Answer the user's current request directly from the existing context and tool results. Do not ask the user to repeat inputs that are already present above.";
 function extractLatestUserInput(request) {
     const typedRequest = request;
@@ -19,7 +20,7 @@ function extractLatestUserInput(request) {
     }
     return undefined;
 }
-export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, }) {
+export async function runLocalToolInvocationLoop({ binding, request, primaryTools, toolNameMapping, executableTools, builtinExecutableTools, callRuntimeWithToolParseRecovery, toolRuntimeContext, }) {
     const executedToolResults = [];
     let activeRequest = request;
     let currentMessages = Array.isArray(activeRequest.messages) ? [...activeRequest.messages] : [];
@@ -74,17 +75,24 @@ export async function runLocalToolInvocationLoop({ binding, request, primaryTool
             const normalizedArgs = normalizeToolArgsForSchema(toolCall.args, activeExecutable.schema, toolCall.rawArgsInput, {
                 latestUserInput,
             });
-            const toolResult = await activeExecutable.invoke(normalizedArgs);
+            const toolResult = toolRuntimeContext
+                ? await activeExecutable.invoke(normalizedArgs, { toolRuntimeContext })
+                : await activeExecutable.invoke(normalizedArgs);
             const memoryCandidates = compiledTool ? extractMemoryCandidatesFromToolOutput(compiledTool, toolResult) : [];
-            executedToolResults.push({
+            const safeToolResult = await maybePersistLargeToolOutput({
                 toolName: activeExecutable.name,
                 output: toolResult,
+                toolRuntimeContext: toolRuntimeContext,
+            });
+            executedToolResults.push({
+                toolName: activeExecutable.name,
+                output: safeToolResult,
                 ...(memoryCandidates.length > 0 ? { memoryCandidates } : {}),
             });
             nextMessages.push(new ToolMessage({
                 name: activeExecutable.name,
                 tool_call_id: toolCall.id ?? `tool-${iteration + 1}-${toolIndex + 1}`,
-                content: stringifyToolOutput(toolResult),
+                content: stringifyToolOutput(safeToolResult),
             }));
         }
         currentMessages = nextMessages;

package/dist/runtime/adapter/middleware-assembly.d.ts

@@ -73,16 +73,19 @@ export declare function resolveBuiltinMiddlewareTools(input: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
     };
     resolveBuiltinMiddlewareBackend: (binding: CompiledAgentBinding, options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => unknown;
     invokeBuiltinTaskTool: (binding: CompiledAgentBinding, toolInput: unknown, options?: {
         context?: Record<string, unknown>;
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => Promise<unknown>;
 }): Promise<Map<string, ExecutableTool>>;
 export declare function materializeAutomaticSummarizationMiddleware(input: {

package/dist/runtime/adapter/middleware-assembly.js

@@ -182,6 +182,7 @@ export async function resolveBuiltinMiddlewareTools(input) {
     return createBuiltinMiddlewareTools(backend, {
         includeTaskTool: isDeepAgentBinding(input.binding),
         workspaceRoot: input.binding.harnessRuntime.workspaceRoot,
+        toolRuntimeContext: input.options?.toolRuntimeContext,
         invokeTaskTool: isDeepAgentBinding(input.binding)
             ? async (toolInput) => input.invokeBuiltinTaskTool(input.binding, toolInput, input.options)
             : undefined,

package/dist/runtime/adapter/tool/builtin-middleware-tools.d.ts

@@ -250,4 +250,5 @@ export declare function createBuiltinMiddlewareTools(backend: BuiltinMiddlewareB
     includeTaskTool: boolean;
     invokeTaskTool?: (input: unknown) => Promise<unknown>;
     workspaceRoot?: string;
+    toolRuntimeContext?: Record<string, unknown>;
 }): Promise<Map<string, BuiltinExecutableTool>>;

package/dist/runtime/adapter/tool/builtin-middleware-tools.js

@@ -3,6 +3,7 @@ import { z } from "zod";
 import { isSandboxBackend } from "deepagents";
 import { isRecord } from "../../../utils/object.js";
 import { formatBuiltinTodoSnapshot, isLowSignalTodoContent, summarizeBuiltinWriteTodosArgs, truncateLines } from "../runtime-adapter-support.js";
+import { maybePersistLargeToolOutput, resolveToolRuntimeContext } from "./tool-output-artifacts.js";
 export const BUILTIN_MIDDLEWARE_TOOL_DESCRIPTORS = [
     { name: "write_todos", description: "Create and update the runtime todo board for multi-step work." },
     { name: "read_todos", description: "Read the current runtime todo board." },
@@ -159,6 +160,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             blocked: 0,
         },
     };
+    const finalizeOutput = async (toolName, output, toolConfig) => maybePersistLargeToolOutput({
+        toolName,
+        output,
+        toolRuntimeContext: resolveToolRuntimeContext(toolConfig, options.toolRuntimeContext),
+    });
     tools.set("write_todos", {
         name: "write_todos",
         description: "Create and update the runtime todo board for multi-step work.",
@@ -200,11 +206,11 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "ls",
         description: "List files in a directory.",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             const targetPath = normalizeWorkspacePathOrThrow(pathScopedBackend, isRecord(input) && typeof input.path === "string" ? input.path : "/");
             const shallowListing = await tryExecuteShallowDirectoryListing(pathScopedBackend, targetPath);
             if (typeof shallowListing === "string") {
-                return shallowListing.length > 0 ? shallowListing : `No files found in ${targetPath}`;
+                return finalizeOutput("ls", shallowListing.length > 0 ? shallowListing : `No files found in ${targetPath}`, toolConfig);
             }
             const legacyInfos = (await Promise.resolve(backend.lsInfo?.(targetPath))) ?? [];
             const infos = legacyInfos.length > 0
@@ -217,14 +223,14 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             if (infos.length === 0) {
                 return `No files found in ${targetPath}`;
             }
-            return truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`));
+            return finalizeOutput("ls", truncateLines(infos.map((info) => info.is_dir ? `${info.path} (directory)` : `${info.path}${info.size ? ` (${info.size} bytes)` : ""}`)), toolConfig);
         },
     });
     tools.set("list_files", {
         name: "list_files",
         description: "List files in a directory.",
         schema: z.object({ path: z.string().optional().default("/") }).passthrough(),
-        invoke: async (input) => tools.get("ls").invoke(input),
+        invoke: async (input, toolConfig) => tools.get("ls").invoke(input, toolConfig),
     });
     tools.set("read_file", {
         name: "read_file",
@@ -352,7 +358,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
         name: "execute",
         description: "Run a shell command in the workspace sandbox.",
         schema: z.object({ command: z.string() }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             if (!isSandboxBackend(backend) || typeof backend.execute !== "function") {
                 return "Error: Execution not available. This agent's backend does not support command execution (SandboxBackendProtocol).";
             }
@@ -365,29 +371,29 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             if (result.truncated) {
                 parts.push("\n[Output was truncated due to size limits]");
             }
-            return parts.join("");
+            return finalizeOutput("execute", parts.join(""), toolConfig);
         },
     });
     tools.set("run_command", {
         name: "run_command",
         description: "Run a shell command in the workspace sandbox.",
         schema: z.object({ command: z.string() }).passthrough(),
-        invoke: async (input) => tools.get("execute").invoke(input),
+        invoke: async (input, toolConfig) => tools.get("execute").invoke(input, toolConfig),
     });
     tools.set("fetch_url", {
         name: "fetch_url",
         description: "Fetch a URL and return the response body.",
         schema: z.object({ url: z.string() }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             if (typeof backend.fetchUrl !== "function") {
                 return notAvailable("fetch_url", "URL fetching");
             }
             const typed = isRecord(input) ? input : {};
             const result = await Promise.resolve(backend.fetchUrl(typeof typed.url === "string" ? typed.url : ""));
             if (typeof result === "string") {
-                return result;
+                return finalizeOutput("fetch_url", result, toolConfig);
             }
-            return formatHttpResponse(result);
+            return finalizeOutput("fetch_url", formatHttpResponse(result), toolConfig);
         },
     });
     tools.set("http_request", {
@@ -399,7 +405,7 @@ export async function createBuiltinMiddlewareTools(backend, options) {
             headers: z.record(z.string(), z.string()).optional(),
             body: z.string().optional(),
         }).passthrough(),
-        invoke: async (input) => {
+        invoke: async (input, toolConfig) => {
             if (typeof backend.httpRequest !== "function") {
                 return notAvailable("http_request", "structured HTTP requests");
             }
@@ -413,9 +419,9 @@ export async function createBuiltinMiddlewareTools(backend, options) {
                 body: typeof typed.body === "string" ? typed.body : undefined,
             }));
             if (typeof result === "string") {
-                return result;
+                return finalizeOutput("http_request", result, toolConfig);
             }
-            return formatHttpResponse(result);
+            return finalizeOutput("http_request", formatHttpResponse(result), toolConfig);
         },
     });
     tools.set("send_message", {

package/dist/runtime/adapter/tool/tool-output-artifacts.d.ts

@@ -0,0 +1,35 @@
+type ArtifactCreateInput = {
+    sessionId: string;
+    requestId: string;
+    kind: string;
+    path: string;
+    content: unknown;
+    artifactId?: string;
+    createdAt?: string;
+};
+type ArtifactCreateResult = {
+    artifactId: string;
+    kind: string;
+    path: string;
+    createdAt: string;
+};
+type ToolRuntimeContext = {
+    runtime?: {
+        current?: {
+            sessionId?: string;
+            requestId?: string;
+        };
+        artifacts?: {
+            create?: (input: ArtifactCreateInput) => Promise<ArtifactCreateResult> | ArtifactCreateResult;
+        };
+    };
+};
+export declare function resolveToolRuntimeContext(toolConfig?: Record<string, unknown>, fallback?: Record<string, unknown>): ToolRuntimeContext | undefined;
+export declare function maybePersistLargeToolOutput(input: {
+    toolName: string;
+    output: unknown;
+    toolRuntimeContext?: Record<string, unknown>;
+    maxInlineChars?: number;
+    previewChars?: number;
+}): Promise<unknown>;
+export {};

package/dist/runtime/adapter/tool/tool-output-artifacts.js

@@ -0,0 +1,88 @@
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function toSerializedToolOutput(output) {
+    if (typeof output === "string") {
+        return output;
+    }
+    try {
+        return JSON.stringify(output, null, 2);
+    }
+    catch {
+        return String(output);
+    }
+}
+function truncatePreview(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 15))}\n...[truncated]`;
+}
+function sanitizeArtifactToolName(toolName) {
+    return toolName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "tool";
+}
+export function resolveToolRuntimeContext(toolConfig, fallback) {
+    const dynamic = asRecord(toolConfig?.toolRuntimeContext);
+    const configurable = asRecord(toolConfig?.configurable);
+    const fallbackRuntime = asRecord(asRecord(fallback)?.runtime);
+    const fallbackCurrent = asRecord(fallbackRuntime?.current);
+    const resolved = (dynamic ?? fallback);
+    const runtime = asRecord(resolved?.runtime);
+    if (!runtime) {
+        return resolved;
+    }
+    return {
+        ...resolved,
+        runtime: {
+            ...runtime,
+            current: {
+                ...fallbackCurrent,
+                ...asRecord(runtime.current),
+                ...(typeof configurable?.thread_id === "string" ? { sessionId: configurable.thread_id } : {}),
+                ...(typeof configurable?.request_id === "string" ? { requestId: configurable.request_id } : {}),
+            },
+        },
+    };
+}
+export async function maybePersistLargeToolOutput(input) {
+    const maxInlineChars = input.maxInlineChars ?? 12_000;
+    const previewChars = input.previewChars ?? 2_000;
+    const serialized = toSerializedToolOutput(input.output);
+    if (serialized.length <= maxInlineChars) {
+        return input.output;
+    }
+    const runtimeContext = input.toolRuntimeContext;
+    const runtime = runtimeContext?.runtime;
+    const sessionId = runtime?.current?.sessionId;
+    const requestId = runtime?.current?.requestId;
+    const createArtifact = runtime?.artifacts?.create;
+    const createdAt = new Date().toISOString();
+    const safeToolName = sanitizeArtifactToolName(input.toolName);
+    let artifact;
+    if (typeof createArtifact === "function" && typeof sessionId === "string" && typeof requestId === "string") {
+        artifact = await Promise.resolve(createArtifact({
+            sessionId,
+            requestId,
+            kind: "tool-output",
+            path: `artifacts/tool-output-${safeToolName}-${Date.now()}.json`,
+            createdAt,
+            content: {
+                toolName: input.toolName,
+                createdAt,
+                output: input.output,
+            },
+        }));
+    }
+    return {
+        truncated: true,
+        toolName: input.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, previewChars),
+        ...(artifact ? { artifact } : {}),
+    };
+}

package/dist/runtime/agent-runtime-adapter.d.ts

@@ -32,6 +32,7 @@ export declare class AgentRuntimeAdapter {
     private resolveFilesystemRootDir;
     private resolveBuiltinMiddlewareBackend;
     private buildFunctionToolRuntimeContext;
+    private tryHandleDirectWorkspaceListing;
     private createDeclaredMiddlewareResolverOptions;
     private createAssemblyResolvers;
     private invokeBuiltinTaskTool;

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

@@ -11,6 +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 { resolveAdapterTools } from "./adapter/tool-resolution.js";
 import { resolveRuntimeStreamExecutionContext, } from "./adapter/flow/execution-context.js";
 import { isRetryableProviderError } from "./adapter/resilience.js";
@@ -173,6 +174,30 @@ export class AgentRuntimeAdapter {
             },
         };
     }
+    async tryHandleDirectWorkspaceListing(binding, input, options = {}) {
+        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) {
+            return undefined;
+        }
+        const output = await listTool.invoke({ path: "." });
+        if (typeof output !== "string" || output.trim().length === 0) {
+            return undefined;
+        }
+        return {
+            toolName: listTool.name,
+            output,
+        };
+    }
     createDeclaredMiddlewareResolverOptions(binding, options = {}) {
         return {
             resolveModel: (model) => this.resolveModel(model),
@@ -277,7 +302,12 @@ export class AgentRuntimeAdapter {
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
         const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, { sessionId: options.sessionId ?? options.legacySessionId }),
+            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, {
+                sessionId: options.sessionId ?? options.legacySessionId,
+                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                    sessionId: options.sessionId ?? options.legacySessionId,
+                }),
+            }),
             explicitToolNames: primaryTools.map((tool) => tool.name),
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding, interruptOn, { sessionId: options.sessionId ?? options.legacySessionId });
@@ -305,9 +335,9 @@ export class AgentRuntimeAdapter {
         if (isLangChainBinding(binding)) {
             return this.createLangChainRunnable(binding, { sessionId: options.sessionId ?? options.legacySessionId });
         }
-        return this.createDeepAgentRunnable(binding);
+        return this.createDeepAgentRunnable(binding, { sessionId: options.sessionId ?? options.legacySessionId });
     }
-    async createDeepAgentRunnable(binding) {
+    async createDeepAgentRunnable(binding, options = {}) {
         const executionKind = getBindingExecutionKind(binding);
         const primaryModel = getBindingPrimaryModel(binding);
         const primaryTools = getBindingPrimaryTools(binding);
@@ -317,7 +347,12 @@ export class AgentRuntimeAdapter {
         const resolvedModel = await this.resolveModel(primaryModel);
         const resolvedTools = this.resolveTools(primaryTools, binding);
         const builtinMiddlewareTools = materializeModelExposedBuiltinMiddlewareTools({
-            builtinTools: await this.resolveBuiltinMiddlewareTools(binding),
+            builtinTools: await this.resolveBuiltinMiddlewareTools(binding, {
+                sessionId: options.sessionId ?? options.legacySessionId,
+                toolRuntimeContext: this.buildFunctionToolRuntimeContext(binding, {
+                    sessionId: options.sessionId ?? options.legacySessionId,
+                }),
+            }),
             explicitToolNames: primaryTools.map((tool) => tool.name),
         });
         const resolvedMiddleware = await this.resolveMiddleware(binding);
@@ -398,6 +433,30 @@ export class AgentRuntimeAdapter {
         }
     }
     async invoke(binding, input, sessionId, requestId, resumePayload, history = [], options = {}) {
+        const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {
+            ...options,
+            sessionId,
+            requestId,
+        });
+        if (directListing) {
+            return {
+                sessionId,
+                requestId,
+                agentId: binding.agent.id,
+                state: "completed",
+                output: directListing.output,
+                finalMessageText: directListing.output,
+                metadata: {
+                    executedToolResults: [{
+                            toolName: directListing.toolName,
+                            output: directListing.output,
+                        }],
+                    upstreamResult: {
+                        directUtility: directListing.toolName,
+                    },
+                },
+            };
+        }
         const callRuntime = async (activeBinding, activeRequest) => {
             return this.invokeWithProviderRetry(activeBinding, async () => {
                 const runnable = await this.create(activeBinding, { sessionId });
@@ -444,6 +503,23 @@ export class AgentRuntimeAdapter {
         }));
     }
     async *stream(binding, input, sessionId, history = [], options = {}) {
+        const directListing = await this.tryHandleDirectWorkspaceListing(binding, input, {
+            ...options,
+            sessionId,
+            requestId: options.requestId,
+        });
+        if (directListing) {
+            yield {
+                kind: "tool-result",
+                toolName: directListing.toolName,
+                output: directListing.output,
+            };
+            yield {
+                kind: "content",
+                content: directListing.output,
+            };
+            return;
+        }
         const invokeTimeoutMs = resolveBindingTimeout(binding);
         const streamIdleTimeoutMs = resolveStreamIdleTimeout(binding);
         const streamDeadlineAt = invokeTimeoutMs ? Date.now() + invokeTimeoutMs : undefined;

package/dist/runtime/harness.js

@@ -174,6 +174,7 @@ export class AgentHarnessRuntime {
                 artifacts: {
                     list: (sessionId, requestId) => this.listRequestArtifacts(sessionId, requestId),
                     read: (sessionId, requestId, artifactPath) => this.readRequestArtifact(sessionId, requestId, artifactPath),
+                    create: (artifact) => this.recordArtifact(artifact),
                 },
                 schedules: {
                     manage: (options) => this.manageSchedule(options),

package/package.json

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