@botbotgo/agent-harness 0.0.297 → 0.0.299

package/dist/resources/tools/search_files.mjs

@@ -0,0 +1,47 @@
+import { tool } from "@botbotgo/agent-harness/tools";
+import {
+  defineSchema,
+  formatGrepResult,
+  formatListEntries,
+  getBackend,
+  normalizeGrepMatches,
+  normalizeWorkspacePath,
+  optionalString,
+} from "./_runtime_tool_helpers.mjs";
+
+export const search_files = tool({
+  description: "Search workspace files by content or path glob.",
+  schema: defineSchema({
+    query: (value) => optionalString(value, ""),
+    path: (value) => optionalString(value, "."),
+    glob: (value) => optionalString(value, undefined),
+    search_type: (value) => (optionalString(value, "content") === "path" ? "path" : "content"),
+  }),
+  async invoke(input, context = {}) {
+    const backend = getBackend(context);
+    const targetPath = normalizeWorkspacePath(context, input.path, ".");
+    if (input.search_type === "path") {
+      const legacyInfos = typeof backend.globInfo === "function" ? await backend.globInfo(input.query, targetPath) : [];
+      const infos = legacyInfos.length > 0
+        ? legacyInfos
+        : typeof backend.glob === "function"
+          ? ((await backend.glob(input.query, targetPath))?.files ?? [])
+          : [];
+      return formatListEntries(
+        infos.map((item) => item.path),
+        `No files found matching pattern '${input.query}'`,
+      );
+    }
+
+    const rawMatches = typeof backend.grepRaw === "function"
+      ? await backend.grepRaw(input.query, targetPath, input.glob ?? null)
+      : undefined;
+    if (typeof rawMatches === "string") {
+      return rawMatches;
+    }
+    const structuredMatches = typeof backend.grep === "function"
+      ? normalizeGrepMatches((await backend.grep(input.query, targetPath, input.glob ?? null))?.matches ?? [])
+      : [];
+    return formatGrepResult(input.query, rawMatches ?? structuredMatches);
+  },
+});

package/dist/resources/tools/send_message.mjs

@@ -0,0 +1,23 @@
+import { tool } from "@botbotgo/agent-harness/tools";
+import { defineSchema, getBackend, notAvailable, optionalObject, optionalString } from "./_runtime_tool_helpers.mjs";
+
+export const send_message = tool({
+  description: "Send a message through the configured runtime backend.",
+  schema: defineSchema({
+    destination: (value) => optionalString(value, ""),
+    message: (value) => optionalString(value, ""),
+    subject: (value) => optionalString(value, undefined),
+    metadata: (value) => optionalObject(value),
+  }),
+  async invoke(input, context = {}) {
+    const backend = getBackend(context);
+    if (typeof backend.sendMessage !== "function") {
+      return notAvailable("send_message", "message delivery");
+    }
+    const result = await backend.sendMessage(input);
+    if (typeof result === "string") {
+      return result;
+    }
+    return result?.error ?? `Message sent to '${input.destination}'${result?.id ? ` (id: ${result.id})` : ""}.`;
+  },
+});

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

@@ -0,0 +1 @@
+export declare function summarizeAssistantText(text: string): string;

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

@@ -0,0 +1,90 @@
+const GENERIC_ASSISTANT_SUMMARY_MAX_CHARS = 180;
+const GENERIC_ASSISTANT_SUMMARY_MAX_LINES = 6;
+function parseListingEntry(line) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed === "...[truncated]" || trimmed === "... [truncated]") {
+        return null;
+    }
+    const match = trimmed.match(/^(\/.+?)(?:\s+\((\d+)\s+bytes\))?$/);
+    if (!match) {
+        return null;
+    }
+    const path = match[1];
+    return {
+        path,
+        isDirectory: path.endsWith("/"),
+        ...(match[2] ? { sizeBytes: Number(match[2]) } : {}),
+    };
+}
+function parseListingEntries(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return [];
+    }
+    const lines = normalized.split(/\r?\n/);
+    const entries = lines
+        .map((line) => parseListingEntry(line))
+        .filter((entry) => entry !== null);
+    if (entries.length < 4) {
+        return [];
+    }
+    return entries.length >= Math.ceil(lines.length * 0.7) ? entries : [];
+}
+function buildListingSummary(entries) {
+    const directories = entries.filter((entry) => entry.isDirectory);
+    const files = entries.filter((entry) => !entry.isDirectory);
+    return {
+        totalEntries: entries.length,
+        directoryCount: directories.length,
+        fileCount: files.length,
+        sampleDirectories: directories.slice(0, 8).map((entry) => entry.path),
+        sampleFiles: files.slice(0, 8).map((entry) => entry.path),
+    };
+}
+function summarizeGenericAssistantResponse(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return normalized;
+    }
+    const summaryLines = normalized
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => line !== "Prior assistant response summary:")
+        .map((line) => line.replace(/^(?:[#>*-]+|\d+\.)\s*/u, "").trim())
+        .map((line) => line.replace(/^Earlier assistant answer covered:\s*/u, "").trim())
+        .filter((line) => line.length > 0);
+    const selected = summaryLines
+        .filter((line, index, items) => items.indexOf(line) === index)
+        .slice(0, GENERIC_ASSISTANT_SUMMARY_MAX_LINES)
+        .map((line) => line.length > GENERIC_ASSISTANT_SUMMARY_MAX_CHARS ? `${line.slice(0, GENERIC_ASSISTANT_SUMMARY_MAX_CHARS - 1)}…` : line);
+    if (selected.length === 0) {
+        return normalized.length > 240 ? `${normalized.slice(0, 239)}…` : normalized;
+    }
+    return selected.join("; ");
+}
+export function summarizeAssistantText(text) {
+    const normalized = text.trim();
+    if (!normalized) {
+        return normalized;
+    }
+    if (/^(?:Prior assistant response summary:|Earlier assistant answer covered:)/m.test(normalized)) {
+        return summarizeGenericAssistantResponse(normalized);
+    }
+    const entries = parseListingEntries(normalized);
+    if (entries.length > 0) {
+        const summary = buildListingSummary(entries);
+        return [
+            `Prior assistant output listed ${summary.totalEntries} workspace entries.`,
+            `Directories: ${summary.directoryCount}`,
+            `Files: ${summary.fileCount}`,
+            summary.sampleDirectories.length > 0 ? `Sample directories: ${summary.sampleDirectories.join(", ")}` : undefined,
+            summary.sampleFiles.length > 0 ? `Sample files: ${summary.sampleFiles.join(", ")}` : undefined,
+        ].filter((part) => Boolean(part)).join("\n");
+    }
+    const lineCount = normalized.split(/\r?\n/).length;
+    if (normalized.length <= 500 && lineCount <= 8) {
+        return normalized;
+    }
+    return summarizeGenericAssistantResponse(normalized);
+}

package/dist/runtime/adapter/flow/execution-context.d.ts

@@ -12,7 +12,7 @@ export declare function buildBindingToolExecutionContext(input: {
     binding: CompiledAgentBinding;
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
     getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;
-    context?: Record<string, unknown>;
+    toolConfig?: Record<string, unknown>;
 }): {
     primaryTools: CompiledTool[];
     resolvedTools: unknown[];

package/dist/runtime/adapter/flow/execution-context.js

@@ -15,7 +15,7 @@ export function buildBindingToolExecutionContext(input) {
         primaryTools,
         resolvedTools,
         toolNameMapping,
-        context: input.context,
+        toolConfig: input.toolConfig,
     });
     return {
         primaryTools,

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

@@ -13,6 +13,7 @@ export declare function executeRequestInvocation(options: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         memoryContext?: string;
+        toolRuntimeContext?: Record<string, unknown>;
     };
     resolveTools: (tools: CompiledTool[], binding?: CompiledAgentBinding) => unknown[];
     getToolNameMapping: (binding: CompiledAgentBinding) => ToolNameMapping;

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

@@ -3,6 +3,7 @@ import { buildBindingToolExecutionContext } from "./execution-context.js";
 import { finalizeRequestResult } from "../invocation-result.js";
 import { invokeRuntimeWithLocalTools } from "./invoke-runtime.js";
 import { buildInvocationRequest } from "../model/invocation-request.js";
+import { UPSTREAM_REQUEST_CONFIG_KEY, UPSTREAM_SESSION_CONFIG_KEY } from "../upstream-configurable-keys.js";
 export async function executeRequestInvocation(options) {
     const history = options.history ?? [];
     const invokeOptions = options.invokeOptions ?? {};
@@ -13,7 +14,14 @@ export async function executeRequestInvocation(options) {
         binding: options.binding,
         resolveTools: options.resolveTools,
         getToolNameMapping: options.getToolNameMapping,
-        context: invokeOptions.context,
+        toolConfig: {
+            ...(invokeOptions.context ? { context: invokeOptions.context } : {}),
+            configurable: {
+                [UPSTREAM_SESSION_CONFIG_KEY]: options.sessionId,
+                [UPSTREAM_REQUEST_CONFIG_KEY]: options.requestId,
+            },
+            ...(options.invokeOptions?.toolRuntimeContext ? { toolRuntimeContext: options.invokeOptions.toolRuntimeContext } : {}),
+        },
     });
     const builtinExecutableTools = await options.resolveBuiltinMiddlewareTools(options.binding, invokeOptions);
     const localOrUpstreamInvocation = await invokeRuntimeWithLocalTools({

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

@@ -4,7 +4,7 @@ import type { ToolNameMapping } from "../tool/tool-name-mapping.js";
 export type ExecutableTool = {
     name: string;
     schema: unknown;
-    invoke: (input: unknown) => Promise<unknown>;
+    invoke: (input: unknown, config?: Record<string, unknown>) => Promise<unknown>;
 };
 export declare function invokeRuntimeWithLocalTools(options: {
     binding: CompiledAgentBinding;

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

@@ -16,6 +16,8 @@ export declare function streamRuntimeExecution(options: {
         files?: Record<string, unknown>;
         requestId?: string;
         memoryContext?: string;
+        profiling?: boolean;
+        toolRuntimeContext?: Record<string, unknown>;
     };
     primaryTools: CompiledTool[];
     toolNameMapping: ToolNameMapping;
@@ -35,14 +37,16 @@ export declare function streamRuntimeExecution(options: {
         state?: Record<string, unknown>;
         files?: Record<string, unknown>;
         memoryContext?: string;
+        toolRuntimeContext?: Record<string, unknown>;
     }) => Promise<{
         output: string;
         metadata?: Record<string, unknown>;
     }>;
     applyToolRecoveryInstruction: (binding: CompiledAgentBinding, instruction: string) => CompiledAgentBinding;
+    isRetryableProviderError?: (binding: CompiledAgentBinding, error: unknown) => boolean;
     getSystemPrompt: (binding: CompiledAgentBinding) => string | undefined;
     isLangChainBinding: (binding: CompiledAgentBinding) => boolean;
     isDeepAgentBinding: (binding: CompiledAgentBinding) => boolean;
     countConfiguredTools: (binding: CompiledAgentBinding) => number;
-}): AsyncGenerator<RuntimeStreamChunk | string>;
+}): AsyncGenerator<RuntimeStreamChunk>;
 export {};