The whole hunk
from line 461, old and new numbered
/
lines
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 461
461461 ]
462462 });
463463
464 for await (const event of stream) {
465 if (event.type === "agent.message") {
466 for (const block of event.content) {
467 if (block.type === "text") {
468 process.stdout.write(block.text);
464 events: for await (const event of stream) {
465 switch (event.type) {
466 case "agent.message":
467 for (const block of event.content) {
468 if (block.type === "text") {
469 process.stdout.write(block.text);
470 }
469471 }
470 }
471 } else if (event.type === "session.status_idle") {
472 break;
473 } else if (event.type === "session.error") {
474 console.log(`\n[Error: ${event.error?.message ?? "unknown"}]`);
475 break;
472 break;
473 case "session.status_idle":
474 break events;
475 case "session.error":
476 console.log(`\n[Error: ${event.error?.message ?? "unknown"}]`);
477 break events;
476478 }
477479 }
478480 ```
from line 580
578580 );
579581
580582 Iterable<BetaManagedAgentsStreamSessionEvents> events = stream.stream()::iterator;
583 events:
581584 for (var event : events) {
582 if (event.isAgentMessage()) {
583 event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
584 } else if (event.isSessionStatusIdle()) {
585 break;
586 } else if (event.isSessionError()) {
587 // The `message` field spans all error variants; read it from the raw JSON.
588 var errorMessage =
589 event.asSessionError().error()._json().orElse(null) instanceof JsonObject json
590 ? json.values().get("message").asStringOrThrow()
591 : "unknown";
592 IO.println("\n[Error: " + errorMessage + "]");
593 break;
585 switch (event.type().value()) {
586 case AGENT_MESSAGE -> event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
587 case SESSION_STATUS_IDLE -> {
588 break events;
589 }
590 case SESSION_ERROR -> {
591 // The `message` field spans all error variants; read it from the raw JSON.
592 var errorMessage =
593 event.asSessionError().error()._json().orElse(null) instanceof JsonObject json
594 ? json.values().get("message").asStringOrThrow()
595 : "unknown";
596 IO.println("\n[Error: " + errorMessage + "]");
597 break events;
598 }
594599 }
595600 }
596601 }
from line 615
610615 );
611616
612617 foreach ($stream as $event) {
613 match ($event->type) {
614 'agent.message' => array_walk(
618 match (true) {
619 $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent => array_walk(
615620 $event->content,
616 static fn ($block) => $block->type === 'text' ? print($block->text) : null,
621 static fn ($block) => $block instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock ? print($block->text) : null,
617622 ),
618 'session.error' => printf("\n[Error: %s]", $event->error?->message ?? 'unknown'),
623 $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionErrorEvent => printf("\n[Error: %s]", $event->error?->message ?? 'unknown'),
619624 default => null,
620625 };
621626 if ($event->type === 'session.status_idle' || $event->type === 'session.error') {
from line 643
638643 )
639644
640645 stream.each do |event|
641 case event.type
642 in :"agent.message"
646 case event
647 when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
643648 event.content.each { print it.text }
644 in :"session.status_idle"
649 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
645650 break
646 in :"session.error"
651 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionErrorEvent
647652 puts "\n[Error: #{event.error&.message || "unknown"}]"
648653 break
649654 else
from line 746
741746 }
742747
743748 // Tail live events, skipping anything already seen
744 for await (const event of stream) {
749 tail: for await (const event of stream) {
745750 // Preview events (event_start/event_delta) carry no top-level id
746751 if (event.type === "event_start" || event.type === "event_delta") continue;
747752 if (seenEventIds.has(event.id)) continue;
748753 seenEventIds.add(event.id);
749 if (event.type === "agent.message") {
750 for (const block of event.content) {
751 if (block.type === "text") {
752 process.stdout.write(block.text);
754 switch (event.type) {
755 case "agent.message":
756 for (const block of event.content) {
757 if (block.type === "text") {
758 process.stdout.write(block.text);
759 }
753760 }
754 }
755 } else if (event.type === "session.status_idle") {
756 break;
761 break;
762 case "session.status_idle":
763 break tail;
757764 }
758765 }
759766 ```
from line 874
867874 continue;
868875 }
869876 $seenEventIds[$event->id] = true;
870 match ($event->type) {
871 'agent.message' => array_walk(
877 match (true) {
878 $event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsAgentMessageEvent => array_walk(
872879 $event->content,
873 static fn ($block) => $block->type === 'text' ? print($block->text) : null,
880 static fn ($block) => $block instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsTextBlock ? print($block->text) : null,
874881 ),
875882 default => null,
876883 };
from line 898
891898 # Tail live events, skipping anything already seen — Set#add? returns nil for duplicates
892899 stream.each do |event|
893900 next unless seen_event_ids.add?(event.id)
894 case event.type
895 in :"agent.message"
901 case event
902 when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
896903 event.content.each { print it.text }
897 in :"session.status_idle"
904 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
898905 break
899906 else
900907 # ignore other event types
from line 1281
12741281 ]
12751282 });
12761283
1277 for await (const event of stream) {
1278 if (event.type === "event_start") {
1279 // 1. Note the announced id and open the snapshot. Deltas and the
1280 // buffered event carry the same id.
1281 const preview = accumulateManagedAgentsEvent(undefined, event);
1282 if (preview) previews.set(event.event.id, preview);
1283 console.log(`event_start ${event.event.type} ${event.event.id}`);
1284 } else if (event.type === "event_delta") {
1285 // 2. Fold the fragment into the snapshot and render it
1286 const preview = accumulateManagedAgentsEvent(previews.get(event.event_id), event);
1287 if (preview) {
1288 previews.set(event.event_id, preview);
1289 const text = preview.content
1284 deltas: for await (const event of stream) {
1285 switch (event.type) {
1286 case "event_start": {
1287 // 1. Note the announced id and open the snapshot. Deltas and the
1288 // buffered event carry the same id.
1289 const preview = accumulateManagedAgentsEvent(undefined, event);
1290 if (preview) previews.set(event.event.id, preview);
1291 console.log(`event_start ${event.event.type} ${event.event.id}`);
1292 break;
1293 }
1294 case "event_delta": {
1295 // 2. Fold the fragment into the snapshot and render it
1296 const preview = accumulateManagedAgentsEvent(previews.get(event.event_id), event);
1297 if (preview) {
1298 previews.set(event.event_id, preview);
1299 const text = preview.content
1300 .map((block) => (block.type === "text" ? block.text : ""))
1301 .join("");
1302 console.log(`event_delta preview: ${JSON.stringify(text)}`);
1303 }
1304 break;
1305 }
1306 case "agent.message": {
1307 // 3. The buffered event is the record: it replaces and closes the preview
1308 const message = accumulateManagedAgentsEvent(previews.get(event.id), event);
1309 previews.delete(event.id);
1310 const text = message.content
12901311 .map((block) => (block.type === "text" ? block.text : ""))
12911312 .join("");
1292 console.log(`event_delta preview: ${JSON.stringify(text)}`);
1293 }
1294 } else if (event.type === "agent.message") {
1295 // 3. The buffered event is the record: it replaces and closes the preview
1296 const message = accumulateManagedAgentsEvent(previews.get(event.id), event);
1297 previews.delete(event.id);
1298 const text = message.content
1299 .map((block) => (block.type === "text" ? block.text : ""))
1300 .join("");
1301 console.log(`agent.message ${event.id} ${JSON.stringify(text)}`);
1302 } else if (event.type === "span.model_request_end") {
1303 // 4. No more deltas are coming. Close any preview that was never reconciled.
1304 for (const eventId of previews.keys()) {
1305 console.log(`span.model_request_end closing preview for ${eventId}`);
1306 }
1307 previews.clear();
1308 } else if (event.type === "session.status_idle") {
1309 break;
1313 console.log(`agent.message ${event.id} ${JSON.stringify(text)}`);
1314 break;
1315 }
1316 case "span.model_request_end":
1317 // 4. No more deltas are coming. Close any preview that was never reconciled.
1318 for (const eventId of previews.keys()) {
1319 console.log(`span.model_request_end closing preview for ${eventId}`);
1320 }
1321 previews.clear();
1322 break;
1323 case "session.status_idle":
1324 break deltas;
13101325 }
13111326 }
13121327 stream.controller.abort();
from line 1483
14681483 );
14691484
14701485 Iterable<BetaManagedAgentsStreamSessionEvents> events = stream.stream()::iterator;
1486 deltas:
14711487 for (var event : events) {
1472 if (event.isEventStart() && event.asEventStart().event().isAgentMessage()) {
1473 var preview = event.asEventStart().event().asAgentMessage();
1474 IO.println("event_start " + preview.type().asString() + " " + preview.id());
1475 } else if (event.isEventDelta()) {
1476 var eventDelta = event.asEventDelta();
1477 var fragment = eventDelta.delta();
1478 var buffer = previews
1479 .computeIfAbsent(eventDelta.eventId(), _ -> new HashMap<>())
1480 .computeIfAbsent(fragment.index().orElse(0L), _ -> new StringBuilder());
1481 buffer.append(fragment.content().text());
1482 IO.println("event_delta preview: " + buffer);
1483 } else if (event.isAgentMessage()) {
1484 // The buffered event is the record: drop its preview, render its content
1485 var message = event.asAgentMessage();
1486 previews.remove(message.id());
1487 var text = message.content().stream()
1488 .flatMap(block -> block.text().stream())
1489 .map(textBlock -> textBlock.text())
1490 .collect(Collectors.joining());
1491 IO.println("agent.message " + message.id() + " " + text);
1492 } else if (event.isSpanModelRequestEnd()) {
1493 // No more deltas are coming. Close any preview whose buffered event never arrived.
1494 previews.keySet().forEach(eventId ->
1495 IO.println("span.model_request_end closing preview for " + eventId));
1496 previews.clear();
1497 } else if (event.isSessionStatusIdle()) {
1498 break;
1488 switch (event.type().value()) {
1489 case EVENT_START -> {
1490 if (event.asEventStart().event().isAgentMessage()) {
1491 var preview = event.asEventStart().event().asAgentMessage();
1492 IO.println("event_start " + preview.type().asString() + " " + preview.id());
1493 }
1494 }
1495 case EVENT_DELTA -> {
1496 var eventDelta = event.asEventDelta();
1497 var fragment = eventDelta.delta();
1498 var buffer = previews
1499 .computeIfAbsent(eventDelta.eventId(), _ -> new HashMap<>())
1500 .computeIfAbsent(fragment.index().orElse(0L), _ -> new StringBuilder());
1501 buffer.append(fragment.content().text());
1502 IO.println("event_delta preview: " + buffer);
1503 }
1504 case AGENT_MESSAGE -> {
1505 // The buffered event is the record: drop its preview, render its content
1506 var message = event.asAgentMessage();
1507 previews.remove(message.id());
1508 var text = message.content().stream()
1509 .flatMap(block -> block.text().stream())
1510 .map(textBlock -> textBlock.text())
1511 .collect(Collectors.joining());
1512 IO.println("agent.message " + message.id() + " " + text);
1513 }
1514 case SPAN_MODEL_REQUEST_END -> {
1515 // No more deltas are coming. Close any preview whose buffered event never arrived.
1516 previews.keySet().forEach(eventId ->
1517 IO.println("span.model_request_end closing preview for " + eventId));
1518 previews.clear();
1519 }
1520 case SESSION_STATUS_IDLE -> {
1521 break deltas;
1522 }
14991523 }
15001524 }
15011525 }
from line 1552
15281552 end
15291553
15301554 stream.each do |event|
1531 case event.type
1532 in :event_start
1555 case event
1556 when Anthropic::Beta::BetaManagedAgentsStartEvent
15331557 puts "event_start #{event.event.type} #{event.event.id}"
1534 in :event_delta
1558 when Anthropic::Beta::BetaManagedAgentsDeltaEvent
15351559 delta = event.delta
15361560 fragment = delta.content.text
15371561 buffers[event.event_id][delta.index || 0] << fragment
15381562 puts "event_delta preview: #{buffers[event.event_id][delta.index || 0].inspect}"
1539 in :"agent.message"
1563 when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
15401564 # Replace: drop the accumulated preview and render the complete event.
15411565 buffers.delete(event.id)
15421566 puts "agent.message #{event.id} #{event.content.map(&:text).join.inspect}"
1543 in :"span.model_request_end"
1567 when Anthropic::Beta::Sessions::BetaManagedAgentsSpanModelRequestEndEvent
15441568 # No more deltas are coming. Close any preview that was never reconciled.
15451569 buffers.each_key { |event_id| puts "span.model_request_end closing preview for #{event_id}" }
15461570 buffers.clear
1547 in :"session.status_idle"
1571 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
15481572 break
15491573 else
15501574 # ignore other event types
from line 1718
16941718 event_deltas: ["agent.message"],
16951719 });
16961720
1697 for await (const event of stream) {
1698 if (event.type === "event_delta") {
1699 process.stdout.write(event.delta.content.text);
1700 } else if (event.type === "agent.message") {
1701 // The buffered event is the authoritative record; render its content.
1702 process.stdout.write("\n");
1703 const text = event.content
1704 .map((block) => (block.type === "text" ? block.text : ""))
1705 .join("");
1706 console.log(text);
1707 } else if (event.type === "session.thread_status_idle") {
1708 break;
1721 threadDeltas: for await (const event of stream) {
1722 switch (event.type) {
1723 case "event_delta":
1724 process.stdout.write(event.delta.content.text);
1725 break;
1726 case "agent.message": {
1727 // The buffered event is the authoritative record; render its content.
1728 process.stdout.write("\n");
1729 const text = event.content
1730 .map((block) => (block.type === "text" ? block.text : ""))
1731 .join("");
1732 console.log(text);
1733 break;
1734 }
1735 case "session.thread_status_idle":
1736 break threadDeltas;
17091737 }
17101738 }
17111739 stream.controller.abort();
from line 1838
18101838 .build()
18111839 )) {
18121840 Iterable<BetaManagedAgentsStreamSessionThreadEvents> events = stream.stream()::iterator;
1841 threadDeltas:
18131842 for (var event : events) {
1814 if (event.isEventDelta()) {
1815 IO.print(event.asEventDelta().delta().content().text());
1816 } else if (event.isAgentMessage()) {
1817 // The buffered event is the authoritative record; render its content.
1818 IO.println();
1819 event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
1820 IO.println();
1821 } else if (event.isSessionThreadStatusIdle()) {
1822 break;
1843 switch (event.type().value()) {
1844 case EVENT_DELTA -> IO.print(event.asEventDelta().delta().content().text());
1845 case AGENT_MESSAGE -> {
1846 // The buffered event is the authoritative record; render its content.
1847 IO.println();
1848 event.asAgentMessage().content().forEach(block -> block.text().ifPresent(textBlock -> IO.print(textBlock.text())));
1849 IO.println();
1850 }
1851 case SESSION_THREAD_STATUS_IDLE -> {
1852 break threadDeltas;
1853 }
18231854 }
18241855 }
18251856 }
from line 1874
18431874 )
18441875
18451876 stream.each do |event|
1846 case event.type
1847 in :event_delta
1877 case event
1878 when Anthropic::Beta::BetaManagedAgentsDeltaEvent
18481879 print event.delta.content.text
1849 in :"agent.message"
1880 when Anthropic::Beta::Sessions::BetaManagedAgentsAgentMessageEvent
18501881 # The buffered event is the authoritative record; render its content.
18511882 puts
18521883 event.content.each { print it.text }
18531884 puts
1854 in :"session.thread_status_idle"
1885 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionThreadStatusIdleEvent
18551886 break
18561887 else
18571888 # ignore other event types
from line 2137
21062137 $stream = $client->beta->sessions->events->streamStream($session->id);
21072138
21082139 foreach ($stream as $event) {
2109 if ($event->type === 'session.status_idle' && $event->stopReason) {
2110 if ($event->stopReason->type === 'requires_action') {
2111 foreach ($event->stopReason->eventIDs as $eventId) {
2112 // Look up the custom tool use event and execute it
2113 $toolEvent = $eventsById[$eventId];
2114 $result = callTool($toolEvent->name, $toolEvent->input);
2115
2116 // Send the result back
2117 $client->beta->sessions->events->send(
2118 $session->id,
2119 events: [
2120 [
2121 'type' => 'user.custom_tool_result',
2122 'custom_tool_use_id' => $eventId,
2123 'content' => [['type' => 'text', 'text' => $result]],
2140 if ($event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent && $event->stopReason) {
2141 switch (true) {
2142 case $event->stopReason instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionRequiresAction:
2143 foreach ($event->stopReason->eventIDs as $eventId) {
2144 // Look up the custom tool use event and execute it
2145 $toolEvent = $eventsById[$eventId];
2146 $result = callTool($toolEvent->name, $toolEvent->input);
2147
2148 // Send the result back
2149 $client->beta->sessions->events->send(
2150 $session->id,
2151 events: [
2152 [
2153 'type' => 'user.custom_tool_result',
2154 'custom_tool_use_id' => $eventId,
2155 'content' => [['type' => 'text', 'text' => $result]],
2156 ],
21242157 ],
2125 ],
2126 );
2127 }
2128 } elseif ($event->stopReason->type === 'end_turn') {
2129 break;
2158 );
2159 }
2160 break;
2161 case $event->stopReason instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionEndTurn:
2162 break 2;
21302163 }
21312164 }
21322165 }
from line 2168
21352168 ```ruby Ruby
21362169 client.beta.sessions.events.stream_events(session.id).each do |event|
21372170 case event
2138 in {type: :"session.status_idle", stop_reason: {type: :requires_action, event_ids:}}
2139 event_ids.each do |event_id|
2140 # Look up the custom tool use event and execute it
2141 tool_event = events_by_id[event_id]
2142 result = call_tool.call(tool_event.name, tool_event.input)
2143 # Send the result back
2144 client.beta.sessions.events.send_(
2145 session.id,
2146 events: [
2147 {
2148 type: "user.custom_tool_result",
2149 custom_tool_use_id: event_id,
2150 content: [{type: "text", text: result}]
2151 }
2152 ]
2153 )
2171 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
2172 stop_reason = event.stop_reason
2173 case stop_reason
2174 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionRequiresAction
2175 stop_reason.event_ids.each do |event_id|
2176 # Look up the custom tool use event and execute it
2177 tool_event = events_by_id[event_id]
2178 result = call_tool.call(tool_event.name, tool_event.input)
2179 # Send the result back
2180 client.beta.sessions.events.send_(
2181 session.id,
2182 events: [
2183 {
2184 type: "user.custom_tool_result",
2185 custom_tool_use_id: event_id,
2186 content: [{type: "text", text: result}]
2187 }
2188 ]
2189 )
2190 end
2191 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionEndTurn
2192 break
21542193 end
2155 in {type: :"session.status_idle", stop_reason: {type: :end_turn}}
2156 break
2157 else
21582194 end
21592195 end
21602196 ```
from line 2401
23652401 $stream = $client->beta->sessions->events->streamStream($session->id);
23662402
23672403 foreach ($stream as $event) {
2368 if ($event->type === 'session.status_idle' && $event->stopReason) {
2369 if ($event->stopReason->type === 'requires_action') {
2370 foreach ($event->stopReason->eventIDs as $eventId) {
2371 // Approve the pending tool call
2372 $client->beta->sessions->events->send(
2373 $session->id,
2374 events: [
2375 [
2376 'type' => 'user.tool_confirmation',
2377 'tool_use_id' => $eventId,
2378 'result' => 'allow',
2404 if ($event instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionStatusIdleEvent && $event->stopReason) {
2405 switch (true) {
2406 case $event->stopReason instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionRequiresAction:
2407 foreach ($event->stopReason->eventIDs as $eventId) {
2408 // Approve the pending tool call
2409 $client->beta->sessions->events->send(
2410 $session->id,
2411 events: [
2412 [
2413 'type' => 'user.tool_confirmation',
2414 'tool_use_id' => $eventId,
2415 'result' => 'allow',
2416 ],
23792417 ],
2380 ],
2381 );
2382 }
2383 } elseif ($event->stopReason->type === 'end_turn') {
2384 break;
2418 );
2419 }
2420 break;
2421 case $event->stopReason instanceof \Anthropic\Beta\Sessions\Events\ManagedAgentsSessionEndTurn:
2422 break 2;
23852423 }
23862424 }
23872425 }
from line 2428
23902428 ```ruby Ruby
23912429 client.beta.sessions.events.stream_events(session.id).each do |event|
23922430 case event
2393 in {type: :"session.status_idle", stop_reason: {type: :requires_action, event_ids:}}
2394 event_ids.each do |event_id|
2395 # Approve the pending tool call
2396 client.beta.sessions.events.send_(
2397 session.id,
2398 events: [
2399 {type: "user.tool_confirmation", tool_use_id: event_id, result: "allow"}
2400 ]
2401 )
2431 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionStatusIdleEvent
2432 stop_reason = event.stop_reason
2433 case stop_reason
2434 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionRequiresAction
2435 stop_reason.event_ids.each do |event_id|
2436 # Approve the pending tool call
2437 client.beta.sessions.events.send_(
2438 session.id,
2439 events: [
2440 {type: "user.tool_confirmation", tool_use_id: event_id, result: "allow"}
2441 ]
2442 )
2443 end
2444 when Anthropic::Beta::Sessions::BetaManagedAgentsSessionEndTurn
2445 break
24022446 end
2403 in {type: :"session.status_idle", stop_reason: {type: :end_turn}}
2404 break
2405 else
24062447 end
24072448 end
24082449 ```
24092450