mid-conversation-effort-example changedbuild-with-claude/mid-conversation-effort-example
Nearest release: v2.1.296, published an hour after this site recorded the change. Shown because the two are within 24 hours of each other. Nothing here says the release caused the edit.
Recorded here
Lines+500added
Lines−557removed
From line
57
where the diff opens
First seen
14 Aug 2026
this site's first read of the page
Recorded edits11to this page, all time
The whole hunk
from line 57, old and new numbered
/
The two sides of this change are more than 400 edits apart, too far apart to line up, so this is the differ's own diff of it and the words inside a line are not marked.
from line 57
5757 ```typescript TypeScript
5858 import { exec } from "node:child_process";
5959 import { createHash } from "node:crypto";
60 import { rmSync } from "node:fs";
61 import { mkdtemp, readFile, rename, writeFile } from "node:fs/promises";
60 import { mkdtempDisposable, readFile, rename, writeFile } from "node:fs/promises";
6261 import { tmpdir } from "node:os";
6362 import { join } from "node:path";
64 import { promisify } from "node:util";
6563
6664 import Anthropic from "@anthropic-ai/sdk";
6765
from line 99
10199 const string systemPrompt = "You are a helpful general-purpose agent. Answer the user's request directly.";
102100
103101 const int requestTimeoutSeconds = 600;
104 // The other ports stream with max_tokens 64000. This port uses non-streaming
105 // Messages.Create, and the API rejects non-streaming requests at that size.
106 // 8192 is the non-streaming ceiling for Opus 4.0 and 4.1 and a conservative
107 // choice for newer Opus models.
108 const int requestMaxTokens = 8192;
109102 const int bashTimeoutSeconds = 60;
110103 const int toolResultMaxChars = 8000;
111104 const int maxConcurrent = 10;
112105 var docTestMode = Environment.GetEnvironmentVariable("DOC_TEST_MODE") is { Length: > 0 };
113 int maxTotalSubtasks = docTestMode ? 2 : 200;
114 int maxSubagentTurns = docTestMode ? 1 : 15;
115 int maxMainTurns = docTestMode ? 1 : 30;
106 var maxTotalSubtasks = docTestMode ? 2 : 200;
107 var maxSubagentTurns = docTestMode ? 1 : 15;
108 var maxMainTurns = docTestMode ? 1 : 30;
116109 const int turnsBetweenRefreshers = 10;
117 var journalPath = Environment.GetEnvironmentVariable("ORCH_JOURNAL") is { Length: > 0 } p ? p : "orchestration_journal.json";
110 var journalPath = Environment.GetEnvironmentVariable("ORCH_JOURNAL") is { Length: > 0 } configuredPath
111 ? configuredPath
112 : "orchestration_journal.json";
118113 ```
119114
120115 ```go Go
from line 166
171166 ```
172167
173168 ```java Java
169 // java.base (java.util, java.nio.file, java.util.concurrent, ...) is imported
170 // implicitly in a compact source file, so only the SDK and Jackson need imports.
174171 import com.anthropic.client.AnthropicClient;
175172 import com.anthropic.client.okhttp.AnthropicOkHttpClient;
173 import com.anthropic.core.JsonArray;
174 import com.anthropic.core.JsonBoolean;
175 import com.anthropic.core.JsonObject;
176 import com.anthropic.core.JsonString;
176177 import com.anthropic.core.JsonValue;
177178 import com.anthropic.core.RequestOptions;
178179 import com.anthropic.helpers.MessageAccumulator;
179 import com.anthropic.models.messages.ContentBlock;
180180 import com.anthropic.models.messages.ContentBlockParam;
181181 import com.anthropic.models.messages.Message;
182182 import com.anthropic.models.messages.MessageCreateParams;
from line 193
193193 import com.fasterxml.jackson.core.type.TypeReference;
194194 import com.fasterxml.jackson.databind.JsonNode;
195195 import com.fasterxml.jackson.databind.ObjectMapper;
196 import java.io.IOException;
197 import java.io.UncheckedIOException;
198 import java.nio.charset.StandardCharsets;
199 import java.nio.file.Files;
200 import java.nio.file.Path;
201 import java.nio.file.StandardCopyOption;
202 import java.security.MessageDigest;
203 import java.time.Duration;
204 import java.util.ArrayList;
205 import java.util.Comparator;
206 import java.util.HashMap;
207 import java.util.HexFormat;
208 import java.util.List;
209 import java.util.Map;
210 import java.util.Objects;
211 import java.util.Optional;
212 import java.util.concurrent.Callable;
213 import java.util.concurrent.CancellationException;
214 import java.util.concurrent.CompletableFuture;
215 import java.util.concurrent.ExecutionException;
216 import java.util.concurrent.ExecutorService;
217 import java.util.concurrent.Executors;
218 import java.util.concurrent.Future;
219 import java.util.concurrent.TimeUnit;
220 import java.util.concurrent.locks.ReentrantLock;
221 import java.util.stream.Collectors;
222 import java.util.stream.IntStream;
223196
224197 AnthropicClient client = AnthropicOkHttpClient.fromEnv();
225198
from line 215
242215 static final int MAX_MAIN_TURNS = DOC_TEST_MODE ? 1 : 30;
243216 static final int TURNS_BETWEEN_REFRESHERS = 10;
244217 static final Path JOURNAL_PATH = Path.of(Optional.ofNullable(System.getenv("ORCH_JOURNAL"))
245 .filter(s -> !s.isEmpty()).orElse("orchestration_journal.json"));
218 .filter(path -> !path.isEmpty())
219 .orElse("orchestration_journal.json"));
246220 ```
247221
248222 ```php PHP
from line 331
357331 ```
358332
359333 ```java Java
360 static final String MODE_ENTER =
361 "Orchestration mode is on: optimize for the most exhaustive, correct answer rather than "
362 + "the fastest one. Use the Workflow tool on every substantive task, sized to the problem's "
363 + "natural decomposition rather than the maximum the tool allows. See the Workflow tool's "
364 + "description for standing consent, granularity guidance, and quality patterns. Work solo "
365 + "only on conversational or trivial turns.";
334 static final String MODE_ENTER = """
335 Orchestration mode is on: optimize for the most exhaustive, correct answer rather than \
336 the fastest one. Use the Workflow tool on every substantive task, sized to the problem's \
337 natural decomposition rather than the maximum the tool allows. See the Workflow tool's \
338 description for standing consent, granularity guidance, and quality patterns. Work solo \
339 only on conversational or trivial turns.""";
366340 static final String MODE_REFRESH =
367341 "Orchestration mode is still on. Use the Workflow tool; see its standing consent section.";
368342 static final String MODE_EXIT =
from line 447
473447 ```typescript TypeScript
474448 const WORKFLOW_TOOL: Anthropic.Tool = {
475449 name: "Workflow",
476 description:
450 description: [
477451 "Orchestrate a multiagent workflow: split a large task into independent subtasks " +
478 "and run them as parallel agents, then collect their results.\n\n" +
452 "and run them as parallel agents, then collect their results.",
479453 "Opt-in: only use this tool when the user explicitly asks for a workflow, or when a " +
480 "system message confirms that orchestration mode is on.\n\n" +
454 "system message confirms that orchestration mode is on.",
481455 "Quality patterns: adversarial verification (a second wave of agents checks the first " +
482 "wave's findings against the source), a completeness critic (one agent hunts for what " +
483 "the others missed), and multiphase sequencing (understand, design, implement, and " +
484 "review as separate workflow calls, reading results between phases). A useful default " +
485 "is hybrid: scout inline first to discover the work-list, then fan out over it.\n\n" +
456 "wave's findings against the source), a completeness critic (one agent hunts for what " +
457 "the others missed), and multiphase sequencing (understand, design, implement, and " +
458 "review as separate workflow calls, reading results between phases). A useful default " +
459 "is hybrid: scout inline first to discover the work-list, then fan out over it.",
486460 "Granularity: scope each subtask to a distinct concern, component, or question rather " +
487 "than per line or per file section. Scale the count to what the user asked for: a " +
488 "focused review of a module of a few hundred lines rarely needs more than about ten " +
489 "subtasks; a broad audit of a large codebase can justify more.\n\n" +
461 "than per line or per file section. Scale the count to what the user asked for: a " +
462 "focused review of a module of a few hundred lines rarely needs more than about ten " +
463 "subtasks; a broad audit of a large codebase can justify more.",
490464 "Standing consent: while a system message confirms orchestration mode is on, that " +
491 "opt-in is standing. Author and run a workflow for every substantive task by default, " +
492 "and lean toward verifying findings adversarially. Work solo only on conversational " +
493 "turns or trivial mechanical edits. When a system message says the mode is off, " +
494 "revert to the opt-in rule above.",
465 "opt-in is standing. Author and run a workflow for every substantive task by default, " +
466 "and lean toward verifying findings adversarially. Work solo only on conversational " +
467 "turns or trivial mechanical edits. When a system message says the mode is off, " +
468 "revert to the opt-in rule above.",
469 ].join("\n\n"),
495470 input_schema: {
496471 type: "object",
497472 properties: {
from line 516
541516 Tool workflowTool = new()
542517 {
543518 Name = "Workflow",
544 Description =
545 "Orchestrate a multiagent workflow: split a large task into independent subtasks "
546 + "and run them as parallel agents, then collect their results.\n\n"
547 + "Opt-in: only use this tool when the user explicitly asks for a workflow, or when a "
548 + "system message confirms that orchestration mode is on.\n\n"
549 + "Quality patterns: adversarial verification (a second wave of agents checks the first "
550 + "wave's findings against the source), a completeness critic (one agent hunts for what "
551 + "the others missed), and multiphase sequencing (understand, design, implement, and "
552 + "review as separate workflow calls, reading results between phases). A useful default "
553 + "is hybrid: scout inline first to discover the work-list, then fan out over it.\n\n"
554 + "Granularity: scope each subtask to a distinct concern, component, or question rather "
555 + "than per line or per file section. Scale the count to what the user asked for: a "
556 + "focused review of a module of a few hundred lines rarely needs more than about ten "
557 + "subtasks; a broad audit of a large codebase can justify more.\n\n"
558 + "Standing consent: while a system message confirms orchestration mode is on, that "
559 + "opt-in is standing. Author and run a workflow for every substantive task by default, "
560 + "and lean toward verifying findings adversarially. Work solo only on conversational "
561 + "turns or trivial mechanical edits. When a system message says the mode is off, "
562 + "revert to the opt-in rule above.",
563 InputSchema = new InputSchema
519 Description = """
520 Orchestrate a multiagent workflow: split a large task into independent subtasks and run them as parallel agents, then collect their results.
521
522 Opt-in: only use this tool when the user explicitly asks for a workflow, or when a system message confirms that orchestration mode is on.
523
524 Quality patterns: adversarial verification (a second wave of agents checks the first wave's findings against the source), a completeness critic (one agent hunts for what the others missed), and multiphase sequencing (understand, design, implement, and review as separate workflow calls, reading results between phases). A useful default is hybrid: scout inline first to discover the work-list, then fan out over it.
525
526 Granularity: scope each subtask to a distinct concern, component, or question rather than per line or per file section. Scale the count to what the user asked for: a focused review of a module of a few hundred lines rarely needs more than about ten subtasks; a broad audit of a large codebase can justify more.
527
528 Standing consent: while a system message confirms orchestration mode is on, that opt-in is standing. Author and run a workflow for every substantive task by default, and lean toward verifying findings adversarially. Work solo only on conversational turns or trivial mechanical edits. When a system message says the mode is off, revert to the opt-in rule above.
529 """,
530 InputSchema = new()
564531 {
565532 Properties = new Dictionary<string, JsonElement>
566533 {
from line 550
583550 Description =
584551 "Report the final findings for your subtask. Call this exactly once, when you are "
585552 + "done investigating; it ends your task.",
586 InputSchema = new InputSchema
553 InputSchema = new()
587554 {
588555 Properties = new Dictionary<string, JsonElement>
589556 {
from line 657
690657 ```java Java
691658 static final Tool WORKFLOW_TOOL = Tool.builder()
692659 .name("Workflow")
693 .description("Orchestrate a multiagent workflow: split a large task into independent subtasks "
694 + "and run them as parallel agents, then collect their results.\n\n"
695 + "Opt-in: only use this tool when the user explicitly asks for a workflow, or when a "
696 + "system message confirms that orchestration mode is on.\n\n"
697 + "Quality patterns: adversarial verification (a second wave of agents checks the first "
698 + "wave's findings against the source), a completeness critic (one agent hunts for what "
699 + "the others missed), and multiphase sequencing (understand, design, implement, and "
700 + "review as separate workflow calls, reading results between phases). A useful default "
701 + "is hybrid: scout inline first to discover the work-list, then fan out over it.\n\n"
702 + "Granularity: scope each subtask to a distinct concern, component, or question rather "
703 + "than per line or per file section. Scale the count to what the user asked for: a "
704 + "focused review of a module of a few hundred lines rarely needs more than about ten "
705 + "subtasks; a broad audit of a large codebase can justify more.\n\n"
706 + "Standing consent: while a system message confirms orchestration mode is on, that "
707 + "opt-in is standing. Author and run a workflow for every substantive task by default, "
708 + "and lean toward verifying findings adversarially. Work solo only on conversational "
709 + "turns or trivial mechanical edits. When a system message says the mode is off, "
710 + "revert to the opt-in rule above.")
660 .description("""
661 Orchestrate a multiagent workflow: split a large task into independent subtasks \
662 and run them as parallel agents, then collect their results.
663
664 Opt-in: only use this tool when the user explicitly asks for a workflow, or when a \
665 system message confirms that orchestration mode is on.
666
667 Quality patterns: adversarial verification (a second wave of agents checks the first \
668 wave's findings against the source), a completeness critic (one agent hunts for what \
669 the others missed), and multiphase sequencing (understand, design, implement, and \
670 review as separate workflow calls, reading results between phases). A useful default \
671 is hybrid: scout inline first to discover the work-list, then fan out over it.
672
673 Granularity: scope each subtask to a distinct concern, component, or question rather \
674 than per line or per file section. Scale the count to what the user asked for: a \
675 focused review of a module of a few hundred lines rarely needs more than about ten \
676 subtasks; a broad audit of a large codebase can justify more.
677
678 Standing consent: while a system message confirms orchestration mode is on, that \
679 opt-in is standing. Author and run a workflow for every substantive task by default, \
680 and lean toward verifying findings adversarially. Work solo only on conversational \
681 turns or trivial mechanical edits. When a system message says the mode is off, \
682 revert to the opt-in rule above.""")
711683 .inputSchema(Tool.InputSchema.builder()
712 .properties(JsonValue.from(Map.of(
713 "subtasks", Map.of(
684 .properties(Tool.InputSchema.Properties.builder()
685 .putAdditionalProperty("subtasks", JsonValue.from(Map.of(
714686 "type", "array",
715687 "items", Map.of("type", "string"),
716 "description", "Independent subtask prompts to run as parallel agents"))))
688 "description", "Independent subtask prompts to run as parallel agents")))
689 .build())
717690 .putAdditionalProperty("required", JsonValue.from(List.of("subtasks")))
718691 .build())
719692 .build();
from line 695
722695
723696 static final Tool REPORT_TOOL = Tool.builder()
724697 .name("report_findings")
725 .description("Report the final findings for your subtask. Call this exactly once, when you are "
726 + "done investigating; it ends your task.")
698 .description("""
699 Report the final findings for your subtask. Call this exactly once, when you are \
700 done investigating; it ends your task.""")
727701 .inputSchema(Tool.InputSchema.builder()
728 .properties(JsonValue.from(Map.of(
729 "summary", Map.of("type", "string", "description", "Two or three sentences of synthesis"),
730 "findings", Map.of(
702 .properties(Tool.InputSchema.Properties.builder()
703 .putAdditionalProperty("summary", JsonValue.from(Map.of(
704 "type", "string",
705 "description", "Two or three sentences of synthesis")))
706 .putAdditionalProperty("findings", JsonValue.from(Map.of(
731707 "type", "array",
732708 "items", Map.of(
733709 "type", "object",
from line 717
741717 "severity", Map.of(
742718 "type", "string",
743719 "enum", List.of("high", "medium", "low", "info"))),
744 "required", List.of("claim", "evidence", "severity"))))))
720 "required", List.of("claim", "evidence", "severity")))))
721 .build())
745722 .putAdditionalProperty("required", JsonValue.from(List.of("summary", "findings")))
746723 .build())
747724 .build();
from line 912
935912 ```
936913
937914 ```typescript TypeScript
938 const execShell = promisify(exec);
915 type ToolOutcome = { output: string; isError: boolean };
939916
940917 // Run bash where the example was launched. In DOC_TEST_MODE the docs harness
941 // points it at a throwaway fixture directory instead, removed on exit.
942 const WORK_DIR = DOC_TEST_MODE
943 ? await mkdtemp(join(tmpdir(), "orchestration-"))
944 : process.cwd();
945 if (DOC_TEST_MODE) {
918 // points it at a throwaway fixture directory instead, removed when the program ends.
919 await using fixtureDir = DOC_TEST_MODE
920 ? await mkdtempDisposable(join(tmpdir(), "orchestration-"))
921 : null;
922 const WORK_DIR = fixtureDir?.path ?? process.cwd();
923 if (fixtureDir) {
946924 await writeFile(
947925 join(WORK_DIR, "sample.py"),
948 "def fib(n):\n" +
949 " return n if n < 2 else fib(n - 1) + fib(n - 2)\n\n" +
950 "print(fib(10))\n",
926 `def fib(n):
927 return n if n < 2 else fib(n - 1) + fib(n - 2)
928
929 print(fib(10))
930 `,
951931 );
952 process.on("exit", () => rmSync(WORK_DIR, { recursive: true, force: true }));
953932 }
954933
955934 // Run a shell command and return its output. No sandbox: example code only.
956 async function runBash(command: string): Promise<{ output: string; isError: boolean }> {
935 function runBash(command: string): Promise<ToolOutcome> {
957936 console.error(`[bash] ${command}`);
958 let stdout = "";
959 let stderr = "";
960 let exitCode = 0;
961 try {
962 ({ stdout, stderr } = await execShell(command, {
963 shell: "/bin/bash",
964 cwd: WORK_DIR,
965 timeout: BASH_TIMEOUT_SECONDS * 1000,
966 maxBuffer: 16 * 1024 * 1024,
967 }));
968 } catch (error) {
969 const failure = error as {
970 stdout?: string;
971 stderr?: string;
972 code?: number | string;
973 killed?: boolean;
974 };
975 if (failure.killed && failure.code !== "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
976 return { output: `command timed out after ${BASH_TIMEOUT_SECONDS}s`, isError: true };
977 }
978 stdout = failure.stdout ?? "";
979 stderr = failure.stderr ?? "";
980 exitCode = typeof failure.code === "number" ? failure.code : 1;
981 }
982 let output = (stdout + stderr).trim() || "(no output)";
983 const codePoints = [...output];
984 if (codePoints.length > TOOL_RESULT_MAX_CHARS) {
985 output =
986 codePoints.slice(0, TOOL_RESULT_MAX_CHARS).join("") +
987 `\n(truncated at ${TOOL_RESULT_MAX_CHARS} chars)`;
988 }
989 if (exitCode !== 0) {
990 output = `(exit code ${exitCode})\n${output}`;
991 }
992 return { output, isError: exitCode !== 0 };
993 }
994
995 async function handleBashBlock(
996 block: Anthropic.ToolUseBlock,
997 ): Promise<{ output: string; isError: boolean }> {
998 const input = block.input as { command?: string; restart?: boolean };
999 if (input.restart === true) {
937 const options = {
938 shell: "/bin/bash",
939 cwd: WORK_DIR,
940 timeout: BASH_TIMEOUT_SECONDS * 1000,
941 maxBuffer: 16 * 1024 * 1024,
942 };
943 return new Promise((resolve) => {
944 exec(command, options, (error, stdout, stderr) => {
945 if (error?.killed) {
946 resolve({ output: `command timed out after ${BASH_TIMEOUT_SECONDS}s`, isError: true });
947 return;
948 }
949 const exitCode = error === null ? 0 : typeof error.code === "number" ? error.code : 1;
950 let output = (stdout + stderr).trim() || "(no output)";
951 const codePoints = [...output];
952 if (codePoints.length > TOOL_RESULT_MAX_CHARS) {
953 const kept = codePoints.slice(0, TOOL_RESULT_MAX_CHARS).join("");
954 output = `${kept}\n(truncated at ${TOOL_RESULT_MAX_CHARS} chars)`;
955 }
956 if (exitCode !== 0) {
957 output = `(exit code ${exitCode})\n${output}`;
958 }
959 resolve({ output, isError: exitCode !== 0 });
960 });
961 });
962 }
963
964 async function handleBashBlock(block: Anthropic.ToolUseBlock): Promise<ToolOutcome> {
965 const { command, restart } = block.input as { command?: string; restart?: boolean };
966 if (restart === true) {
1000967 return { output: "Shell restarted.", isError: false };
1001968 }
1002 if (!input.command) {
969 if (!command) {
1003970 return { output: "bash error: no command was provided.", isError: true };
1004971 }
1005 return runBash(input.command);
972 return runBash(command);
1006973 }
1007974 ```
1008975
from line 980
1013980 if (docTestMode)
1014981 {
1015982 workDir = Directory.CreateTempSubdirectory("orchestration-").FullName;
1016 File.WriteAllText(Path.Combine(workDir, "sample.py"),
1017 "def fib(n):\n" +
1018 " return n if n < 2 else fib(n - 1) + fib(n - 2)\n\n" +
1019 "print(fib(10))\n");
983 await File.WriteAllTextAsync(Path.Combine(workDir, "sample.py"), """
984 def fib(n):
985 return n if n < 2 else fib(n - 1) + fib(n - 2)
986
987 print(fib(10))
988
989 """);
1020990 var fixtureDir = workDir;
1021991 AppDomain.CurrentDomain.ProcessExit += (_, _) =>
1022992 {
from line 1050
10801050 // Execute one bash tool call requested by the model.
10811051 async Task<(string Output, bool IsError)> HandleBashBlock(ToolUseBlock block)
10821052 {
1083 if (block.Input.TryGetValue("restart", out var restart) && restart.ValueKind == JsonValueKind.True)
1053 if (block.Input.GetValueOrDefault("restart").ValueKind is JsonValueKind.True)
10841054 {
10851055 return ("Shell restarted.", false);
10861056 }
1087 var command = block.Input.TryGetValue("command", out var rawCommand) && rawCommand.ValueKind == JsonValueKind.String
1088 ? rawCommand.GetString()!
1089 : "";
1090 if (command.Length == 0)
1091 {
1092 return ("bash error: no command was provided.", true);
1093 }
1094 return await RunBash(command);
1057 return block.Input.GetValueOrDefault("command") is { ValueKind: JsonValueKind.String } command
1058 && command.GetString() is { Length: > 0 } commandText
1059 ? await RunBash(commandText)
1060 : ("bash error: no command was provided.", true);
10951061 }
10961062 ```
10971063
from line 1076
11101076 if err != nil {
11111077 log.Fatal(err)
11121078 }
1113 fixture := "def fib(n):\n" +
1114 " return n if n < 2 else fib(n - 1) + fib(n - 2)\n\n" +
1115 "print(fib(10))\n"
1079 const fixture = `def fib(n):
1080 return n if n < 2 else fib(n - 1) + fib(n - 2)
1081
1082 print(fib(10))
1083 `
11161084 if err := os.WriteFile(filepath.Join(dir, "sample.py"), []byte(fixture), 0o644); err != nil {
11171085 log.Fatal(err)
11181086 }
from line 1109
11411109 if err == nil {
11421110 return output, false
11431111 }
1144 var exitErr *exec.ExitError
1145 if errors.As(err, &exitErr) {
1112 if exitErr, ok := errors.AsType[*exec.ExitError](err); ok {
11461113 return fmt.Sprintf("(exit code %d)\n%s", exitErr.ExitCode(), output), true
11471114 }
11481115 return fmt.Sprintf("(%s)\n%s", err, output), true
from line 1155
11881155 print(fib(10))
11891156 """);
11901157 Runtime.getRuntime().addShutdownHook(new Thread(() -> {
1158 // Best-effort cleanup; the OS tmp sweeper handles leftovers.
11911159 try (var paths = Files.walk(dir)) {
1192 paths.sorted(Comparator.reverseOrder()).forEach(p -> {
1193 try { Files.deleteIfExists(p); } catch (IOException ignored) {}
1160 paths.sorted(Comparator.reverseOrder()).forEach(path -> {
1161 try { Files.deleteIfExists(path); } catch (IOException _) {}
11941162 });
1195 } catch (IOException ignored) {
1196 // Best-effort cleanup; the OS tmp sweeper handles leftovers.
1197 }
1163 } catch (IOException _) {}
11981164 }));
11991165 return dir;
12001166 } catch (IOException error) {
from line 1184
12181184 CompletableFuture<String> outputReader = CompletableFuture.supplyAsync(() -> {
12191185 try (var stdout = process.getInputStream()) {
12201186 return new String(stdout.readAllBytes(), StandardCharsets.UTF_8);
1221 } catch (IOException error) {
1187 } catch (IOException _) {
12221188 return "";
12231189 }
12241190 });
from line 1193
12271193 outputReader.cancel(true);
12281194 return new ToolOutput("command timed out after " + BASH_TIMEOUT_SECONDS + "s", true);
12291195 }
1230 String output = outputReader.join().trim();
1196 String output = outputReader.join().strip();
12311197 if (output.isEmpty()) {
12321198 output = "(no output)";
1233 }
1234 if (output.length() > TOOL_RESULT_MAX_CHARS) {
1199 } else if (output.length() > TOOL_RESULT_MAX_CHARS) {
12351200 output = output.substring(0, TOOL_RESULT_MAX_CHARS)
12361201 + "\n(truncated at " + TOOL_RESULT_MAX_CHARS + " chars)";
12371202 }
12381203 int exitCode = process.exitValue();
1239 if (exitCode != 0) {
1240 return new ToolOutput("(exit code " + exitCode + ")\n" + output, true);
1241 }
1242 return new ToolOutput(output, false);
1204 return exitCode == 0
1205 ? new ToolOutput(output, false)
1206 : new ToolOutput("(exit code " + exitCode + ")\n" + output, true);
1207 }
1208
1209 // A tool call's input fields, or an empty map if the model sent something other than an object.
1210 Map<String, JsonValue> toolInput(ToolUseBlock toolUse) {
1211 return toolUse._input() instanceof JsonObject object ? object.values() : Map.of();
12431212 }
12441213
12451214 // Execute one bash tool call requested by the model.
1246 ToolOutput handleBashBlock(ToolUseBlock block) throws InterruptedException {
1247 Map<String, JsonValue> input = (Map<String, JsonValue>) block._input().asObject().orElse(Map.of());
1248 JsonValue restart = input.getOrDefault("restart", JsonValue.from(false));
1249 if (Boolean.TRUE.equals(restart.asBoolean().orElse(false))) {
1215 ToolOutput handleBashBlock(ToolUseBlock toolUse) throws InterruptedException {
1216 Map<String, JsonValue> input = toolInput(toolUse);
1217 if (input.get("restart") instanceof JsonBoolean restart && restart.value()) {
12501218 return new ToolOutput("Shell restarted.", false);
12511219 }
1252 JsonValue raw = input.get("command");
1253 String command = raw != null && raw.asString().isPresent() ? raw.asStringOrThrow() : "";
1220 String command = input.get("command") instanceof JsonString text ? text.value() : "";
12541221 if (command.isEmpty()) {
12551222 return new ToolOutput("bash error: no command was provided.", true);
12561223 }
from line 1486
15191486 }
15201487 if (response.stop_reason !== "tool_use") {
15211488 let text = response.content
1522 .filter((block): block is Anthropic.TextBlock => block.type === "text")
1523 .map((block) => block.text)
1489 .flatMap((block) => (block.type === "text" ? [block.text] : []))
15241490 .join("");
15251491 if (response.stop_reason === "max_tokens") {
15261492 text += "\n\n(warning: subagent response was truncated at max_tokens)";
from line 1499
15331499 if (block.type !== "tool_use") {
15341500 continue;
15351501 }
1536 let output: string;
1537 let isError: boolean;
1502 let outcome: ToolOutcome;
15381503 switch (block.name) {
15391504 case "report_findings":
15401505 report = JSON.stringify(block.input, null, 2);
1541 output = "Findings recorded.";
1542 isError = false;
1506 outcome = { output: "Findings recorded.", isError: false };
15431507 break;
15441508 case "bash":
1545 ({ output, isError } = await handleBashBlock(block));
1509 outcome = await handleBashBlock(block);
15461510 break;
15471511 default:
1548 output = `unknown tool: ${block.name}`;
1549 isError = true;
1512 outcome = { output: `unknown tool: ${block.name}`, isError: true };
15501513 }
15511514 toolResults.push({
15521515 type: "tool_result",
15531516 tool_use_id: block.id,
1554 content: output,
1555 is_error: isError,
1517 content: outcome.output,
1518 is_error: outcome.isError,
15561519 });
15571520 }
15581521 if (report !== null) {
from line 1530
15671530 ```csharp C#
15681531 // One subagent: a small nested agent loop with the bash tool plus report_findings.
15691532 // Subagents inherit the main loop's effort level.
1533 JsonSerializerOptions indented = new() { WriteIndented = true };
1534
15701535 async Task<string> RunSubagent(string prompt)
15711536 {
15721537 const string subagentSystem =
from line 1542
15771542 for (var turn = 0; turn < maxSubagentTurns; turn++)
15781543 {
15791544 using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(requestTimeoutSeconds));
1580 var response = await client.Messages.Create(new MessageCreateParams
1545 var response = await client.Messages.CreateStreaming(new MessageCreateParams
15811546 {
15821547 Model = model,
1583 MaxTokens = requestMaxTokens,
1548 MaxTokens = 64000,
15841549 System = subagentSystem,
15851550 OutputConfig = new OutputConfig { Effort = effort },
15861551 Tools = [bashTool, reportTool],
15871552 Messages = messages,
1588 }, cancellationToken: deadline.Token);
1553 }, cancellationToken: deadline.Token).Aggregate();
15891554 messages.Add(new()
15901555 {
15911556 Role = Role.Assistant,
from line 1578
16131578 {
16141579 continue;
16151580 }
1616 string output;
1617 bool isError;
16181581 if (toolUse.Name == "report_findings")
16191582 {
1620 report = JsonSerializer.Serialize(
1621 toolUse.Input, new JsonSerializerOptions { WriteIndented = true });
1622 output = "Findings recorded.";
1623 isError = false;
1583 report = JsonSerializer.Serialize(toolUse.Input, indented);
16241584 }
1625 else if (toolUse.Name == "bash")
1585 var (output, isError) = toolUse.Name switch
16261586 {
1627 (output, isError) = await HandleBashBlock(toolUse);
1628 }
1629 else
1630 {
1631 output = $"unknown tool: {toolUse.Name}";
1632 isError = true;
1633 }
1587 "report_findings" => ("Findings recorded.", false),
1588 "bash" => await HandleBashBlock(toolUse),
1589 _ => ($"unknown tool: {toolUse.Name}", true),
1590 };
16341591 toolResults.Add(new ToolResultBlockParam(toolUse.ID) { Content = output, IsError = isError });
16351592 }
16361593 if (report is not null)
from line 1601
16441601 ```
16451602
16461603 ```go Go
1604 // streamMessage sends one request and accumulates the streamed events into the
1605 // final message.
1606 func streamMessage(ctx context.Context, params anthropic.MessageNewParams) (anthropic.Message, error) {
1607 ctx, cancel := context.WithTimeout(ctx, requestTimeoutSeconds*time.Second)
1608 defer cancel()
1609 stream := client.Messages.NewStreaming(ctx, params)
1610 defer stream.Close()
1611 var message anthropic.Message
1612 for stream.Next() {
1613 if err := message.Accumulate(stream.Current()); err != nil {
1614 return message, err
1615 }
1616 }
1617 return message, stream.Err()
1618 }
1619
1620 // textOf joins the text blocks of a response.
1621 func textOf(message anthropic.Message) string {
1622 var text strings.Builder
1623 for _, block := range message.Content {
1624 if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
1625 text.WriteString(textBlock.Text)
1626 }
1627 }
1628 return text.String()
1629 }
1630
16471631 // runSubagent runs one subagent: a small nested agent loop with the bash tool plus
16481632 // report_findings. Subagents inherit the main loop's effort level.
16491633 func runSubagent(ctx context.Context, model string, prompt string) (string, error) {
1650 subagentSystem := "You are one agent in a larger parallel fan-out, assigned a single subtask. " +
1634 const subagentSystem = "You are one agent in a larger parallel fan-out, assigned a single subtask. " +
16511635 "Investigate it directly, using bash to check facts rather than guessing, and finish " +
16521636 "by calling report_findings exactly once. Return findings, not narration."
16531637 messages := []anthropic.MessageParam{anthropic.NewUserMessage(anthropic.NewTextBlock(prompt))}
16541638 for range maxSubagentTurns {
1655 var response anthropic.Message
1656 err := func() error {
1657 ctx, cancel := context.WithTimeout(ctx, requestTimeoutSeconds*time.Second)
1658 defer cancel()
1659 stream := client.Messages.NewStreaming(ctx, anthropic.MessageNewParams{
1660 Model: model,
1661 MaxTokens: 64000,
1662 System: []anthropic.TextBlockParam{{Text: subagentSystem}},
1663 OutputConfig: anthropic.OutputConfigParam{Effort: effort},
1664 Tools: []anthropic.ToolUnionParam{bashTool, reportTool},
1665 Messages: messages,
1666 })
1667 defer stream.Close()
1668 for stream.Next() {
1669 if err := response.Accumulate(stream.Current()); err != nil {
1670 return err
1671 }
1672 }
1673 return stream.Err()
1674 }()
1639 response, err := streamMessage(ctx, anthropic.MessageNewParams{
1640 Model: model,
1641 MaxTokens: 64000,
1642 System: []anthropic.TextBlockParam{{Text: subagentSystem}},
1643 OutputConfig: anthropic.OutputConfigParam{Effort: effort},
1644 Tools: []anthropic.ToolUnionParam{bashTool, reportTool},
1645 Messages: messages,
1646 })
16751647 if err != nil {
16761648 return "", err
16771649 }
16781650 messages = append(messages, response.ToParam())
1679 if response.StopReason == anthropic.StopReasonPauseTurn {
1651
1652 switch response.StopReason {
1653 case anthropic.StopReasonPauseTurn:
16801654 continue
1655 case anthropic.StopReasonMaxTokens:
1656 return textOf(response) + "\n\n(warning: subagent response was truncated at max_tokens)", nil
1657 case anthropic.StopReasonToolUse:
1658 default:
1659 return textOf(response), nil
16811660 }
1682 if response.StopReason != anthropic.StopReasonToolUse {
1683 var text strings.Builder
1684 for _, block := range response.Content {
1685 if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
1686 text.WriteString(textBlock.Text)
1687 }
1688 }
1689 if response.StopReason == anthropic.StopReasonMaxTokens {
1690 text.WriteString("\n\n(warning: subagent response was truncated at max_tokens)")
1691 }
1692 return text.String(), nil
1693 }
1661
16941662 var toolResults []anthropic.ContentBlockParamUnion
16951663 var report string
16961664 var reportRecorded bool
from line 1681
17131681 case "bash":
17141682 output, isError = handleBashBlock(ctx, toolUse)
17151683 default:
1716 output, isError = fmt.Sprintf("unknown tool: %s", toolUse.Name), true
1684 output, isError = "unknown tool: "+toolUse.Name, true
17171685 }
17181686 toolResults = append(toolResults, anthropic.NewToolResultBlock(toolUse.ID, output, isError))
17191687 }
from line 1696
17281696 ```
17291697
17301698 ```java Java
1699 static final String SUBAGENT_SYSTEM = """
1700 You are one agent in a larger parallel fan-out, assigned a single subtask. \
1701 Investigate it directly, using bash to check facts rather than guessing, and finish \
1702 by calling report_findings exactly once. Return findings, not narration.""";
1703
17311704 // One subagent: a small nested agent loop with the bash tool plus report_findings.
17321705 // Subagents inherit the main loop's effort level.
17331706 String runSubagent(Model model, String prompt) throws InterruptedException {
1734 String subagentSystem = "You are one agent in a larger parallel fan-out, assigned a single subtask. "
1735 + "Investigate it directly, using bash to check facts rather than guessing, and finish "
1736 + "by calling report_findings exactly once. Return findings, not narration.";
17371707 List<MessageParam> messages = new ArrayList<>();
17381708 messages.add(MessageParam.builder().role(MessageParam.Role.USER).content(prompt).build());
17391709 for (int turn = 0; turn < MAX_SUBAGENT_TURNS; turn++) {
17401710 MessageCreateParams params = MessageCreateParams.builder()
17411711 .model(model)
17421712 .maxTokens(64000L)
1743 .system(subagentSystem)
1713 .system(SUBAGENT_SYSTEM)
17441714 .outputConfig(OutputConfig.builder().effort(EFFORT).build())
17451715 .addTool(BASH_TOOL)
17461716 .addTool(REPORT_TOOL)
from line 1736
17661736 }
17671737 return text;
17681738 }
1739 List<ToolUseBlock> toolUses = response.content().stream()
1740 .flatMap(block -> block.toolUse().stream())
1741 .toList();
17691742 List<ContentBlockParam> toolResults = new ArrayList<>();
17701743 String report = null;
1771 for (ContentBlock block : response.content()) {
1772 if (block.toolUse().isEmpty()) {
1773 continue;
1774 }
1775 ToolUseBlock toolUse = block.toolUse().get();
1776 ToolOutput result;
1777 if (toolUse.name().equals("report_findings")) {
1778 report = toolUse._input().convert(JsonNode.class).toPrettyString();
1779 result = new ToolOutput("Findings recorded.", false);
1780 } else if (toolUse.name().equals("bash")) {
1781 result = handleBashBlock(toolUse);
1782 } else {
1783 result = new ToolOutput("unknown tool: " + toolUse.name(), true);
1784 }
1744 for (ToolUseBlock toolUse : toolUses) {
1745 ToolOutput result = switch (toolUse.name()) {
1746 case "report_findings" -> {
1747 report = toolUse._input().convert(JsonNode.class).toPrettyString();
1748 yield new ToolOutput("Findings recorded.", false);
1749 }
1750 case "bash" -> handleBashBlock(toolUse);
1751 default -> new ToolOutput("unknown tool: " + toolUse.name(), true);
1752 };
17851753 toolResults.add(ContentBlockParam.ofToolResult(ToolResultBlockParam.builder()
17861754 .toolUseId(toolUse.id())
17871755 .content(result.output())
from line 2041
20732041 // that never finished are recomputed. Delete the journal file to start fresh.
20742042 async Task<string> Journaled(string prompt, Func<Task<string>> compute)
20752043 {
2076 var key = Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes(prompt))).ToLowerInvariant();
2044 var key = Convert.ToHexStringLower(SHA256.HashData(Encoding.UTF8.GetBytes(prompt)));
20772045 if ((await LoadJournal()).TryGetValue(key, out var cached))
20782046 {
20792047 Console.Error.WriteLine($"[journal] cache hit for {key[..12]}");
from line 2125
21572125 return Objects.requireNonNullElseGet(
21582126 JOURNAL_MAPPER.readValue(Files.readString(JOURNAL_PATH), new TypeReference<HashMap<String, String>>() {}),
21592127 HashMap::new);
2160 } catch (IOException error) {
2128 } catch (IOException _) {
21612129 return new HashMap<>();
21622130 }
21632131 }
from line 2258
22902258 "that contradicts them. Default to refuted if uncertain. Call report_findings with "
22912259 "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command "
22922260 "output that decided it.\n\n"
2293 f"Subtask: {subtask}\n\nResult to verify:\n{result}"
2261 f"""Subtask: {subtask}
2262
2263 Result to verify:
2264 {result}"""
22942265 )
22952266
22962267
from line 2289
23182289 verdicts = list(pool.map(run_one, verify_prompts))
23192290
23202291 joined = "\n\n".join(
2321 f"[agent {index + 1}: {task}]\n{result}\n\n[verify {index + 1}]\n{verdict}"
2292 f"""[agent {index + 1}: {task}]
2293 {result}
2294
2295 [verify {index + 1}]
2296 {verdict}"""
23222297 for index, (task, result, verdict) in enumerate(zip(subtasks, results, verdicts))
23232298 )
23242299 if dropped > 0:
from line 2326
23512326 }
23522327
23532328 function verifyPromptFor(subtask: string, result: string): string {
2354 return (
2329 const instructions =
23552330 "Adversarially verify the subagent result below: try to REFUTE it. Re-derive the " +
23562331 "claims yourself with bash rather than trusting the result, and look for evidence " +
23572332 "that contradicts them. Default to refuted if uncertain. Call report_findings with " +
23582333 "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command " +
2359 "output that decided it.\n\n" +
2360 `Subtask: ${subtask}\n\nResult to verify:\n${result}`
2361 );
2334 "output that decided it.";
2335 return `${instructions}
2336
2337 Subtask: ${subtask}
2338
2339 Result to verify:
2340 ${result}`;
23622341 }
23632342
23642343 // Map with a concurrency limit: at most `limit` tasks are in flight at once.
from line 2361
23822361 // Run subtasks as parallel subagents, then run a second verification wave over
23832362 // the results, and return both. MAX_TOTAL_SUBTASKS bounds how many the model can
23842363 // queue; MAX_CONCURRENT bounds how many run at once.
2385 async function runWorkflow(
2386 model: string,
2387 rawSubtasks: unknown,
2388 ): Promise<{ output: string; isError: boolean }> {
2364 async function runWorkflow(model: string, rawSubtasks: unknown): Promise<ToolOutcome> {
23892365 const allSubtasks = normalizeSubtasks(rawSubtasks);
23902366 const subtasks = allSubtasks.slice(0, MAX_TOTAL_SUBTASKS);
23912367 const dropped = allSubtasks.length - subtasks.length;
from line 2385
24092385 const verifyPrompts = subtasks.map((task, index) => verifyPromptFor(task, results[index]));
24102386 const verdicts = await mapWithLimit(verifyPrompts, MAX_CONCURRENT, runOne);
24112387
2412 let joined = subtasks
2388 const report = subtasks
24132389 .map(
2414 (task, index) =>
2415 `[agent ${index + 1}: ${task}]\n${results[index]}\n\n[verify ${index + 1}]\n${verdicts[index]}`,
2390 (task, index) => `[agent ${index + 1}: ${task}]
2391 ${results[index]}
2392
2393 [verify ${index + 1}]
2394 ${verdicts[index]}`,
24162395 )
24172396 .join("\n\n");
2418 if (dropped > 0) {
2419 joined =
2420 `(note: ${dropped} subtasks beyond MAX_TOTAL_SUBTASKS=${MAX_TOTAL_SUBTASKS} were not ` +
2421 "run; rerun them in a follow-up Workflow call)\n\n" +
2422 joined;
2423 }
2424 return { output: joined, isError: false };
2397 const droppedNote =
2398 dropped > 0
2399 ? `(note: ${dropped} subtasks beyond MAX_TOTAL_SUBTASKS=${MAX_TOTAL_SUBTASKS} were ` +
2400 "not run; rerun them in a follow-up Workflow call)\n\n"
2401 : "";
2402 return { output: droppedNote + report, isError: false };
24252403 }
24262404 ```
24272405
from line 2408
24302408 // JSON-encoded as a single string, or a newline-separated list.
24312409 List<string> NormalizeSubtasks(JsonElement raw)
24322410 {
2433 List<string> tasks = [];
2434 if (raw.ValueKind == JsonValueKind.Array)
2411 IEnumerable<string?> tasks = raw.ValueKind switch
24352412 {
2436 tasks = raw.EnumerateArray()
2413 JsonValueKind.Array => raw.EnumerateArray()
24372414 .Where(item => item.ValueKind == JsonValueKind.String)
2438 .Select(item => item.GetString()!)
2439 .ToList();
2440 }
2441 else if (raw.ValueKind == JsonValueKind.String)
2415 .Select(item => item.GetString()),
2416 JsonValueKind.String => ParseSubtaskString(raw.GetString()!),
2417 _ => [],
2418 };
2419 return [.. tasks.OfType<string>().Select(task => task.Trim()).Where(task => task.Length > 0)];
2420 }
2421
2422 IEnumerable<string?> ParseSubtaskString(string single)
2423 {
2424 try
24422425 {
2443 var single = raw.GetString()!;
2444 try
2445 {
2446 tasks = JsonSerializer.Deserialize<List<string>>(single) ?? [];
2447 }
2448 catch (JsonException)
2449 {
2450 tasks = [.. single.Split('\n')];
2451 }
2452 }
2453 return tasks.Where(task => task != null).Select(task => task.Trim()).Where(task => task.Length > 0).ToList();
2454 }
2455
2456 string VerifyPromptFor(string subtask, string result) =>
2457 "Adversarially verify the subagent result below: try to REFUTE it. Re-derive the "
2458 + "claims yourself with bash rather than trusting the result, and look for evidence "
2459 + "that contradicts them. Default to refuted if uncertain. Call report_findings with "
2460 + "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command "
2461 + "output that decided it.\n\n"
2462 + $"Subtask: {subtask}\n\nResult to verify:\n{result}";
2426 return JsonSerializer.Deserialize<List<string?>>(single) ?? [];
2427 }
2428 catch (JsonException)
2429 {
2430 return single.Split('\n');
2431 }
2432 }
2433
2434 string VerifyPromptFor(string subtask, string result) => $"""
2435 Adversarially verify the subagent result below: try to REFUTE it. Re-derive the claims yourself with bash rather than trusting the result, and look for evidence that contradicts them. Default to refuted if uncertain. Call report_findings with summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command output that decided it.
2436
2437 Subtask: {subtask}
2438
2439 Result to verify:
2440 {result}
2441 """;
24632442
24642443 // Run subtasks as parallel subagents, then run a second verification wave over
24652444 // the results, and return both. maxTotalSubtasks bounds how many the model can
from line 2446
24672446 async Task<(string Output, bool IsError)> RunWorkflow(JsonElement rawSubtasks)
24682447 {
24692448 var allSubtasks = NormalizeSubtasks(rawSubtasks);
2470 var subtasks = allSubtasks.Take(maxTotalSubtasks).ToList();
2449 List<string> subtasks = [.. allSubtasks.Take(maxTotalSubtasks)];
24712450 var dropped = allSubtasks.Count - subtasks.Count;
24722451 if (subtasks.Count == 0)
24732452 {
from line 2475
24962475
24972476 var results = await Task.WhenAll(subtasks.Select(RunOne));
24982477 Console.Error.WriteLine($"[workflow] verifying {results.Length} results");
2499 var verifyPrompts = subtasks.Select((task, index) => VerifyPromptFor(task, results[index])).ToList();
2500 var verdicts = await Task.WhenAll(verifyPrompts.Select(RunOne));
2501
2502 var joined = string.Join(
2503 "\n\n",
2504 subtasks.Select((task, index) =>
2505 $"[agent {index + 1}: {task}]\n{results[index]}\n\n[verify {index + 1}]\n{verdicts[index]}"));
2478 var verdicts = await Task.WhenAll(subtasks.Zip(results, VerifyPromptFor).Select(RunOne));
2479
2480 var joined = string.Join("\n\n", subtasks.Select((task, index) => $"""
2481 [agent {index + 1}: {task}]
2482 {results[index]}
2483
2484 [verify {index + 1}]
2485 {verdicts[index]}
2486 """));
25062487 if (dropped > 0)
25072488 {
2508 joined = $"(note: {dropped} subtasks beyond maxTotalSubtasks={maxTotalSubtasks} were not run; "
2509 + "rerun them in a follow-up Workflow call)\n\n" + joined;
2489 joined = $"""
2490 (note: {dropped} subtasks beyond maxTotalSubtasks={maxTotalSubtasks} were not run; rerun them in a follow-up Workflow call)
2491
2492 {joined}
2493 """;
25102494 }
25112495 return (joined, false);
25122496 }
from line 2525
25412525 "that contradicts them. Default to refuted if uncertain. Call report_findings with " +
25422526 "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command " +
25432527 "output that decided it.\n\n" +
2544 "Subtask: " + subtask + "\n\nResult to verify:\n" + result
2528 fmt.Sprintf(`Subtask: %s
2529
2530 Result to verify:
2531 %s`, subtask, result)
25452532 }
25462533
25472534 // mapWithLimit runs task over items with at most limit goroutines in flight.
from line 2537
25502537 semaphore := make(chan struct{}, limit)
25512538 var waitGroup sync.WaitGroup
25522539 for index, item := range items {
2553 waitGroup.Add(1)
25542540 semaphore <- struct{}{}
2555 go func() {
2556 defer waitGroup.Done()
2541 waitGroup.Go(func() {
25572542 defer func() { <-semaphore }()
25582543 results[index] = task(item)
2559 }()
2544 })
25602545 }
25612546 waitGroup.Wait()
25622547 return results
from line 2552
25672552 // queue; maxConcurrent bounds how many run at once.
25682553 func runWorkflow(ctx context.Context, model string, rawSubtasks json.RawMessage) (string, bool) {
25692554 allSubtasks := normalizeSubtasks(rawSubtasks)
2570 subtasks := allSubtasks
2571 if len(subtasks) > maxTotalSubtasks {
2572 subtasks = subtasks[:maxTotalSubtasks]
2573 }
2555 subtasks := allSubtasks[:min(len(allSubtasks), maxTotalSubtasks)]
25742556 dropped := len(allSubtasks) - len(subtasks)
25752557 if len(subtasks) == 0 {
25762558 return "Workflow error: no usable subtasks were provided.", true
from line 2578
25962578
25972579 sections := make([]string, len(subtasks))
25982580 for index, task := range subtasks {
2599 sections[index] = fmt.Sprintf("[agent %d: %s]\n%s\n\n[verify %d]\n%s",
2581 sections[index] = fmt.Sprintf(`[agent %d: %s]
2582 %s
2583
2584 [verify %d]
2585 %s`,
26002586 index+1, task, results[index], index+1, verdicts[index])
26012587 }
26022588 joined := strings.Join(sections, "\n\n")
from line 2598
26122598 ```java Java
26132599 // Accept the subtasks input in whatever shape the model emits: an array, the array
26142600 // JSON-encoded as a single string, or a newline-separated list.
2615 List<String> normalizeSubtasks(JsonValue raw) {
2616 List<String> tasks = new ArrayList<>();
2617 if (raw.asArray().isPresent()) {
2618 for (JsonValue item : (List<JsonValue>) raw.asArray().get()) {
2619 tasks.add(item.asString().isPresent() ? item.asStringOrThrow() : item.toString());
2620 }
2621 } else if (raw.asString().isPresent()) {
2622 String single = raw.asStringOrThrow();
2623 try {
2624 String[] parsed = new ObjectMapper().readValue(single, String[].class);
2625 if (parsed != null) {
2626 for (String task : parsed) {
2627 tasks.add(task);
2628 }
2629 }
2630 } catch (JsonProcessingException error) {
2631 for (String task : single.split("\n")) {
2632 tasks.add(task);
2633 }
2634 }
2635 }
2601 List<String> normalizeSubtasks(JsonValue rawSubtasks) {
2602 List<String> tasks = switch (rawSubtasks) {
2603 case JsonArray array -> array.values().stream()
2604 .map(item -> item instanceof JsonString text ? text.value() : item.toString())
2605 .toList();
2606 case JsonString string -> parseSubtaskString(string.value());
2607 default -> List.of();
2608 };
26362609 return tasks.stream()
2637 .filter(task -> task != null)
2638 .map(String::trim)
2610 .filter(Objects::nonNull)
2611 .map(String::strip)
26392612 .filter(task -> !task.isEmpty())
26402613 .toList();
26412614 }
26422615
2616 List<String> parseSubtaskString(String encoded) {
2617 try {
2618 String[] parsed = new ObjectMapper().readValue(encoded, String[].class);
2619 return parsed == null ? List.of() : Arrays.asList(parsed);
2620 } catch (JsonProcessingException _) {
2621 return encoded.lines().toList();
2622 }
2623 }
2624
26432625 String verifyPromptFor(String subtask, String result) {
2644 return "Adversarially verify the subagent result below: try to REFUTE it. Re-derive the "
2645 + "claims yourself with bash rather than trusting the result, and look for evidence "
2646 + "that contradicts them. Default to refuted if uncertain. Call report_findings with "
2647 + "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command "
2648 + "output that decided it.\n\n"
2649 + "Subtask: " + subtask + "\n\nResult to verify:\n" + result;
2650 }
2651
2626 return """
2627 Adversarially verify the subagent result below: try to REFUTE it. Re-derive the \
2628 claims yourself with bash rather than trusting the result, and look for evidence \
2629 that contradicts them. Default to refuted if uncertain. Call report_findings with \
2630 summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command \
2631 output that decided it.
2632
2633 Subtask: %s
2634
2635 Result to verify:
2636 %s""".formatted(subtask, result);
2637 }
2638
2639 // invokeAll waits for every job, so each future is finished when it is read here.
26522640 List<String> runAll(ExecutorService pool, List<String> prompts, Model model) throws InterruptedException {
26532641 List<Callable<String>> jobs = prompts.stream()
26542642 .<Callable<String>>map(prompt -> () -> journaled(prompt, () -> runSubagent(model, prompt)))
26552643 .toList();
2656 List<String> results = new ArrayList<>();
2657 for (Future<String> future : pool.invokeAll(jobs)) {
2658 try {
2659 results.add(future.get());
2660 } catch (ExecutionException | CancellationException error) {
2661 // Isolation boundary: one bad subagent should not end the run.
2662 Throwable cause = error.getCause() != null ? error.getCause() : error;
2663 results.add("(subagent failed: " + cause + ")");
2664 }
2665 }
2666 return results;
2644 return pool.invokeAll(jobs).stream()
2645 .map(future -> switch (future.state()) {
2646 case SUCCESS -> future.resultNow();
2647 // Isolation boundary: one bad subagent should not end the run.
2648 case FAILED -> "(subagent failed: " + future.exceptionNow() + ")";
2649 case CANCELLED, RUNNING -> "(subagent failed: cancelled)";
2650 })
2651 .toList();
26672652 }
26682653
26692654 // Run subtasks as parallel subagents, then run a second verification wave over
from line 2674
26892674 verdicts = runAll(pool, verifyPrompts, model);
26902675 }
26912676 String joined = IntStream.range(0, subtasks.size())
2692 .mapToObj(index -> "[agent " + (index + 1) + ": " + subtasks.get(index) + "]\n" + results.get(index)
2693 + "\n\n[verify " + (index + 1) + "]\n" + verdicts.get(index))
2677 .mapToObj(index -> """
2678 [agent %d: %s]
2679 %s
2680
2681 [verify %d]
2682 %s""".formatted(index + 1, subtasks.get(index), results.get(index), index + 1, verdicts.get(index)))
26942683 .collect(Collectors.joining("\n\n"));
26952684 if (dropped > 0) {
2696 joined = "(note: " + dropped + " subtasks beyond MAX_TOTAL_SUBTASKS=" + MAX_TOTAL_SUBTASKS
2697 + " were not run; rerun them in a follow-up Workflow call)\n\n" + joined;
2685 joined = """
2686 (note: %d subtasks beyond MAX_TOTAL_SUBTASKS=%d were not run; rerun them in a follow-up Workflow call)
2687
2688 %s""".formatted(dropped, MAX_TOTAL_SUBTASKS, joined);
26982689 }
26992690 return new ToolOutput(joined, false);
27002691 }
from line 2719
27282719 . 'that contradicts them. Default to refuted if uncertain. Call report_findings with '
27292720 . "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command "
27302721 . "output that decided it.\n\n"
2731 . "Subtask: {$subtask}\n\nResult to verify:\n{$result}";
2722 . <<<PROMPT
2723 Subtask: {$subtask}
2724
2725 Result to verify:
2726 {$result}
2727 PROMPT;
27322728 }
27332729
27342730 /**
from line 2791
27952791 "claims yourself with bash rather than trusting the result, and look for evidence " \
27962792 "that contradicts them. Default to refuted if uncertain. Call report_findings with " \
27972793 "summary 'refuted: <why>' or 'confirmed: <why>', citing the file:line or command " \
2798 "output that decided it.\n\n" \
2799 "Subtask: #{subtask}\n\nResult to verify:\n#{result}"
2794 "output that decided it.\n\n" +
2795 <<~PROMPT.chomp
2796 Subtask: #{subtask}
2797
2798 Result to verify:
2799 #{result}
2800 PROMPT
28002801 end
28012802
28022803 # Map with a concurrency limit: at most `limit` threads are in flight at once.
from line 2839
28382839 verdicts = map_with_limit(verify_prompts, MAX_CONCURRENT, &run_one)
28392840
28402841 joined = subtasks.each_with_index.map do |task, index|
2841 "[agent #{index + 1}: #{task}]\n#{results[index]}\n\n[verify #{index + 1}]\n#{verdicts[index]}"
2842 <<~ENTRY.chomp
2843 [agent #{index + 1}: #{task}]
2844 #{results[index]}
2845
2846 [verify #{index + 1}]
2847 #{verdicts[index]}
2848 ENTRY
28422849 end.join("\n\n")
28432850 if dropped > 0
28442851 joined =
from line 3025
30183025 if response.stop_reason != "tool_use":
30193026 text = "".join(block.text for block in response.content if block.type == "text")
30203027 if response.stop_reason == "max_tokens":
3021 # Drop the truncated assistant message so later turns don't build on it.
3028 # Drop the truncated assistant message so later turns do not build on it.
30223029 self.messages.pop()
30233030 text += "\n\n(warning: response was truncated at max_tokens)"
30243031 return text
from line 3056
30493056 ```typescript TypeScript
30503057 // An agent loop whose orchestration mode is toggled with mid-conversation system messages.
30513058 class ModeAgent {
3052 private readonly model: string;
3053 private modeOn: boolean;
3054 private readonly messages: Anthropic.MessageParam[] = [];
3055 private modeAnnounced = false;
3056 private exitPending = false;
3057 private turnsSinceReminder = 0;
3059 readonly #model: string;
3060 readonly #messages: Anthropic.MessageParam[] = [];
3061 #modeOn: boolean;
3062 #modeAnnounced = false;
3063 #exitPending = false;
3064 #turnsSinceReminder = 0;
30583065
30593066 constructor(model: string, modeOn = true) {
3060 this.model = model;
3061 this.modeOn = modeOn;
3067 this.#model = model;
3068 this.#modeOn = modeOn;
30623069 }
30633070
30643071 // Turn the mode on or off. The notice is delivered with the next user turn.
30653072 setMode(modeOn: boolean): void {
3066 if (modeOn === this.modeOn) {
3073 if (modeOn === this.#modeOn) {
30673074 return;
30683075 }
3069 if (!modeOn) {
3070 if (this.modeAnnounced) {
3071 this.exitPending = true;
3072 }
3073 } else {
3074 this.exitPending = false;
3075 }
3076 this.modeOn = modeOn;
3076 // An exit notice is only owed if the model was told the mode was on.
3077 this.#exitPending = !modeOn && this.#modeAnnounced;
3078 this.#modeOn = modeOn;
30773079 }
30783080
30793081 // System messages owed on this turn: an exit notice, the full mode text on entry,
30803082 // or a one-line refresher every TURNS_BETWEEN_REFRESHERS user turns.
3081 private dueSystemMessages(): Anthropic.MessageParam[] {
3082 const due: Array<{ role: "system"; content: string }> = [];
3083 if (this.exitPending) {
3084 this.exitPending = false;
3085 this.modeAnnounced = false;
3083 #dueSystemMessages(): Anthropic.MessageParam[] {
3084 const due: Anthropic.MessageParam[] = [];
3085 if (this.#exitPending) {
3086 this.#exitPending = false;
3087 this.#modeAnnounced = false;
30863088 due.push({ role: "system", content: MODE_EXIT });
30873089 }
3088 if (this.modeOn) {
3089 if (!this.modeAnnounced) {
3090 this.modeAnnounced = true;
3091 this.turnsSinceReminder = 0;
3090 if (this.#modeOn) {
3091 if (!this.#modeAnnounced) {
3092 this.#modeAnnounced = true;
3093 this.#turnsSinceReminder = 0;
30923094 due.push({ role: "system", content: MODE_ENTER });
3093 } else if (this.turnsSinceReminder >= TURNS_BETWEEN_REFRESHERS) {
3094 this.turnsSinceReminder = 0;
3095 } else if (this.#turnsSinceReminder >= TURNS_BETWEEN_REFRESHERS) {
3096 this.#turnsSinceReminder = 0;
30953097 due.push({ role: "system", content: MODE_REFRESH });
30963098 }
30973099 }
3098 // The published SDK types message roles as "user" | "assistant"; typed support for
3099 // mid-conversation system messages ships with the SDK release that includes them.
3100 return due as unknown as Anthropic.MessageParam[];
3100 return due;
31013101 }
31023102
31033103 async turn(userInput: string): Promise<string> {
31043104 // Mid-conversation system messages follow the user turn they apply to, which keeps
31053105 // the cached prefix ahead of them untouched.
3106 this.messages.push({ role: "user", content: userInput });
3107 this.messages.push(...this.dueSystemMessages());
3108 this.turnsSinceReminder += 1;
3106 this.#messages.push({ role: "user", content: userInput }, ...this.#dueSystemMessages());
3107 this.#turnsSinceReminder += 1;
31093108
31103109 for (let turn = 0; turn < MAX_MAIN_TURNS; turn++) {
31113110 const response = await client.messages
31123111 .stream(
31133112 {
3114 model: this.model,
3113 model: this.#model,
31153114 max_tokens: 64000,
31163115 system: SYSTEM_PROMPT, // static for the whole session
31173116 output_config: { effort: EFFORT },
31183117 tools: [WORKFLOW_TOOL, BASH_TOOL],
3119 messages: this.messages,
3118 messages: this.#messages,
31203119 },
31213120 { signal: AbortSignal.timeout(REQUEST_TIMEOUT_SECONDS * 1000) },
31223121 )
31233122 .finalMessage();
3124 this.messages.push({ role: "assistant", content: response.content });
3123 this.#messages.push({ role: "assistant", content: response.content });
31253124
31263125 if (response.stop_reason === "pause_turn") {
31273126 continue;
31283127 }
31293128 if (response.stop_reason !== "tool_use") {
31303129 let text = response.content
3131 .filter((block): block is Anthropic.TextBlock => block.type === "text")
3132 .map((block) => block.text)
3130 .flatMap((block) => (block.type === "text" ? [block.text] : []))
31333131 .join("");
31343132 if (response.stop_reason === "max_tokens") {
31353133 // Drop the truncated assistant message so later turns do not build on it.
3136 this.messages.pop();
3134 this.#messages.pop();
31373135 text += "\n\n(warning: response was truncated at max_tokens)";
31383136 }
31393137 return text;
from line 3142
31443142 if (block.type !== "tool_use") {
31453143 continue;
31463144 }
3147 let output: string;
3148 let isError: boolean;
3145 let outcome: ToolOutcome;
31493146 switch (block.name) {
31503147 case "Workflow": {
3151 const input = block.input as { subtasks?: unknown };
3152 ({ output, isError } = await runWorkflow(this.model, input.subtasks ?? []));
3148 const { subtasks } = block.input as { subtasks?: unknown };
3149 outcome = await runWorkflow(this.#model, subtasks);
31533150 break;
31543151 }
31553152 case "bash":
3156 ({ output, isError } = await handleBashBlock(block));
3153 outcome = await handleBashBlock(block);
31573154 break;
31583155 default:
3159 output = `unknown tool: ${block.name}`;
3160 isError = true;
3156 outcome = { output: `unknown tool: ${block.name}`, isError: true };
31613157 }
31623158 toolResults.push({
31633159 type: "tool_result",
31643160 tool_use_id: block.id,
3165 content: output,
3166 is_error: isError,
3161 content: outcome.output,
3162 is_error: outcome.isError,
31673163 });
31683164 }
3169 this.messages.push({ role: "user", content: toolResults });
3165 this.#messages.push({ role: "user", content: toolResults });
31703166 }
31713167 return "(hit the main loop turn limit before finishing)";
31723168 }
from line 3184
31883184 {
31893185 return;
31903186 }
3191 if (!nextModeOn)
3192 {
3193 if (modeAnnounced)
3194 {
3195 exitPending = true;
3196 }
3197 }
3198 else
3199 {
3200 exitPending = false;
3201 }
3187 // An exit notice is owed only if the model was told the mode was on.
3188 exitPending = !nextModeOn && modeAnnounced;
32023189 modeOn = nextModeOn;
32033190 }
32043191
3205 // The Role property is an open enum, so the mid-conversation "system" role can be assigned
3206 // as a raw string; a dedicated constant ships with the SDK release.
3207 MessageParam SystemMessage(string content) => new() { Role = "system", Content = content };
3192 MessageParam SystemMessage(string content) => new() { Role = Role.System, Content = content };
32083193
32093194 // System messages owed on this turn: an exit notice, the full mode text on entry,
32103195 // or a one-line refresher every turnsBetweenRefreshers user turns.
from line 3231
32463231 for (var turn = 0; turn < maxMainTurns; turn++)
32473232 {
32483233 using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(requestTimeoutSeconds));
3249 var response = await client.Messages.Create(new MessageCreateParams
3234 var response = await client.Messages.CreateStreaming(new MessageCreateParams
32503235 {
32513236 Model = model,
3252 MaxTokens = requestMaxTokens,
3237 MaxTokens = 64000,
32533238 System = systemPrompt, // static for the whole session
32543239 OutputConfig = new OutputConfig { Effort = effort },
32553240 Tools = [workflowTool, bashTool],
32563241 Messages = messages,
3257 }, cancellationToken: deadline.Token);
3242 }, cancellationToken: deadline.Token).Aggregate();
32583243 messages.Add(new()
32593244 {
32603245 Role = Role.Assistant,
from line 3256
32713256 response.Content.Select(block => block.TryPickText(out var textBlock) ? textBlock.Text : ""));
32723257 if (response.StopReason == StopReason.MaxTokens)
32733258 {
3274 // Drop the truncated assistant message so the next turn does not build on it.
3259 // Drop the truncated assistant message so later turns do not build on it.
32753260 messages.RemoveAt(messages.Count - 1);
32763261 text += "\n\n(warning: response was truncated at max_tokens)";
32773262 }
from line 3270
32853270 {
32863271 continue;
32873272 }
3288 string output;
3289 bool isError;
3290 if (toolUse.Name == "Workflow")
3273 var (output, isError) = toolUse.Name switch
32913274 {
3292 toolUse.Input.TryGetValue("subtasks", out var rawSubtasks);
3293 (output, isError) = await RunWorkflow(rawSubtasks);
3294 }
3295 else if (toolUse.Name == "bash")
3296 {
3297 (output, isError) = await HandleBashBlock(toolUse);
3298 }
3299 else
3300 {
3301 output = $"unknown tool: {toolUse.Name}";
3302 isError = true;
3303 }
3275 "Workflow" => await RunWorkflow(toolUse.Input.GetValueOrDefault("subtasks")),
3276 "bash" => await HandleBashBlock(toolUse),
3277 _ => ($"unknown tool: {toolUse.Name}", true),
3278 };
33043279 toolResults.Add(new ToolResultBlockParam(toolUse.ID) { Content = output, IsError = isError });
33053280 }
33063281 messages.Add(new() { Role = Role.User, Content = toolResults });
from line 3318
33433318 // dueSystemMessages returns the system messages owed on this turn: an exit notice, the
33443319 // full mode text on entry, or a one-line refresher every turnsBetweenRefreshers user turns.
33453320 func (agent *modeAgent) dueSystemMessages() []anthropic.MessageParam {
3346 // MessageParamRole is an open string type, so the mid-conversation "system" role can
3347 // be expressed directly; a dedicated constant ships with the SDK release.
33483321 systemMessage := func(content string) anthropic.MessageParam {
33493322 return anthropic.MessageParam{
3350 Role: anthropic.MessageParamRole("system"),
3323 Role: anthropic.MessageParamRoleSystem,
33513324 Content: []anthropic.ContentBlockParamUnion{anthropic.NewTextBlock(content)},
33523325 }
33533326 }
from line 3352
33793352 agent.turnsSinceReminder++
33803353
33813354 for range maxMainTurns {
3382 var response anthropic.Message
3383 err := func() error {
3384 ctx, cancel := context.WithTimeout(ctx, requestTimeoutSeconds*time.Second)
3385 defer cancel()
3386 stream := client.Messages.NewStreaming(ctx, anthropic.MessageNewParams{
3387 Model: agent.model,
3388 MaxTokens: 64000,
3389 System: []anthropic.TextBlockParam{{Text: systemPrompt}}, // static for the whole session
3390 OutputConfig: anthropic.OutputConfigParam{Effort: effort},
3391 Tools: []anthropic.ToolUnionParam{workflowTool, bashTool},
3392 Messages: agent.messages,
3393 })
3394 defer stream.Close()
3395 for stream.Next() {
3396 if err := response.Accumulate(stream.Current()); err != nil {
3397 return err
3398 }
3399 }
3400 return stream.Err()
3401 }()
3355 response, err := streamMessage(ctx, anthropic.MessageNewParams{
3356 Model: agent.model,
3357 MaxTokens: 64000,
3358 System: []anthropic.TextBlockParam{{Text: systemPrompt}}, // static for the whole session
3359 OutputConfig: anthropic.OutputConfigParam{Effort: effort},
3360 Tools: []anthropic.ToolUnionParam{workflowTool, bashTool},
3361 Messages: agent.messages,
3362 })
34023363 if err != nil {
34033364 return "", err
34043365 }
34053366 agent.messages = append(agent.messages, response.ToParam())
34063367
3407 if response.StopReason == anthropic.StopReasonPauseTurn {
3368 switch response.StopReason {
3369 case anthropic.StopReasonPauseTurn:
34083370 continue
3409 }
3410 if response.StopReason != anthropic.StopReasonToolUse {
3411 var text strings.Builder
3412 for _, block := range response.Content {
3413 if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
3414 text.WriteString(textBlock.Text)
3415 }
3416 }
3417 if response.StopReason == anthropic.StopReasonMaxTokens {
3418 // Drop the truncated assistant message rather than leave a clipped turn in history.
3419 agent.messages = agent.messages[:len(agent.messages)-1]
3420 text.WriteString("\n\n(warning: response was truncated at max_tokens)")
3421 }
3422 return text.String(), nil
3371 case anthropic.StopReasonMaxTokens:
3372 // Drop the truncated assistant message so later turns do not build on it.
3373 agent.messages = agent.messages[:len(agent.messages)-1]
3374 return textOf(response) + "\n\n(warning: response was truncated at max_tokens)", nil
3375 case anthropic.StopReasonToolUse:
3376 default:
3377 return textOf(response), nil
34233378 }
34243379
34253380 var toolResults []anthropic.ContentBlockParamUnion
from line 3398
34433398 case "bash":
34443399 output, isError = handleBashBlock(ctx, toolUse)
34453400 default:
3446 output, isError = fmt.Sprintf("unknown tool: %s", toolUse.Name), true
3401 output, isError = "unknown tool: "+toolUse.Name, true
34473402 }
34483403 toolResults = append(toolResults, anthropic.NewToolResultBlock(toolUse.ID, output, isError))
34493404 }
from line 3413
34583413 // An agent loop whose orchestration mode is toggled with mid-conversation system messages.
34593414 class ModeAgent {
34603415 private final Model model;
3416 private final List<MessageParam> messages = new ArrayList<>();
34613417 private boolean modeOn;
3462 private final List<MessageParam> messages = new ArrayList<>();
3463 private boolean modeAnnounced = false;
3464 private boolean exitPending = false;
3465 private int turnsSinceReminder = 0;
3418 private boolean modeAnnounced;
3419 private boolean exitPending;
3420 private int turnsSinceReminder;
34663421
34673422 ModeAgent(Model model) {
34683423 this(model, true);
from line 3428
34733428 this.modeOn = modeOn;
34743429 }
34753430
3476 // Turn the mode on or off. The notice is delivered with the next user turn.
3431 // Turn the mode on or off. The notice is delivered with the next user turn:
3432 // an exit notice is owed only if the model was told the mode was on.
34773433 void setMode(boolean modeOn) {
34783434 if (modeOn == this.modeOn) {
34793435 return;
34803436 }
3481 if (!modeOn) {
3482 if (modeAnnounced) {
3483 exitPending = true;
3484 }
3485 } else {
3486 exitPending = false;
3487 }
3437 exitPending = !modeOn && modeAnnounced;
34883438 this.modeOn = modeOn;
34893439 }
34903440
from line 3460
35103460 return due;
35113461 }
35123462
3513 // MessageParam.Role is an open enum, so the mid-conversation "system" role can be
3514 // expressed with Role.of; a dedicated constant ships with the SDK release.
35153463 private MessageParam systemMessage(String content) {
35163464 return MessageParam.builder()
3517 .role(MessageParam.Role.of("system"))
3465 .role(MessageParam.Role.SYSTEM)
35183466 .content(content)
35193467 .build();
35203468 }
from line 3502
35543502 .map(TextBlock::text)
35553503 .collect(Collectors.joining());
35563504 if (StopReason.MAX_TOKENS.equals(stopReason)) {
3557 // Drop the truncated assistant message so it does not poison later turns.
3505 // Drop the truncated assistant message so later turns do not build on it.
35583506 messages.removeLast();
35593507 text += "\n\n(warning: response was truncated at max_tokens)";
35603508 }
35613509 return text;
35623510 }
35633511
3512 List<ToolUseBlock> toolUses = response.content().stream()
3513 .flatMap(block -> block.toolUse().stream())
3514 .toList();
35643515 List<ContentBlockParam> toolResults = new ArrayList<>();
3565 for (ContentBlock block : response.content()) {
3566 if (block.toolUse().isEmpty()) {
3567 continue;
3568 }
3569 ToolUseBlock toolUse = block.toolUse().get();
3516 for (ToolUseBlock toolUse : toolUses) {
35703517 ToolOutput result = switch (toolUse.name()) {
3571 case "Workflow" -> {
3572 Map<String, JsonValue> input =
3573 (Map<String, JsonValue>) toolUse._input().asObject().orElse(Map.of());
3574 JsonValue rawSubtasks = input.getOrDefault("subtasks", JsonValue.from(List.of()));
3575 yield runWorkflow(model, rawSubtasks);
3576 }
3518 case "Workflow" -> runWorkflow(model,
3519 toolInput(toolUse).getOrDefault("subtasks", JsonValue.from(List.of())));
35773520 case "bash" -> handleBashBlock(toolUse);
35783521 default -> new ToolOutput("unknown tool: " + toolUse.name(), true);
35793522 };
from line 3598
36553598 }
36563599 }
36573600 if ($stopReason === 'max_tokens') {
3658 // Drop the truncated assistant message so the next turn does not build on it.
3601 // Drop the truncated assistant message so later turns do not build on it.
36593602 array_pop($this->messages);
36603603 $text .= "\n\n(warning: response was truncated at max_tokens)";
36613604 }
from line 3707
37643707 unless response.stop_reason == :tool_use
37653708 text = response.content.select { |block| block.type == :text }.map(&:text).join
37663709 if response.stop_reason == :max_tokens
3767 @messages.pop # drop the truncated assistant message from the history
3710 # Drop the truncated assistant message so later turns do not build on it.
3711 @messages.pop
37683712 text += "\n\n(warning: response was truncated at max_tokens)"
37693713 end
37703714 return text
from line 3844
39003844
39013845 ```java Java
39023846 void main(String[] args) throws InterruptedException {
3903 String task = args.length > 0
3904 ? args[0]
3905 : "Explore the current directory, then give a thorough review: what it does, "
3906 + "code-quality issues, and concrete improvements.";
3847 String task = args.length > 0 ? args[0] : """
3848 Explore the current directory, then give a thorough review: what it does, \
3849 code-quality issues, and concrete improvements.""";
39073850 ModeAgent agent = new ModeAgent(MODEL);
39083851 IO.println(agent.turn(task));
39093852 agent.setMode(false);
39103853
No line in this hunk matches that.