@bluecopa/harness 0.1.0-snapshot.87 → 0.1.0-snapshot.88

package/dist/arc/create-arc-agent.d.ts

@@ -1,4 +1,4 @@
-import { A as ArcLoopConfig, a as AgentMessage, b as ArcEvent, c as ArcRunResult, T as TraceEvent } from '../types-BS_9IiFG.js';
+import { A as ArcLoopConfig, a as AgentMessage, b as ArcEvent, c as ArcRunResult, T as TraceEvent } from '../types-CTO78tn-.js';
 import 'zod';
 import 'ai';
 

package/dist/arc/create-arc-agent.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'crypto';
-import { tool, streamText, generateText, generateObject } from 'ai';
+import { tool, streamText, generateText, generateObject, stepCountIs } from 'ai';
 import { anthropic } from '@ai-sdk/anthropic';
 import { z } from 'zod';
 import { readFile } from 'fs/promises';
@@ -883,6 +883,18 @@ function createChannel() {
 }
 var DEFAULT_PAGE_THRESHOLD = 4e3;
 var READ_FULL_RESULT_HARD_CAP = 32e3;
+function extractStepUsage(usage) {
+  if (!usage) return void 0;
+  const u = {};
+  if (usage.inputTokens != null) u.inputTokens = usage.inputTokens;
+  if (usage.outputTokens != null) u.outputTokens = usage.outputTokens;
+  const inputDetails = usage.inputTokenDetails ?? usage;
+  const outputDetails = usage.outputTokenDetails ?? usage;
+  if (inputDetails.cacheReadTokens != null) u.cacheReadTokens = inputDetails.cacheReadTokens;
+  if (inputDetails.cacheWriteTokens != null) u.cacheWriteTokens = inputDetails.cacheWriteTokens;
+  if (outputDetails.reasoningTokens != null) u.reasoningTokens = outputDetails.reasoningTokens;
+  return Object.keys(u).length > 0 ? u : void 0;
+}
 var PROCESS_SYSTEM_PROMPT = [
   "You are a focused execution thread within a larger agent system.",
   "Complete the assigned task using the available tools.",
@@ -1261,6 +1273,265 @@ var AgentRunner = class {
     }
     return { messages, output: "max steps reached", steps: config.maxSteps };
   }
+  async *stream(config) {
+    const messages = [
+      ...config.seed ?? [],
+      { role: "user", content: config.prompt }
+    ];
+    const systemContent = config.contextFacts?.length ? config.systemPrompt + "\n\n## Known Facts\n" + config.contextFacts.map((f) => `- ${f}`).join("\n") : config.systemPrompt;
+    const cachedSystem = [{
+      role: "system",
+      content: systemContent
+    }];
+    const pageThreshold = config.resultPageThreshold ?? DEFAULT_PAGE_THRESHOLD;
+    const pagingExcludeSet = new Set(config.pagingExclude ?? []);
+    const effectiveTools = config.resultPager ? {
+      ...config.tools,
+      ReadFullResult: tool({
+        description: "Retrieve the full content of a paged tool result. Use when the summary is insufficient and you need the complete data.",
+        inputSchema: z.object({
+          ref: z.string().describe("The paged result reference from a previous tool output"),
+          lineRange: z.object({
+            start: z.number().int().min(1).describe("Start line (1-indexed, inclusive)"),
+            end: z.number().int().min(1).describe("End line (1-indexed, inclusive)")
+          }).optional().describe("Optional line range to retrieve. Omit for full content.")
+        })
+      })
+    } : config.tools;
+    for (let step = 0; step < config.maxSteps; step++) {
+      config.signal.throwIfAborted();
+      yield { type: "step_start", step: step + 1 };
+      if (config.inbox) {
+        for await (const msg of drainNonBlocking(config.inbox)) {
+          messages.push(msg);
+        }
+      }
+      if (config.maxContextTokens && step > 0) {
+        trimContext(messages, config.maxContextTokens);
+      }
+      const result = streamText({
+        model: (config.createModel ?? anthropic)(config.model),
+        tools: normalizeTools(effectiveTools),
+        toolChoice: resolveToolChoice(config.toolChoice, step),
+        messages: toModelMessages(messages),
+        system: cachedSystem,
+        abortSignal: config.signal,
+        stopWhen: stepCountIs(1)
+      });
+      const toolCalls = [];
+      let finalText = "";
+      for await (const part of result.fullStream) {
+        if (part.type === "text-delta") {
+          finalText += part.text;
+          yield { type: "text_delta", text: part.text };
+        }
+        if (part.type === "tool-call") {
+          const raw = part;
+          toolCalls.push({
+            toolName: raw.toolName,
+            input: raw.args ?? raw.input ?? {},
+            ...raw.toolCallId != null ? { toolCallId: raw.toolCallId } : {},
+            ...raw.providerMetadata || raw.experimental_providerMetadata ? { providerMetadata: raw.providerMetadata ?? raw.experimental_providerMetadata } : {}
+          });
+        }
+      }
+      let usage;
+      try {
+        usage = extractStepUsage(await result.usage);
+      } catch {
+        usage = void 0;
+      }
+      if (toolCalls.length === 0) {
+        const rawText = finalText.trim();
+        if (!rawText && step === 0) {
+          const text2 = "ERROR: LLM returned empty response with no tool calls on first step. This may indicate an API billing issue, authentication error, or rate limit.";
+          messages.push({ role: "assistant", content: text2 });
+          yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
+          return { messages, output: text2, steps: step + 1 };
+        }
+        const text = rawText || "Done.";
+        messages.push({ role: "assistant", content: text });
+        if (config.hookRunner) {
+          const decision = await config.hookRunner.run({
+            event: "RunComplete",
+            metadata: {
+              messages,
+              steps: step + 1,
+              output: text
+            }
+          });
+          if (!decision.allow) {
+            messages.push({
+              role: "user",
+              content: decision.reason ?? "Continue \u2014 a required post-completion step was not performed."
+            });
+            yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
+            continue;
+          }
+        }
+        if (config.outputSchema) {
+          try {
+            const extractionMessages = [
+              ...messages,
+              { role: "user", content: "Extract the structured output from your response above." }
+            ];
+            const structured = await generateObject({
+              model: (config.createModel ?? anthropic)(config.model),
+              schema: config.outputSchema,
+              messages: toModelMessages(extractionMessages),
+              system: config.systemPrompt,
+              abortSignal: config.signal
+            });
+            yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
+            return { messages, output: text, steps: step + 1, structuredOutput: structured.object };
+          } catch {
+          }
+        }
+        yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
+        return { messages, output: text, steps: step + 1 };
+      }
+      const toolCallInfos = toolCalls.map((tc) => {
+        const info = {
+          toolCallId: tc.toolCallId ?? randomUUID(),
+          toolName: tc.toolName,
+          args: tc.input ?? {}
+        };
+        if (tc.providerMetadata) {
+          info.providerMetadata = tc.providerMetadata;
+        }
+        return info;
+      });
+      messages.push({
+        role: "assistant",
+        content: finalText || toolCalls.map((tc) => `${tc.toolName}(${JSON.stringify(tc.input ?? {}).slice(0, 100)})`).join(", "),
+        toolCalls: toolCallInfos
+      });
+      for (let index = 0; index < toolCallInfos.length; index += 1) {
+        const tc = toolCallInfos[index];
+        const action = {
+          type: "tool",
+          name: tc.toolName,
+          args: tc.args,
+          toolCallId: tc.toolCallId
+        };
+        yield { type: "tool_start", name: tc.toolName, args: tc.args, ...tc.toolCallId ? { toolCallId: tc.toolCallId } : {} };
+        if (tc.toolName === "ReadFullResult" && config.resultPager) {
+          const ref = String(tc.args.ref ?? "");
+          const content = await config.resultPager.retrieve(ref);
+          if (!content) {
+            const errorText = "ERROR: Content expired or not found. Use the summary above.";
+            messages.push({
+              role: "tool",
+              content: errorText,
+              toolResults: [{ toolCallId: tc.toolCallId, toolName: tc.toolName, result: errorText, isError: true }]
+            });
+            yield { type: "tool_end", name: tc.toolName, result: { success: false, output: "", error: errorText } };
+            continue;
+          }
+          let output = content;
+          const lr = tc.args.lineRange;
+          if (lr && typeof lr === "object" && "start" in lr && "end" in lr) {
+            const start = Number(lr.start);
+            const end = Number(lr.end);
+            if (Number.isFinite(start) && Number.isFinite(end) && start >= 1 && end >= start) {
+              const lines = content.split("\n");
+              output = lines.slice(start - 1, end).join("\n");
+            }
+          }
+          if (output.length > READ_FULL_RESULT_HARD_CAP) {
+            output = output.slice(0, READ_FULL_RESULT_HARD_CAP) + `
+
+[Showing first ${READ_FULL_RESULT_HARD_CAP} of ${output.length} chars. Use lineRange for specific sections.]`;
+          }
+          messages.push({
+            role: "tool",
+            content: output,
+            toolResults: [{ toolCallId: tc.toolCallId, toolName: tc.toolName, result: output, isError: false }]
+          });
+          yield { type: "tool_end", name: tc.toolName, result: { success: true, output } };
+          continue;
+        }
+        if (config.allowedToolNames && !config.allowedToolNames.includes(tc.toolName)) {
+          const resultText2 = `ERROR: Tool "${tc.toolName}" is not available in this profile.`;
+          messages.push({
+            role: "tool",
+            content: resultText2,
+            toolResults: [{
+              toolCallId: tc.toolCallId,
+              toolName: tc.toolName,
+              result: resultText2,
+              isError: true
+            }]
+          });
+          yield { type: "tool_end", name: tc.toolName, result: { success: false, output: "", error: resultText2 } };
+          continue;
+        }
+        let toolResult;
+        try {
+          toolResult = await executeTool(action, config.toolProvider, {
+            ...config.executeToolAction != null ? { executeToolAction: config.executeToolAction } : {},
+            ...config.hookRunner != null ? { hookRunner: config.hookRunner } : {},
+            ...config.permissionManager != null ? { permissionManager: config.permissionManager } : {},
+            ...config.askUser != null ? { askUser: config.askUser } : {},
+            ...config.tellUser != null ? { tellUser: config.tellUser } : {},
+            ...config.downloadRawFile != null ? { downloadRawFile: config.downloadRawFile } : {}
+          });
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          toolResult = {
+            success: false,
+            output: "",
+            error: errorMsg.length > 500 ? errorMsg.slice(0, 500) + "..." : errorMsg
+          };
+        }
+        let resultText = toolResult.success ? toolResult.output : `ERROR: ${toolResult.error ?? "unknown failure"}`;
+        if (config.resultPager && toolResult.success && resultText.length > pageThreshold && !pagingExcludeSet.has(tc.toolName) && tc.toolName !== "ReadFullResult") {
+          try {
+            const paged = await config.resultPager.page(resultText, {
+              toolName: tc.toolName,
+              toolCallId: tc.toolCallId
+            });
+            resultText = [
+              paged.summary,
+              "",
+              `[Full result: ${paged.originalLength} chars \u2014 call ReadFullResult("${paged.ref}") to retrieve]`
+            ].join("\n");
+          } catch {
+            resultText = resultText.slice(0, pageThreshold) + `
+
+[Truncated \u2014 ${resultText.length} chars total. Storage unavailable.]`;
+          }
+        }
+        if (config.maxToolResultLength && resultText.length > config.maxToolResultLength) {
+          const originalLength = resultText.length;
+          resultText = resultText.slice(0, config.maxToolResultLength) + `
+
+[Truncated \u2014 ${originalLength} chars total, showing first ${config.maxToolResultLength}.]`;
+        }
+        messages.push({
+          role: "tool",
+          content: resultText,
+          toolResults: [{
+            toolCallId: tc.toolCallId,
+            toolName: tc.toolName,
+            result: resultText,
+            isError: !toolResult.success
+          }]
+        });
+        yield {
+          type: "tool_end",
+          name: tc.toolName,
+          result: {
+            success: toolResult.success,
+            output: toolResult.output,
+            ...toolResult.error != null ? { error: toolResult.error } : {}
+          }
+        };
+      }
+      yield usage ? { type: "step_end", step: step + 1, usage } : { type: "step_end", step: step + 1 };
+    }
+    return { messages, output: "max steps reached", steps: config.maxSteps };
+  }
 };
 function createProcess(request, config) {
   const id = randomUUID();
@@ -1323,39 +1594,86 @@ ${subGuideBlocks}
         }
       }
       const result = await Promise.race([
-        runner.run({
-          model,
-          prompt: request.action,
-          tools: config.processTools,
-          systemPrompt,
-          toolProvider: config.toolProvider,
-          maxSteps,
-          signal: ac.signal,
-          seed,
-          inbox: inboxChannel,
-          onActivity: (activity) => {
-            outbox.push({ type: "activity", activity });
-          },
-          ...pickDefined(config, [
-            "createModel",
-            "hookRunner",
-            "permissionManager",
-            "telemetry",
-            "executeToolAction",
-            "askUser",
-            "tellUser",
-            "downloadRawFile",
-            "allowedToolNames",
-            "outputSchema",
-            "toolChoice",
-            "resultPager",
-            "resultPageThreshold",
-            "pagingExclude",
-            "maxToolResultLength",
-            "contextFacts",
-            "maxContextTokens"
-          ])
-        }),
+        (async () => {
+          const stream = runner.stream({
+            model,
+            prompt: request.action,
+            tools: config.processTools,
+            systemPrompt,
+            toolProvider: config.toolProvider,
+            maxSteps,
+            signal: ac.signal,
+            seed,
+            inbox: inboxChannel,
+            ...pickDefined(config, [
+              "createModel",
+              "hookRunner",
+              "permissionManager",
+              "telemetry",
+              "executeToolAction",
+              "askUser",
+              "tellUser",
+              "downloadRawFile",
+              "allowedToolNames",
+              "outputSchema",
+              "toolChoice",
+              "resultPager",
+              "resultPageThreshold",
+              "pagingExclude",
+              "maxToolResultLength",
+              "contextFacts",
+              "maxContextTokens"
+            ])
+          });
+          while (true) {
+            const next = await stream.next();
+            if (next.done) {
+              return next.value;
+            }
+            const event = next.value;
+            if (event.type === "text_delta") {
+              outbox.push({ type: "text_delta", text: event.text });
+              continue;
+            }
+            if (event.type === "step_start") {
+              outbox.push({ type: "step_start", step: event.step });
+              continue;
+            }
+            if (event.type === "step_end") {
+              outbox.push({
+                type: "step_end",
+                step: event.step,
+                ...event.usage ? { usage: event.usage } : {}
+              });
+              continue;
+            }
+            if (event.type === "tool_start") {
+              outbox.push({
+                type: "activity",
+                activity: {
+                  type: "tool_start",
+                  name: event.name,
+                  args: event.args,
+                  ts: Date.now()
+                }
+              });
+              continue;
+            }
+            if (event.type === "tool_end") {
+              outbox.push({
+                type: "activity",
+                activity: {
+                  type: "tool_end",
+                  name: event.name,
+                  ok: event.result.success,
+                  ms: 0,
+                  preview: String(event.result.output ?? "").slice(0, 200),
+                  ts: Date.now()
+                }
+              });
+            }
+          }
+        })(),
         timeoutPromise(config.processTimeout)
       ]);
       const durationMs = Date.now() - startTime;
@@ -2302,16 +2620,12 @@ ${a.content}`).join("\n\n");
       );
       if (active.length > 0) {
         const deadline = Date.now() + (this.config.processTimeout ?? 12e4);
-        await new Promise((resolve) => {
-          const check = () => {
-            if (active.every((p) => p.status !== "running" && p.status !== "pending") || Date.now() > deadline) {
-              resolve();
-            } else {
-              setTimeout(check, 10);
-            }
-          };
-          check();
-        });
+        while (active.some((p) => p.status === "running" || p.status === "pending") && Date.now() <= deadline) {
+          if (this.pendingEvents.length === 0) {
+            await this.waitForPendingEvent(signal, 400);
+          }
+          yield* this.drainPendingEvents();
+        }
       }
       const completionMessages = [];
       for (const [id, proc] of this.processes) {
@@ -2460,6 +2774,28 @@ ${hints.join("\n")}`
             id: proc.id,
             activity: event.activity
           });
+        } else if (event.type === "text_delta") {
+          this.traceProcessRunning(proc.id);
+          this.enqueuePendingEvent({
+            type: "process_text_delta",
+            id: proc.id,
+            text: event.text
+          });
+        } else if (event.type === "step_start") {
+          this.traceProcessRunning(proc.id);
+          this.enqueuePendingEvent({
+            type: "process_step_start",
+            id: proc.id,
+            step: event.step
+          });
+        } else if (event.type === "step_end") {
+          this.traceProcessRunning(proc.id);
+          this.enqueuePendingEvent({
+            type: "process_step_end",
+            id: proc.id,
+            step: event.step,
+            ...event.usage ? { usage: event.usage } : {}
+          });
         } else if (event.type === "done") {
           this.traceProcessRunning(proc.id);
           this.trace({ type: "process_transition", id: proc.id, from: "running", to: "completed" });