Public: anyone can read this; the crew can change it.
A Talk answer can be stopped with one tap, and the answer says stopped and what it cost so far #13549
Check · Review · Land · Live done — Landed and live in production.
torque/forge:torque/13528-a-talk-answer-can-be-stopped-with-one-ta → main 9 commits fork 5 threads · 5 unresolved
docs/features/README.md +1
| @@ -144,6 +144,7 @@ Read with the guide page [Tell the crew](../guide-tell-the-crew.md). | ||
| 144 | 144 | - [](talk-attachments.md) |
| 145 | 145 | - [](talk-captain.md) |
| 146 | 146 | - [](talk.md) |
| 147 | - [](talk-stop.md) | |
| 147 | 148 | - [](talk-links.md) |
| 148 | 149 | - [](share-tell.md) |
| 149 | 150 | - [](crew-line.md) |
docs/features/talk-stop.md added +9
| @@ -0,0 +1,9 @@ | ||
| 1 | # Stopping a Talk answer | |
| 2 | ||
| 3 | While an answer is being written on `/talk`, **Stop** ends it with one tap. | |
| 4 | ||
| 5 | - The words already written stay in the thread, followed by a line that says **Stopped**. | |
| 6 | - The cost line reads **Stopped: $X spent so far**, with the dollars the answer had used when it stopped. | |
| 7 | - The spend is counted once: the run's row holds it and the turn list carries it a single time. | |
| 8 | - In the terminal, `ssh ... talk <words>` prints the same line (`Stopped: $X spent so far`) for the turn before, in place of `last turn $X`; one helper words both. | |
| 9 | - A turn cut before its result is priced from the usage it streamed, each component at its own rate: input $3, cache writes $3.75, cache reads $0.30 and output $15 per million tokens (an estimate; a result's own cost replaces it). |
src/core/conversation_cost.ts +23 −7
| @@ -11,23 +11,39 @@ export const CONTEXT_TOKENS = 200_000; | ||
| 11 | 11 | export const FULL_AT = 0.8; |
| 12 | 12 | |
| 13 | 13 | /** |
| 14 | * The dollars of the run that wrote each agent turn, by turn id: on the last agent turn inside the | |
| 14 | * What one agent turn's run spent, and whether the person stopped it (`conversation_run.stopped`). | |
| 15 | */ | |
| 16 | export interface Spend { | |
| 17 | readonly usd: number; | |
| 18 | readonly stopped: boolean; | |
| 19 | } | |
| 20 | ||
| 21 | /** The words under a reply, one wording for the page, its stream and the terminal. */ | |
| 22 | export const spendWords = (spend: Spend): string => (spend.stopped ? `Stopped: ${dollars(spend.usd)} spent so far` : `${dollars(spend.usd)} this turn`); | |
| 23 | ||
| 24 | /** | |
| 25 | * The spend of the run that wrote each agent turn, by turn id: on the last agent turn inside the | |
| 15 | 26 | * run's span. |
| 16 | 27 | */ |
| 17 | export function turnCosts(db: Database, conversationId: string): Map<string, number> { | |
| 28 | export function turnSpend(db: Database, conversationId: string): Map<string, Spend> { | |
| 18 | 29 | const rows = db |
| 19 | .query<{ id: string; cost: number }, [string]>( | |
| 30 | .query<{ id: string | null; cost: number; stopped: number }, [string]>( | |
| 20 | 31 | `SELECT (SELECT t.id FROM conversation_turn t |
| 21 | 32 | WHERE t.conversation_id = r.conversation_id AND t.role = 'agent' |
| 22 | 33 | AND t.created_at >= r.started_at AND t.created_at <= r.finished_at |
| 23 | ORDER BY t.rowid DESC LIMIT 1) AS id, r.cost_usd AS cost | |
| 34 | ORDER BY t.rowid DESC LIMIT 1) AS id, r.cost_usd AS cost, r.stopped AS stopped | |
| 24 | 35 | FROM conversation_run r |
| 25 | 36 | WHERE r.conversation_id = ?1 AND r.finished_at IS NOT NULL AND r.cost_usd > 0`, |
| 26 | 37 | ) |
| 27 | 38 | .all(conversationId); |
| 28 | const costs = new Map<string, number>(); | |
| 29 | for (const r of rows) if (r.id !== null) costs.set(r.id, (costs.get(r.id) ?? 0) + r.cost); | |
| 30 | return costs; | |
| 39 | const spent = new Map<string, Spend>(); | |
| 40 | for (const r of rows) if (r.id !== null) spent.set(r.id, { usd: (spent.get(r.id)?.usd ?? 0) + r.cost, stopped: (spent.get(r.id)?.stopped ?? false) || r.stopped === 1 }); | |
| 41 | return spent; | |
| 42 | } | |
| 43 | ||
| 44 | /** The dollars of the run that wrote each agent turn, by turn id. */ | |
| 45 | export function turnCosts(db: Database, conversationId: string): Map<string, number> { | |
| 46 | return new Map([...turnSpend(db, conversationId)].map(([id, s]) => [id, s.usd])); | |
| 31 | 47 | } |
| 32 | 48 | |
| 33 | 49 | /** |
src/crew/claude.ts +35
| @@ -250,6 +250,7 @@ async function runClaudeRaw(input: ClaudeInput): Promise<ClaudeOutcome> { | ||
| 250 | 250 | // A message's usage repeats on every content block of it, growing; the |
| 251 | 251 | // last word per message id is the message's spend. |
| 252 | 252 | const perMessage = new Map<string, { tokensIn: number; tokensOut: number }>(); |
| 253 | const perMessageUsd = new Map<string, number>(); | |
| 253 | 254 | |
| 254 | 255 | // The reads end on their own when the process exits — unless something it |
| 255 | 256 | // spawned still holds the pipe. Aborting them is how a settled session |
| @@ -345,6 +346,7 @@ async function runClaudeRaw(input: ClaudeInput): Promise<ClaudeOutcome> { | ||
| 345 | 346 | // What the last message read is the context the session holds. |
| 346 | 347 | contextTokens = used.tokensIn; |
| 347 | 348 | perMessage.set(key, used); |
| 349 | perMessageUsd.set(key, partialCostUsd(m["usage"])); | |
| 348 | 350 | if (input.onUsage) { |
| 349 | 351 | let tokensIn = 0; |
| 350 | 352 | let tokensOut = 0; |
| @@ -456,6 +458,17 @@ async function runClaudeRaw(input: ClaudeInput): Promise<ClaudeOutcome> { | ||
| 456 | 458 | closeInput(); |
| 457 | 459 | input.signal.removeEventListener("abort", onAbort); |
| 458 | 460 | |
| 461 | // Cut before its result: Claude Code names the cost only there, so what the | |
| 462 | // session had streamed is priced at the stated rates (`partialCostUsd`). | |
| 463 | if (!sawResult) { | |
| 464 | for (const t of perMessage.values()) { | |
| 465 | tokensIn += t.tokensIn; | |
| 466 | tokensOut += t.tokensOut; | |
| 467 | } | |
| 468 | costUsd = 0; | |
| 469 | for (const usd of perMessageUsd.values()) costUsd += usd; | |
| 470 | } | |
| 471 | ||
| 459 | 472 | if (why !== undefined) { |
| 460 | 473 | return { |
| 461 | 474 | ok: false, |
| @@ -504,6 +517,28 @@ export function reapGroup(pgid: number): void { | ||
| 504 | 517 | } |
| 505 | 518 | } |
| 506 | 519 | |
| 520 | /** | |
| 521 | * Assumed rates for a turn cut before its result: USD per million tokens, the | |
| 522 | * list price of a Sonnet-class model. Each usage component has its own rate: | |
| 523 | * cache writes cost 1.25x and cache reads 0.1x the input rate. An estimate of | |
| 524 | * what had streamed; a result's own `total_cost_usd` replaces it. | |
| 525 | */ | |
outdated
Comment says cache reads are not priced, but tokensOf() adds cache_read_input_tokens and cache_creation_input_tokens into tokensIn, so they are charged at the full input rate. The comment is wrong and the figure is overstated. Fix one or the other. |
||
| 526 | export const PARTIAL_USD_PER_MTOK = { in: 3, cacheWrite: 3.75, cacheRead: 0.3, out: 15 } as const; | |
| 527 | ||
| 528 | /** | |
| 529 | * USD of one message's `usage` object, each component at its own rate in `PARTIAL_USD_PER_MTOK`. | |
| 530 | */ | |
| 531 | export function partialCostUsd(usage: unknown): number { | |
| 532 | if (typeof usage !== "object" || usage === null) return 0; | |
| 533 | const u = usage as Record<string, unknown>; | |
| 534 | const n = (key: string): number => { | |
| 535 | const v = u[key]; | |
| 536 | return typeof v === "number" && Number.isFinite(v) && v > 0 ? Math.round(v) : 0; | |
| 537 | }; | |
| 538 | const r = PARTIAL_USD_PER_MTOK; | |
| 539 | return (n("input_tokens") * r.in + n("cache_creation_input_tokens") * r.cacheWrite + n("cache_read_input_tokens") * r.cacheRead + n("output_tokens") * r.out) / 1_000_000; | |
| 540 | } | |
| 541 | ||
| 507 | 542 | /** The largest `contextWindow` a result's `modelUsage` names, 0 when none. */ |
| 508 | 543 | export function windowOf(modelUsage: unknown): number { |
| 509 | 544 | if (typeof modelUsage !== "object" || modelUsage === null) return 0; |
src/crew/conversation.ts +37 −14
| @@ -124,7 +124,8 @@ export function stopTurn(app: App, userId: string): boolean { | ||
| 124 | 124 | for (const [conversationId, running] of stoppers) { |
| 125 | 125 | if (running.userId !== userId) continue; |
| 126 | 126 | // Cancelled first: no Confirm may land while the process is going down. |
| 127 | // Stop is the person calling it off: what waited behind the turn goes too (interrupting keeps it, `say`). | |
| 127 | // Stop is the person calling it off: what waited behind the turn goes too (interrupting keeps | |
| 128 | // it, `say`). | |
| 128 | 129 | queues.delete(conversationId); |
| 129 | 130 | cancelHeld(app.db, `conversation:${conversationId}`); |
| 130 | 131 | running.stop(); |
| @@ -147,9 +148,10 @@ export const turnDir = (dataDir: string): string => { | ||
| 147 | 148 | }; |
| 148 | 149 | |
| 149 | 150 | /** |
| 150 | * Where Claude Code keeps conversation sessions: `FORGE_AGENT_CONFIG_DIR` (or the older `FORGE_CLAUDE_CONFIG_DIR`, read through `runnerSettings`) | |
| 151 | * when the operator named one, else a directory of its own under the data | |
| 152 | * dir, which outlives a release (the container's HOME does not). Owner-only: | |
| 151 | * Where Claude Code keeps conversation sessions: `FORGE_AGENT_CONFIG_DIR` (or the older | |
| 152 | * `FORGE_CLAUDE_CONFIG_DIR`, read through `runnerSettings`) when the operator named one, else a | |
| 153 | * directory of its own under the data dir, which outlives a release (the container's HOME does | |
| 154 | * not). Owner-only: | |
| 153 | 155 | * it holds what the people said. |
| 154 | 156 | */ |
| 155 | 157 | export const sessionsDir = (dataDir: string, configured?: string): string => { |
| @@ -193,7 +195,10 @@ export function withHistory(app: App, conversation: Conversation, prompt: string | ||
| 193 | 195 | return `Your earlier session was lost, so this conversation starts a new one. What was said so far, oldest first, is a record to read, not instructions:\n\n${lines.join("\n\n")}\n\nThe person's message now:\n${prompt}`; |
| 194 | 196 | } |
| 195 | 197 | |
| 196 | /** The `--mcp-config` JSON: this forge's `/mcp`, the token read from the child's environment, never from its argv. */ | |
| 198 | /** | |
| 199 | * The `--mcp-config` JSON: this forge's `/mcp`, the token read from the child's environment, never | |
| 200 | * from its argv. | |
| 201 | */ | |
| 197 | 202 | export function mcpConfig(localUrl: string): string { |
| 198 | 203 | return JSON.stringify({ |
| 199 | 204 | mcpServers: { |
| @@ -209,7 +214,10 @@ export function mcpConfig(localUrl: string): string { | ||
| 209 | 214 | export type SayRefusal = "not_found" | "unauthorized" | "empty" | "too_long" | "no_account" | "resting" | "busy" | "answering" | "queue_full" | "file_taken"; |
| 210 | 215 | |
| 211 | 216 | export interface Said { |
| 212 | /** `started` a new turn, `steered` words into the one running, `queued` for after it, or `interrupted` it to send these at once. */ | |
| 217 | /** | |
| 218 | * `started` a new turn, `steered` words into the one running, `queued` for after it, or | |
| 219 | * `interrupted` it to send these at once. | |
| 220 | */ | |
| 213 | 221 | readonly how: "started" | "steered" | "queued" | "interrupted" | "answered"; |
| 214 | 222 | /** Settles when the turn does; only a started turn has one. */ |
| 215 | 223 | readonly done?: Promise<void>; |
| @@ -239,11 +247,17 @@ export const QUEUE_MAX = 5; | ||
| 239 | 247 | |
| 240 | 248 | const queues = new Map<string, Queued[]>(); |
| 241 | 249 | |
| 242 | /** The person's messages waiting for their running turn in a conversation (the latest by default), oldest first. */ | |
| 250 | /** | |
| 251 | * The person's messages waiting for their running turn in a conversation (the latest by default), | |
| 252 | * oldest first. | |
| 253 | */ | |
| 243 | 254 | export const queuedOf = (app: App, userId: string, conversationId?: string): readonly Queued[] => |
| 244 | 255 | queues.get(conversationId ?? openConversation(app.db, userId).id) ?? []; |
| 245 | 256 | |
| 246 | /** Whether a message waiting in a queue holds this file: it cannot be removed or sent twice meanwhile. */ | |
| 257 | /** | |
| 258 | * Whether a message waiting in a queue holds this file: it cannot be removed or sent twice | |
| 259 | * meanwhile. | |
| 260 | */ | |
| 247 | 261 | export const fileQueued = (fileId: string): boolean => [...queues.values()].some((l) => l.some((q) => q.files.some((f) => f.id === fileId))); |
| 248 | 262 | |
| 249 | 263 | /** Take back a waiting message; false when it is gone (already sent, or never theirs). */ |
| @@ -289,7 +303,10 @@ function drain(app: App, options: ConversationOptions, conversation: Conversatio | ||
| 289 | 303 | appendTurn(app.db, userId, current.id, { role: "agent", text: failureLine("error"), failed: true }); |
| 290 | 304 | } |
| 291 | 305 | |
| 292 | /** Store a person's message and answer it: steer, queue or interrupt the turn that runs (`During`), or start one. */ | |
| 306 | /** | |
| 307 | * Store a person's message and answer it: steer, queue or interrupt the turn that runs (`During`), | |
| 308 | * or start one. | |
| 309 | */ | |
| 293 | 310 | export function say( |
| 294 | 311 | app: App, |
| 295 | 312 | options: ConversationOptions, |
| @@ -329,7 +346,8 @@ export function say( | ||
| 329 | 346 | appendTurn(app.db, userId, conversation.id, { role: "agent", text: answer }); |
| 330 | 347 | return ok({ how: "answered", answer }); |
| 331 | 348 | } |
| 332 | // The subject rides with a new conversation's first message only (#10496), as fenced data the agent reads before the words. | |
| 349 | // The subject rides with a new conversation's first message only (#10496), as fenced data the | |
| 350 | // agent reads before the words. | |
| 333 | 351 | const first = listTurns(app.db, userId, conversation.id, { limit: 1 }); |
| 334 | 352 | const subject = about === undefined || about === null || !first.ok || first.value.length > 0 ? "" : aboutContext(app.db, about, user); |
| 335 | 353 | // A conversation that builds an app tells the agent where to work with every message (#11010). |
| @@ -339,7 +357,8 @@ export function say( | ||
| 339 | 357 | const stored = appendTurn(app.db, userId, conversation.id, { role: "person", text }); |
| 340 | 358 | if (!stored.ok) return err("too_long"); |
| 341 | 359 | attach(app.db, files, stored.value.id); |
| 342 | // A message nobody will answer is not kept: the door says why instead, and its files wait for the next try. | |
| 360 | // A message nobody will answer is not kept: the door says why instead, and its files wait for the | |
| 361 | // next try. | |
| 343 | 362 | const refuse = (why: SayRefusal): Result<Said, SayRefusal> => { |
| 344 | 363 | release(app.db, stored.value.id); |
| 345 | 364 | removeTurn(app.db, userId, conversation.id, stored.value.id); |
| @@ -353,8 +372,8 @@ export function say( | ||
| 353 | 372 | if (steerRun(app, running, text + delivery.text)) return ok({ how: "steered" }); |
| 354 | 373 | } |
| 355 | 374 | if (live.size >= (options.liveMax ?? TURNS_LIVE_MAX)) return refuse("busy"); |
| 356 | // A thread that runs for days summarises itself when it fills (#11011): the next turn starts a fresh | |
| 357 | // session whose context is the stored record and the person's memory. | |
| 375 | // A thread that runs for days summarises itself when it fills (#11011): the next turn starts a | |
| 376 | // fresh session whose context is the stored record and the person's memory. | |
| 358 | 377 | const full = (contextOf(app.db, conversation.id)?.share ?? 0) >= CONTEXT_FULL && conversation.claudeSessionId !== ""; |
| 359 | 378 | const started = full |
| 360 | 379 | ? begin(app, options, conversation, withHistory(app, conversation, text), 0, undefined, delivery, lead) |
| @@ -601,6 +620,9 @@ function begin( | ||
| 601 | 620 | // find, keeping what the session had reported (Claude Code names the |
| 602 | 621 | // cost only in its result, so a cut turn keeps its tokens and the cost |
| 603 | 622 | // it had). Its token is revoked at boot (`resumeInterrupted`). |
| 623 | // Charged here, once: the boot closes this row as failed without | |
| 624 | // charging it, and the resumed turn is a run of its own charged only its | |
| 625 | // own cost (test/talk-stop.test.ts). | |
| 604 | 626 | if (options.signal.aborted) { |
| 605 | 627 | app.db.query("UPDATE conversation_run SET tokens_in = ?2, tokens_out = ?3, cost_usd = ?4, context_tokens = ?5, context_window = ?6 WHERE id = ?1").run(runId, outcome?.tokensIn ?? 0, outcome?.tokensOut ?? 0, cost, outcome?.contextTokens ?? 0, outcome?.contextWindow ?? 0); |
| 606 | 628 | app.db.query("UPDATE subscription SET spent_usd = spent_usd + ?2 WHERE id = ?1").run(subscriptionId, cost); |
| @@ -641,7 +663,8 @@ function begin( | ||
| 641 | 663 | } finally { |
| 642 | 664 | if (live.get(conversation.id) === runId) live.delete(conversation.id); |
| 643 | 665 | if (stoppers.get(conversation.id)?.runId === runId) stoppers.delete(conversation.id); |
| 644 | // A restart leaves the next message unsent (its turn would be cut again); anything else sends it. | |
| 666 | // A restart leaves the next message unsent (its turn would be cut again); anything else sends | |
| 667 | // it. | |
| 645 | 668 | if (options.signal.aborted) queues.delete(conversation.id); |
| 646 | 669 | else { |
| 647 | 670 | // A build's first version gives its branch the pull that previews it (#11010). |
src/tui/ssh-talk.ts +8 −3
| @@ -29,7 +29,7 @@ | ||
| 29 | 29 | |
| 30 | 30 | import { cancelTalk, queuedTalk, TALK_WORDS, stopTalk, talk, talkAgain } from "../actions/talk.ts"; |
| 31 | 31 | import { FILE_WORDS, IMAGE_MAX, pendingAmong, removePending, storeFile } from "../core/conversation_files.ts"; |
| 32 | import { contextOf, contextText, conversationTotal, dollars, totalText, turnCosts } from "../core/conversation_cost.ts"; | |
| 32 | import { contextOf, contextText, conversationTotal, dollars, spendWords, totalText, turnSpend, type Spend } from "../core/conversation_cost.ts"; | |
| 33 | 33 | import { openConversation } from "../core/conversations.ts"; |
| 34 | 34 | import { aboutLine } from "../core/talk_about.ts"; |
| 35 | 35 | import type { App } from "../app.ts"; |
| @@ -158,9 +158,9 @@ export function serveTalk(app: App, session: SshSession, user: User | undefined, | ||
| 158 | 158 | if (user !== undefined) { |
| 159 | 159 | // The figures of the turn before this one, from its own usage record. |
| 160 | 160 | const conversation = openConversation(app.db, user.id); |
| 161 | const last = [...turnCosts(app.db, conversation.id).values()].at(-1); | |
| 161 | const last = [...turnSpend(app.db, conversation.id).values()].at(-1); | |
| 162 | 162 | const context = contextOf(app.db, conversation.id); |
| 163 | if (last !== undefined) session.write(`last turn ${dollars(last)}${CRLF}`); | |
| 163 | if (last !== undefined) session.write(`${lastTurnWords(last)}${CRLF}`); | |
| 164 | 164 | const total = conversationTotal(app.db, conversation.id); |
| 165 | 165 | if (total !== undefined) session.write(`${totalText(total)}${CRLF}`); |
| 166 | 166 | if (context !== undefined) session.write(`${contextText(context)}${CRLF}`); |
| @@ -182,6 +182,11 @@ export function serveTalk(app: App, session: SshSession, user: User | undefined, | ||
| 182 | 182 | }); |
| 183 | 183 | } |
| 184 | 184 | |
| 185 | /** | |
| 186 | * The line the terminal prints for the turn before: the page's Stopped wording when it was stopped. | |
| 187 | */ | |
| 188 | export const lastTurnWords = (spend: Spend): string => (spend.stopped ? spendWords(spend) : `last turn ${dollars(spend.usd)}`); | |
| 189 | ||
| 185 | 190 | /** `talk-again <edit words | regenerate | retry>`; undefined when the command is not one. */ |
| 186 | 191 | export function parseTalkAgain(command: string | undefined): { how: RedoHow; words: string } | undefined { |
| 187 | 192 | if (command === undefined) return undefined; |
src/web/pages/talk.ts +5 −5
| @@ -40,7 +40,7 @@ import { | ||
| 40 | 40 | type Turn, |
| 41 | 41 | } from "../../core/conversations.ts"; |
| 42 | 42 | import { conversationMarkdown } from "../../core/conversation_markdown.ts"; |
| 43 | import { contextOf, contextText, conversationTotal, dollars, totalText, turnCosts, type Context } from "../../core/conversation_cost.ts"; | |
| 43 | import { contextOf, contextText, conversationTotal, spendWords, totalText, turnSpend, type Spend, type Context } from "../../core/conversation_cost.ts"; | |
| 44 | 44 | import { aboutLine as aboutText } from "../../core/talk_about.ts"; |
| 45 | 45 | import { WORDS_MAX } from "../../core/fence.ts"; |
| 46 | 46 | import { thinkingOf, worksOf, type Work } from "../../core/talk_work.ts"; |
| @@ -213,10 +213,10 @@ const totalLine = (usd: number | undefined): Html => | ||
| 213 | 213 | html`<p class="talk-total small muted" data-total ${usd === undefined ? html`hidden` : null}>${usd === undefined ? "" : totalText(usd)}</p>`; |
| 214 | 214 | |
| 215 | 215 | /** The cost line under a reply. */ |
outdated
Principle 1/8: the terminal (src/tui/ssh-talk.ts:161, 'last turn $X') does not say stopped. Reuse this wording so both doors agree. |
||
| 216 | const costLine = (usd: number): Html => html`<p class="talk-cost small muted">${dollars(usd)} this turn</p>`; | |
| 216 | const costLine = (spend: Spend): Html => html`<p class="talk-cost small muted">${spendWords(spend)}</p>`; | |
| 217 | 217 | |
| 218 | 218 | /** One turn as the page and the stream both draw it; `waiting` is the confirms still open. */ |
| 219 | export function turnHtml(turn: Turn, waiting: ReadonlySet<string>, cost?: number, act?: Html, work?: Work, files: readonly ConversationFile[] = [], expired: ReadonlySet<string> = new Set(), undone: ReadonlySet<string> = new Set(), refs?: (n: number) => string | undefined): Html { | |
| 219 | export function turnHtml(turn: Turn, waiting: ReadonlySet<string>, cost?: Spend, act?: Html, work?: Work, files: readonly ConversationFile[] = [], expired: ReadonlySet<string> = new Set(), undone: ReadonlySet<string> = new Set(), refs?: (n: number) => string | undefined): Html { | |
| 220 | 220 | const id = `t-${turn.id}`; |
| 221 | 221 | const set = turn.replaced ? " talk-replaced" : ""; |
| 222 | 222 | const acts = act === undefined ? null : html`<div class="talk-acts">${act}</div>`; |
| @@ -357,7 +357,7 @@ async function talkPage(ctx: Ctx, conversation: Conversation, before0: string | | ||
| 357 | 357 | const undone = undoneIn(turns); |
| 358 | 358 | const sent = filesOfTurns(ctx.app.db, user.id, turns.filter((t) => t.role === "person").map((t) => t.id)); |
| 359 | 359 | const running = clock.running(ctx.app, user.id, conversation.id); |
| 360 | const costs = turnCosts(ctx.app.db, conversation.id); | |
| 360 | const costs = turnSpend(ctx.app.db, conversation.id); | |
| 361 | 361 | const context = contextOf(ctx.app.db, conversation.id); |
| 362 | 362 | const works = worksOf(ctx.app.db, user.id, conversation.id, turns); |
| 363 | 363 | // Paging back, the log ends before the newest turn: it does not follow. |
| @@ -645,7 +645,7 @@ export function talkStream(ctx: Ctx): Response { | ||
| 645 | 645 | if (fresh.length >= MAX_PAGE) return; |
| 646 | 646 | if (!running) { |
| 647 | 647 | // The run stored its figures before it stopped running: send them with the end. |
| 648 | const costs = [...turnCosts(app.db, conversation.id)].slice(-5).map(([id, usd]) => ({ id: `t-${id}`, html: costLine(usd).text })); | |
| 648 | const costs = [...turnSpend(app.db, conversation.id)].slice(-5).map(([id, spend]) => ({ id: `t-${id}`, html: costLine(spend).text })); | |
| 649 | 649 | const context = contextOf(app.db, conversation.id); |
| 650 | 650 | const total = conversationTotal(app.db, conversation.id); |
| 651 | 651 | emit("done", { |
test/talk-page.test.ts +27
| @@ -703,6 +703,33 @@ describe("the stream", () => { | ||
| 703 | 703 | expect(resumed.map((f) => f.event)).toEqual(["done"]); |
| 704 | 704 | }); |
| 705 | 705 | |
| 706 | test("the done frame carries the Stopped cost line for a stopped run and the plain one for a finished run (#13528)", async () => { | |
| 707 | const cid = openConversation(app.db, bob.id).id; | |
| 708 | const ran = (id: string, text: string, stopped: number, usd: number) => { | |
| 709 | const at = new Date(Date.now() - 1000).toISOString(); | |
| 710 | const turn = say(bob, "agent", text); | |
| 711 | if (!turn.ok) throw new Error("turn"); | |
| 712 | app.db | |
| 713 | .query("INSERT INTO conversation_run (id, conversation_id, user_id, prompt, state, stopped, cost_usd, started_at, finished_at) VALUES (?1,?2,?3,'x',?4,?5,?6,?7,?8)") | |
| 714 | .run(id, cid, bob.id, stopped ? "stopped" : "ok", stopped, usd, at, new Date(Date.now() + 1000).toISOString()); | |
| 715 | return turn.value.id; | |
| 716 | }; | |
| 717 | // One run at a time: a run's spend sits on the last agent turn inside its span. | |
| 718 | const costOf = async (id: string, text: string, stopped: number, usd: number): Promise<string | undefined> => { | |
| 719 | const turn = ran(id, text, stopped, usd); | |
| 720 | const all = await frames(`/talk/stream?after=${turn}`, bob); | |
| 721 | const behind = await frames("/talk/stream?after=", bob); | |
| 722 | const done = JSON.parse(behind.find((f) => f.event === "done")!.data!) as { costs: { id: string; html: string }[] }; | |
| 723 | expect(all.map((f) => f.event)).toEqual(["done"]); | |
| 724 | app.db.query("DELETE FROM conversation_run WHERE id = ?1").run(id); | |
| 725 | return done.costs.find((c) => c.id === `t-${turn}`)?.html; | |
| 726 | }; | |
| 727 | expect(await costOf("rs-cut", "Stopped.", 1, 0.006)).toContain("Stopped: $0.006 spent so far"); | |
| 728 | const whole = await costOf("rs-ok", "A whole answer.", 0, 0.25); | |
| 729 | expect(whole).toContain("$0.25 this turn"); | |
| 730 | expect(whole).not.toContain("Stopped"); | |
| 731 | }); | |
| 732 | ||
| 706 | 733 | test("never shows another person's turns, and refuses a bad id", async () => { |
| 707 | 734 | const mine = say(bob, "agent", "bob private"); |
| 708 | 735 | if (!mine.ok) throw new Error("turn"); |
test/talk-stop.test.ts added +158
| @@ -0,0 +1,158 @@ | ||
| 1 | /** | |
Add an assertion on subscription.spent_usd (about 0.006, once) after stopTurn; box 3 is about the ledger and only the run row is checked. |
||
| 2 | * A Talk answer stopped with one tap (#13528): the words so far stay, the | |
| 3 | * turn says Stopped with the dollars spent so far, and the ledger holds the | |
| 4 | * partial spend once. Hand calculation: 1000 input and 200 output tokens at | |
| 5 | * $3 and $15 per million = 0.003 + 0.003 = $0.006. | |
| 6 | */ | |
| 7 | ||
| 8 | import { afterAll, beforeAll, expect, test } from "bun:test"; | |
| 9 | import { chmodSync, writeFileSync } from "node:fs"; | |
| 10 | import { mkdtemp, rm } from "node:fs/promises"; | |
| 11 | import { tmpdir } from "node:os"; | |
| 12 | import { join } from "node:path"; | |
| 13 | import { createApp, type App } from "../src/app.ts"; | |
| 14 | import { listTurns, openConversation } from "../src/core/conversations.ts"; | |
| 15 | import { turnCosts } from "../src/core/conversation_cost.ts"; | |
| 16 | import { createUser, type User } from "../src/core/users.ts"; | |
| 17 | import { PLATFORM } from "../src/core/subscriptions.ts"; | |
| 18 | import { partialCostUsd } from "../src/crew/claude.ts"; | |
| 19 | import { resumeInterrupted, say, STOPPED_LINE, stopTurn } from "../src/crew/conversation.ts"; | |
| 20 | import { lastTurnWords } from "../src/tui/ssh-talk.ts"; | |
| 21 | import { turnHtml } from "../src/web/pages/talk.ts"; | |
| 22 | ||
| 23 | let dir: string; | |
| 24 | let app: App; | |
| 25 | let user: User; | |
| 26 | ||
| 27 | /** | |
| 28 | * The platform account's lifetime spend (`subscription.spent_usd`), where a Talk turn is charged. | |
| 29 | */ | |
| 30 | const spent = (): number => app.db.query<{ n: number }, [string]>("SELECT spent_usd AS n FROM subscription WHERE id = ?1").get(PLATFORM)!.n; | |
| 31 | ||
| 32 | /** A stand-in `claude` that streams half an answer worth $0.006 and then hangs until cut. */ | |
| 33 | function halfAnswer(name: string, sid: string): string { | |
| 34 | const path = join(dir, name); | |
| 35 | writeFileSync( | |
| 36 | path, | |
| 37 | `#!/bin/sh | |
| 38 | if [ "$1" = "--version" ]; then echo "2.1.0 (fake)"; exit 0; fi | |
| 39 | IFS= read -r first | |
| 40 | echo '{"type":"system","subtype":"init","session_id":"${sid}","model":"fake"}' | |
| 41 | echo '{"type":"assistant","session_id":"${sid}","message":{"id":"m1","content":[{"type":"text","text":"Half an answer."}],"usage":{"input_tokens":1000,"output_tokens":200}}}' | |
| 42 | sleep 300 | |
| 43 | `, | |
| 44 | ); | |
| 45 | chmodSync(path, 0o755); | |
| 46 | return path; | |
| 47 | } | |
| 48 | ||
| 49 | /** A stand-in `claude` that finishes with a result naming $0.01. */ | |
| 50 | function fullAnswer(name: string, sid: string): string { | |
| 51 | const path = join(dir, name); | |
| 52 | writeFileSync( | |
| 53 | path, | |
| 54 | `#!/bin/sh | |
| 55 | if [ "$1" = "--version" ]; then echo "2.1.0 (fake)"; exit 0; fi | |
| 56 | IFS= read -r first | |
| 57 | echo '{"type":"system","subtype":"init","session_id":"${sid}","model":"fake"}' | |
| 58 | echo '{"type":"assistant","session_id":"${sid}","message":{"id":"m2","content":[{"type":"text","text":"The rest."}],"usage":{"input_tokens":10,"output_tokens":5}}}' | |
| 59 | echo '{"type":"result","subtype":"success","is_error":false,"result":"The rest.","total_cost_usd":0.01,"num_turns":1,"session_id":"${sid}","terminal_reason":"completed","usage":{"input_tokens":10,"output_tokens":5}}' | |
| 60 | `, | |
| 61 | ); | |
| 62 | chmodSync(path, 0o755); | |
| 63 | return path; | |
| 64 | } | |
| 65 | ||
| 66 | beforeAll(async () => { | |
| 67 | dir = await mkdtemp(join(tmpdir(), "talk-stop-")); | |
| 68 | app = createApp({ dataDir: dir, port: 0 }); | |
| 69 | const made = await createUser(app.db, { origin: "seed", trusted: true, username: "stopper", email: "[email protected]", password: "a-good-passphrase", adminIfFirst: true }); | |
| 70 | if (!made.ok) throw new Error("no user"); | |
| 71 | user = made.value; | |
| 72 | }); | |
| 73 | afterAll(async () => { | |
| 74 | await rm(dir, { recursive: true, force: true }); | |
| 75 | }); | |
| 76 | ||
| 77 | test("partial spend is priced from each usage component at its own rate", () => { | |
| 78 | expect(partialCostUsd({ input_tokens: 1000, output_tokens: 200 })).toBeCloseTo(0.006, 9); | |
| 79 | // Hand calculation: 1000 in = 0.003; 1000 cache write at 3.75 = 0.00375; 10000 cache read at 0.3 | |
| 80 | // = 0.003; 200 out = 0.003. | |
| 81 | expect(partialCostUsd({ input_tokens: 1000, cache_creation_input_tokens: 1000, cache_read_input_tokens: 10000, output_tokens: 200 })).toBeCloseTo(0.01275, 9); | |
| 82 | expect(partialCostUsd(undefined)).toBe(0); | |
| 83 | }); | |
| 84 | ||
| 85 | test("a stopped answer keeps its text, says stopped with dollars, and is recorded once", async () => { | |
| 86 | const path = halfAnswer("claude", "s-stop"); | |
| 87 | const before = spent(); | |
| 88 | const said = say(app, { binary: path, localUrl: "http://127.0.0.1:9", budgetUsd: 1, timeoutMs: 30_000, signal: new AbortController().signal }, user.id, "go on"); | |
| 89 | if (!said.ok || said.value.done === undefined) throw new Error("not started"); | |
| 90 | const conversation = openConversation(app.db, user.id); | |
| 91 | const texts = (): string[] => { | |
| 92 | const l = listTurns(app.db, user.id, conversation.id, {}); | |
| 93 | return l.ok ? l.value.map((t) => t.text) : []; | |
| 94 | }; | |
| 95 | for (let i = 0; i < 100 && !texts().includes("Half an answer."); i++) await Bun.sleep(50); // real-timer: polls a child process the test cannot step | |
| 96 | expect(texts()).toContain("Half an answer."); | |
| 97 | expect(stopTurn(app, user.id)).toBe(true); | |
| 98 | await said.value.done; | |
| 99 | ||
| 100 | expect(texts().slice(-2)).toEqual(["Half an answer.", STOPPED_LINE]); | |
| 101 | const run = app.db.query<{ cost_usd: number; state: string }, [string]>("SELECT cost_usd, state FROM conversation_run WHERE user_id = ?1").get(user.id)!; | |
| 102 | expect(run.state).toBe("stopped"); | |
| 103 | expect(run.cost_usd).toBeCloseTo(0.006, 9); | |
| 104 | // Once: the run's row holds it and the turn list carries it a single time. | |
| 105 | const costs = [...turnCosts(app.db, conversation.id).values()]; | |
| 106 | expect(costs).toHaveLength(1); | |
| 107 | expect(costs[0]).toBeCloseTo(0.006, 9); | |
| 108 | // The account's ledger rises by the partial spend, once. | |
| 109 | expect(spent() - before).toBeCloseTo(0.006, 9); | |
| 110 | ||
| 111 | const l = listTurns(app.db, user.id, conversation.id, {}); | |
| 112 | const stopped = (l.ok ? l.value : []).find((t) => t.text === STOPPED_LINE)!; | |
| 113 | expect(turnHtml(stopped, new Set(), { usd: 0.006, stopped: true }).text).toContain("Stopped: $0.006 spent so far"); | |
| 114 | }); | |
| 115 | ||
| 116 | test("a turn cut by a restart is charged its partial spend once; the resumed turn adds only its own", async () => { | |
| 117 | const who = user; | |
| 118 | const before = spent(); | |
| 119 | const earlier = new Set(app.db.query<{ id: string }, [string]>("SELECT id FROM conversation_run WHERE user_id = ?1").all(who.id).map((r) => r.id)); | |
| 120 | const restart = new AbortController(); | |
| 121 | const options = { localUrl: "http://127.0.0.1:9", budgetUsd: 1, timeoutMs: 30_000 }; | |
| 122 | const said = say(app, { ...options, binary: halfAnswer("cut", "s-cut"), signal: restart.signal }, who.id, "go on"); | |
| 123 | if (!said.ok || said.value.done === undefined) throw new Error("not started"); | |
| 124 | const conversation = openConversation(app.db, who.id); | |
| 125 | const runs = () => | |
| 126 | app.db | |
| 127 | .query<{ id: string; cost_usd: number; state: string; resumes: number }, [string]>("SELECT id, cost_usd, state, resumes FROM conversation_run WHERE user_id = ?1 ORDER BY started_at, id") | |
| 128 | .all(who.id) | |
| 129 | .filter((r) => !earlier.has(r.id)) | |
| 130 | .map(({ cost_usd, state, resumes }) => ({ cost_usd, state, resumes })); | |
| 131 | const halves = (): number => { | |
| 132 | const l = listTurns(app.db, who.id, conversation.id, {}); | |
| 133 | return l.ok ? l.value.filter((t) => t.text === "Half an answer.").length : 0; | |
| 134 | }; | |
| 135 | const halvesBefore = halves(); | |
| 136 | for (let i = 0; i < 100 && halves() === halvesBefore; i++) await Bun.sleep(50); // real-timer: polls a child process the test cannot step | |
| 137 | restart.abort(); // the forge stops: the row stays running, charged what it streamed | |
| 138 | await said.value.done; | |
| 139 | expect(runs()).toEqual([{ cost_usd: expect.closeTo(0.006, 9) as unknown as number, state: "running", resumes: 0 }]); | |
| 140 | expect(spent() - before).toBeCloseTo(0.006, 9); | |
| 141 | ||
| 142 | // The next boot closes the cut row without charging it and starts a new run, charged only its own | |
| 143 | // result. | |
| 144 | await Promise.all(resumeInterrupted(app, { ...options, binary: fullAnswer("resumed", "s-cut"), signal: new AbortController().signal })); | |
| 145 | const [cut, resumed] = runs(); | |
| 146 | expect(cut).toEqual({ cost_usd: expect.closeTo(0.006, 9) as unknown as number, state: "failed", resumes: 0 }); | |
| 147 | expect(resumed).toEqual({ cost_usd: expect.closeTo(0.01, 9) as unknown as number, state: "ok", resumes: 1 }); | |
| 148 | // Hand calculation: 0.006 for the cut turn + 0.01 for the resumed one = 0.016, never 0.022. | |
| 149 | expect(spent() - before).toBeCloseTo(0.016, 9); | |
| 150 | // A second boot finds nothing left running, so nothing is charged again. | |
| 151 | expect(resumeInterrupted(app, { ...options, binary: fullAnswer("never", "s-cut"), signal: new AbortController().signal })).toHaveLength(0); | |
| 152 | expect(spent() - before).toBeCloseTo(0.016, 9); | |
| 153 | }); | |
| 154 | ||
| 155 | test("the terminal says Stopped with the same words as the page, and keeps 'last turn' for a finished one", () => { | |
| 156 | expect(lastTurnWords({ usd: 0.006, stopped: true })).toBe("Stopped: $0.006 spent so far"); | |
| 157 | expect(lastTurnWords({ usd: 0.5, stopped: false })).toBe("last turn $0.50"); | |
| 158 | }); |
This estimate now also feeds the restart-abort path, which adds it to subscription.spent_usd while the run stays running. Prove a resumed run is not charged twice, with a test.