+ ![]()
` and SVG ``, and `map` tiles are requests by
- * construction. Kinds absent here carry their bytes as `data:` and reach nothing.
+ * construction. Kinds absent here carry their bytes as `data:` and reach nothing,
+ * or render through a component that is itself inert on the public page —
+ * `aiagent` is the second case, via `GfmMarkdown`, which is why it renders
+ * markdown yet is not listed while `markdown` still is.
* Inert only on the public page, which promises to issue no requests. */
const OFFLINE_INERT_KINDS: ResultKind[] = ['markdown', 'html', 'svg', 'map']
let length = $state(1)
@@ -743,15 +746,14 @@
{/if}
{#if result_stream && result == undefined}
- {@const agentStream = parseAgentStream(result_stream)}
| undefined {
+ let event: unknown
+ try {
+ event = JSON.parse(line)
+ } catch {
+ return undefined
+ }
+ if (!isRecord(event) || typeof event.type !== 'string') {
+ return undefined
+ }
+ return STREAM_EVENT_TYPES.includes(event.type) ? event : undefined
+}
+
/**
- * `result_stream` carries one `StreamingEvent` per line while an agent runs.
- * Returns undefined for a stream that is not an agent's, so any other streaming
- * result keeps being shown verbatim.
+ * Whether `result_stream` is an agent's event stream rather than something a
+ * script printed. Reads only the first complete line, because it runs on every
+ * poll of a running job.
*/
-export function parseAgentStream(raw: string): AgentStream | undefined {
- let sawEvent = false
- const stream: AgentStream = { answer: '', reasoning: '' }
- for (const line of raw.split('\n')) {
+export function isAgentStream(raw: string): boolean {
+ let start = 0
+ while (start < raw.length) {
+ const end = raw.indexOf('\n', start)
+ if (end === -1) {
+ // Only a partial first line so far; wait for the poll that completes it.
+ return false
+ }
+ const line = raw.slice(start, end)
+ if (line.trim() !== '') {
+ return parseStreamEvent(line) !== undefined
+ }
+ start = end + 1
+ }
+ return false
+}
+
+/**
+ * Fold the events that arrived since `previous` into the answer so far.
+ *
+ * Incremental rather than a parse of the whole buffer: the stream only ever
+ * grows, a poll can arrive every 50ms, and a `tool_result` event carries the
+ * tool's entire output — so re-reading everything each time is quadratic in the
+ * number of events with a large constant.
+ */
+export function advanceAgentStream(
+ raw: string,
+ previous: AgentStreamProgress
+): AgentStreamProgress {
+ // A trailing line with no newline yet is still being written, so it stays
+ // unconsumed until the poll that completes it.
+ const complete = raw.lastIndexOf('\n') + 1
+ if (complete <= previous.consumed) {
+ return previous
+ }
+ const stream: AgentStream = { ...previous.stream }
+ for (const line of raw.slice(previous.consumed, complete).split('\n')) {
if (line.trim() === '') {
continue
}
- let event: unknown
- try {
- event = JSON.parse(line)
- } catch {
- // A trailing partial line is normal: the poll can cut an event in half.
+ const event = parseStreamEvent(line)
+ if (!event) {
continue
}
- if (!isRecord(event) || typeof event.type !== 'string') {
- continue
- }
- if (!STREAM_EVENT_TYPES.includes(event.type)) {
- continue
- }
- sawEvent = true
if (event.type === 'token_delta' && typeof event.content === 'string') {
stream.answer += event.content
} else if (event.type === 'reasoning_token_delta' && typeof event.content === 'string') {
@@ -188,14 +220,18 @@ export function parseAgentStream(raw: string): AgentStream | undefined {
}
}
}
- return sawEvent ? stream : undefined
+ return { consumed: complete, stream }
}
-/** Token counts run to five and six figures, where the exact digit is noise. */
+/**
+ * Token counts run to five and six figures, where the exact digit is noise. The
+ * millions branch is not decoration: usage accumulates over every loop
+ * iteration, and each one re-sends the whole context.
+ */
export function formatTokenCount(count: number): string {
if (count < 1000) {
return String(count)
}
- const thousands = count / 1000
- return `${thousands < 10 ? thousands.toFixed(1) : Math.round(thousands)}k`
+ const [scaled, unit] = count < 1_000_000 ? [count / 1000, 'k'] : [count / 1_000_000, 'M']
+ return `${scaled < 10 ? scaled.toFixed(1) : Math.round(scaled)}${unit}`
}
{#if stream.tool.running}
diff --git a/frontend/src/lib/components/DisplayResult.svelte b/frontend/src/lib/components/DisplayResult.svelte
index 6cbaf52090..6a8e450f17 100644
--- a/frontend/src/lib/components/DisplayResult.svelte
+++ b/frontend/src/lib/components/DisplayResult.svelte
@@ -57,7 +57,7 @@
import type { MarkupTrust } from './apps/markupTrust'
import AgentResultDisplay from './AgentResultDisplay.svelte'
import AgentStreamDisplay from './AgentStreamDisplay.svelte'
- import { parseAgentResult, parseAgentStream } from './aiAgentResult'
+ import { isAgentStream, parseAgentResult } from './aiAgentResult'
const TABLE_MAX_SIZE = 5000000
const DISPLAY_MAX_SIZE = 100000
@@ -99,7 +99,10 @@
const REPLAY_INERT_KINDS: ResultKind[] = ['s3object', 's3object-list', 'materialized', 'approval']
/** Kinds whose markup pulls subresources: DOMPurify stops scripting but keeps
* `