Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

feat(cli): serve amp history from Amp's own store, not from ours

0xken158d25d692fd04
diff --git a/cli/src/backendSocket.ts b/cli/src/backendSocket.ts
index 9f41ba6f0..17af11abc 100644
--- a/cli/src/backendSocket.ts
+++ b/cli/src/backendSocket.ts
@@ -30,6 +30,7 @@ import { loadCursorReplayTaskLinks } from './engines/cursor/subagent.js'
import { opencodeMessagesToEvents, windowOpencodeMessages } from './engines/opencode/normalizer.js'
import { museMessagesToEvents } from './engines/muse/normalizer.js'
import { ampMessagesToEvents } from './engines/amp/normalizer.js'
+import { ampThreadToEvents, readAmpThread } from './engines/amp/threadExport.js'
import { piMessagesToEvents, windowPiLines } from './engines/pi/normalizer.js'
import { commandcodeMessagesToEvents, windowCommandCodeLines } from './engines/commandcode/normalizer.js'
import { hermesMessagesToEvents, windowHermesMessages } from './engines/hermes/normalizer.js'
@@ -97,6 +98,27 @@ function clipDeviceAgentName(input: string): string {
return `${out}${DEVICE_ELLIPSIS}`
}
+/**
+ * Amp history comes from AMP's store, not from ours.
+ *
+ * The plugin's JSONL is a record of what the plugin saw; a thread that ran before the integration existed
+ * — or in a pane still holding an older plugin — is simply not in it, and no local file can rebuild those
+ * turns. `amp threads export` returns the thread complete, including the tools Amp runs server-side.
+ *
+ * The local file stays as the FALLBACK, because an export is a network call and a pane with no history at
+ * all is worse than a partial one. Which source answered is logged either way: silently serving the lesser
+ * record is exactly how the missing tool cards went unnoticed for a day.
+ */
+async function ampHistory(sessionId: string, lines: string[]): Promise<SessionEvent[]> {
+ const messages = await readAmpThread(sessionId)
+ if (messages) {
+ console.log(`[history] ${sessionId.slice(0, 12)} amp · ${messages.length} message(s) from amp's own store`)
+ return ampThreadToEvents(messages)
+ }
+ console.warn(`[history] ${sessionId.slice(0, 12)} amp · export unavailable — falling back to the local transcript`)
+ return ampMessagesToEvents(lines)
+}
+
export function deviceAgentListItem(
raw: unknown,
): { id: unknown; name?: string; engine?: 'claude' | 'codex' | 'cursor' | 'opencode' | 'pi' | 'hermes' | 'commandcode' | 'devin' | 'muse' | 'amp'; selectedModel?: string | null } {
@@ -751,7 +773,7 @@ export class BackendSocket {
: s.engine === 'muse'
? museMessagesToEvents(lines)
: s.engine === 'amp'
- ? ampMessagesToEvents(lines)
+ ? await ampHistory(sessionId, lines)
: s.engine === 'pi'
? piMessagesToEvents(lines)
: s.engine === 'commandcode'
@@ -779,7 +801,7 @@ export class BackendSocket {
reply(type, requestId, {
id: sessionId,
title: projectDisplayName(s),
- events: s.engine === 'amp' ? ampMessagesToEvents(lines) : museMessagesToEvents(lines),
+ events: s.engine === 'amp' ? await ampHistory(sessionId, lines) : museMessagesToEvents(lines),
timestamp,
engine: s.engine,
hasMore: false,
diff --git a/cli/src/engines/amp/normalizer.ts b/cli/src/engines/amp/normalizer.ts
index 35dcada7b..851c16d87 100644
--- a/cli/src/engines/amp/normalizer.ts
+++ b/cli/src/engines/amp/normalizer.ts
@@ -149,6 +149,10 @@ export function ampToolOutput(output: unknown): string {
} catch { /* an ordinary string, which is the common case */ }
return output
}
+ // A BARE array of hits, which is what the export's `run.result` holds. `obj()` rejects arrays, so
+ // without this the card fell through to JSON.stringify and showed whole scraped pages.
+ const bare = searchHits(output)
+ if (bare) return bare
const body = obj(output)
if (!body) return output === undefined || output === null ? '' : JSON.stringify(output)
const content = body.content
diff --git a/cli/src/engines/amp/threadExport.spec.ts b/cli/src/engines/amp/threadExport.spec.ts
new file mode 100644
index 000000000..95ea3eb84
--- /dev/null
+++ b/cli/src/engines/amp/threadExport.spec.ts
@@ -0,0 +1,74 @@
+import { describe, expect, it } from 'vitest'
+import { readFileSync } from 'fs'
+import { fileURLToPath } from 'url'
+import { ampThreadToEvents } from './threadExport.js'
+
+/**
+ * A REAL `amp threads export` payload — one web-search turn, home directory scrubbed and the scraped
+ * page text trimmed. This is the shape history is served from, so the fixture is Amp's own export rather
+ * than anything this adapter writes.
+ */
+function messages(): Record<string, unknown>[] {
+ const p = fileURLToPath(new URL('../../lib/__fixtures__/amp-thread-export.json', import.meta.url))
+ return (JSON.parse(readFileSync(p, 'utf-8')) as { messages: Record<string, unknown>[] }).messages
+}
+
+describe('amp thread export → history', () => {
+ it('renders the turn as a conversation', () => {
+ const events = ampThreadToEvents(messages())
+ // The measured order. Note thinking lands AFTER the tool, not before it: the first assistant message
+ // carries an empty `thinking` (withheld by the provider, dropped here) and the second carries the
+ // real one alongside the answer.
+ expect(events.map((e) => e.type)).toEqual([
+ 'user_message', 'tool_start', 'tool_end', 'thinking_delta', 'text_delta', 'done',
+ ])
+ expect(events[0]).toMatchObject({ payload: { content: 'gia BTC di' } })
+ })
+
+ /**
+ * The point of reading Amp's store instead of the local transcript: `web_search` runs on Amp's server,
+ * fires no client event, and so never reached the JSONL written by an older plugin. It is in the export.
+ */
+ it('carries the server-run tool the local transcript never saw', () => {
+ const events = ampThreadToEvents(messages())
+ const start = events.find((e) => e.type === 'tool_start')
+ const end = events.find((e) => e.type === 'tool_end')
+ expect(start).toMatchObject({ payload: { tool: 'WebSearch' } })
+ expect(end).toMatchObject({ payload: { tool: 'WebSearch', isError: false } })
+ expect((start as { payload: { id: string } }).payload.id)
+ .toBe((end as { payload: { id: string } }).payload.id)
+ })
+
+ it('reduces the search result to its sources, from the export\'s nested shape', () => {
+ const end = ampThreadToEvents(messages()).find((e) => e.type === 'tool_end')
+ const output = (end as { payload: { output: string } }).payload.output
+ // `{run:{result:[{title,url,excerpts}]}}` — one level deeper than the live event's shape.
+ expect(output).toContain('https://')
+ expect(output).not.toContain('excerpts')
+ })
+
+ it('drops reasoning the provider withheld instead of drawing an empty bubble', () => {
+ // Amp exports reasoning under `thinking`, not `text`. It is often WITHHELD — an OpenAI-backed turn
+ // carries `thinking: ""` and an opaque id — and an empty bubble is worse than none.
+ const withheld = [{ role: 'assistant', content: [{ type: 'thinking', thinking: '', signature: '' }] }]
+ expect(ampThreadToEvents(withheld).map((e) => e.type)).toEqual(['done'])
+ // When it IS present it renders, which the fixture turn proves.
+ expect(ampThreadToEvents(messages()).some((e) => e.type === 'thinking_delta')).toBe(true)
+ })
+
+ it('pairs a result by toolUseID, which is not the key other engines use', () => {
+ const withSnakeCase = [{
+ role: 'assistant',
+ content: [{ type: 'tool_use', id: 'TU-1', name: 'shell_command', input: { command: 'ls' } }],
+ }, {
+ role: 'user',
+ content: [{ type: 'tool_result', tool_use_id: 'TU-1', run: { result: 'ok' } }],
+ }]
+ const events = ampThreadToEvents(withSnakeCase)
+ expect(events.find((e) => e.type === 'tool_end')).toMatchObject({ payload: { tool: 'Bash' } })
+ })
+
+ it('survives a thread with nothing in it', () => {
+ expect(ampThreadToEvents([])).toEqual([{ type: 'done', payload: { result: 'success' } }])
+ })
+})
diff --git a/cli/src/engines/amp/threadExport.ts b/cli/src/engines/amp/threadExport.ts
new file mode 100644
index 000000000..b9aba2cbd
--- /dev/null
+++ b/cli/src/engines/amp/threadExport.ts
@@ -0,0 +1,135 @@
+/**
+ * Amp history, read from AMP's OWN store rather than from ours.
+ *
+ * The live stream is fed by the adapter's plugin, which writes a JSONL transcript because Amp keeps no
+ * conversation on disk. That file is a good enough record of what the plugin SAW — and a bad answer for
+ * history, which is what this module exists to fix. It only ever contains turns that happened while a
+ * current plugin was loaded: a thread that ran before the integration existed, or in a pane whose plugin
+ * predates a fix, is missing from it forever, and nothing local can rebuild those turns.
+ *
+ * Amp does persist them, on its server, and hands them back complete: `amp threads export <threadId>`
+ * returns every message with its content blocks, including the tools Amp runs server-side that no client
+ * event ever reports. That is the authoritative history, so that is what `session_get` serves.
+ *
+ * The cost is a network round trip of roughly 1.5s per request, which history can afford and a live
+ * stream cannot — hence the split: Amp's store for the past, the plugin's JSONL for the present.
+ */
+
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import { env } from '../../config/env.js'
+import type { SessionEvent } from '../../lib/normalize.js'
+import { ampToolName, ampToolOutput, clip } from './normalizer.js'
+
+const execFileAsync = promisify(execFile)
+
+type JsonObject = Record<string, unknown>
+
+const MAX_OUTPUT = 2_000
+const MAX_THINKING = 500
+/** One thread of a long session is comfortably inside this; the default 1MB is not. */
+const MAX_BUFFER = 32 * 1024 * 1024
+const EXPORT_TIMEOUT_MS = 20_000
+/** `T-019fda29-9c6c-750e-acf0-47d06e200759` — checked before it ever reaches argv. */
+const THREAD_ID_RE = /^T-[0-9a-fA-F-]{8,64}$/
+
+function obj(value: unknown): JsonObject | null {
+ return value && typeof value === 'object' && !Array.isArray(value) ? (value as JsonObject) : null
+}
+
+function str(value: unknown): string {
+ return typeof value === 'string' ? value : ''
+}
+
+/**
+ * The messages Amp holds for one thread, or null when they cannot be fetched.
+ *
+ * Null is a real answer and callers must handle it: the export is a network call and Amp's client gives
+ * up on its own after ~30s (see `runAmpOneShot`, where the same flakiness forced a retry).
+ */
+export async function readAmpThread(threadId: string): Promise<JsonObject[] | null> {
+ // The id reaches here from a REGISTERED session, but it still goes on a command line — so it is
+ // validated by shape rather than trusted, the same rule `validTranscriptPath` applies to paths.
+ if (!THREAD_ID_RE.test(threadId)) return null
+ let stdout: string
+ try {
+ ({ stdout } = await execFileAsync(env.AMP_PATH || 'amp', ['threads', 'export', threadId], {
+ maxBuffer: MAX_BUFFER,
+ timeout: EXPORT_TIMEOUT_MS,
+ env: { ...process.env, AMP_DISABLE_PLUGINS: '1' },
+ }))
+ } catch (err) {
+ console.warn(`[amp] threads export failed for ${threadId.slice(0, 12)}: ${err instanceof Error ? err.message : err}`)
+ return null
+ }
+ let parsed: unknown
+ try { parsed = JSON.parse(stdout) } catch { return null }
+ const messages = obj(parsed)?.messages
+ return Array.isArray(messages) ? messages.map((m) => obj(m)).filter((m): m is JsonObject => m !== null) : null
+}
+
+/** A tool result's payload. Amp's export nests it one level deeper than the live event does. */
+function exportedToolOutput(block: JsonObject): string {
+ const run = obj(block.run)
+ // `{run:{result:…}}` in the export; `{output:…}`/`{content:[…]}` bare on the live path.
+ return ampToolOutput(run && 'result' in run ? run.result : (block.run ?? block.content ?? block.output))
+}
+
+/**
+ * One exported thread → the same event vocabulary the live stream produces.
+ *
+ * Block shapes are measured, not assumed: user text is `{type:'text',text}`, assistant reasoning is
+ * `{type:'thinking',thinking}` (note the field name differs from `text`), a call is
+ * `{type:'tool_use',id,name,input}` and its result is `{type:'tool_result',toolUseID,run}` — the pairing
+ * key is `toolUseID`, camelCase, and NOT the `tool_use_id` other engines use.
+ */
+export function ampThreadToEvents(messages: JsonObject[]): SessionEvent[] {
+ const events: SessionEvent[] = []
+ const toolNames = new Map<string, string>()
+ let thinkingCounter = 0
+
+ for (const message of messages) {
+ const role = str(message.role)
+ const blocks = Array.isArray(message.content) ? message.content : []
+ for (const raw of blocks) {
+ const block = obj(raw)
+ if (!block) continue
+ const type = str(block.type)
+ if (type === 'text') {
+ const text = str(block.text)
+ if (!text) continue
+ events.push(role === 'user'
+ ? { type: 'user_message', payload: { content: text } }
+ : { type: 'text_delta', payload: { content: text } })
+ } else if (type === 'thinking') {
+ // Reasoning is often withheld — an OpenAI-backed turn exports `thinking: ""` with only an opaque
+ // id. Emitting an empty bubble would be worse than emitting nothing.
+ const text = str(block.thinking).trim()
+ if (!text) continue
+ events.push({
+ type: 'thinking_delta',
+ payload: { content: clip(text, MAX_THINKING), thinkingId: `thinking-amp-${thinkingCounter++}` },
+ })
+ } else if (type === 'tool_use') {
+ const id = str(block.id)
+ if (!id) continue
+ const tool = ampToolName(str(block.name))
+ toolNames.set(id, tool)
+ events.push({ type: 'tool_start', payload: { id, tool, input: block.input ?? {} } })
+ } else if (type === 'tool_result') {
+ const id = str(block.toolUseID) || str(block.tool_use_id)
+ if (!id) continue
+ const tool = toolNames.get(id) ?? 'Tool'
+ toolNames.delete(id)
+ const output = exportedToolOutput(block)
+ const isError = obj(block.run)?.status === 'error'
+ events.push({
+ type: 'tool_end',
+ payload: { id, tool, output: clip(output, MAX_OUTPUT), isError, summary: isError ? 'error' : '' },
+ })
+ }
+ }
+ }
+ events.push({ type: 'done', payload: { result: 'success' } })
+ return events
+}
diff --git a/cli/src/lib/__fixtures__/amp-thread-export.json b/cli/src/lib/__fixtures__/amp-thread-export.json
new file mode 100644
index 000000000..5a5ca010f
--- /dev/null
+++ b/cli/src/lib/__fixtures__/amp-thread-export.json
@@ -0,0 +1,157 @@
+{
+ "messages": [
+ {
+ "meta": {
+ "sentAt": 1786080117426
+ },
+ "role": "user",
+ "readAt": "2026-08-07T05:21:58.004Z",
+ "content": [
+ {
+ "text": "gia BTC di",
+ "type": "text"
+ }
+ ],
+ "messageId": 15,
+ "protocolMessageID": "M-0342qPZDROR7U3qwhUucUC",
+ "protocolMessageVersion": 1
+ },
+ {
+ "role": "assistant",
+ "state": {
+ "type": "complete",
+ "stopReason": "tool_use"
+ },
+ "usage": {
+ "model": "gpt-5.6-sol",
+ "timestamp": "2026-08-07T05:22:30.907Z",
+ "inputTokens": 0,
+ "outputTokens": 99,
+ "maxInputTokens": 272000,
+ "totalInputTokens": 30602,
+ "cacheReadInputTokens": 30359,
+ "cacheCreationInputTokens": 243
+ },
+ "readAt": null,
+ "content": [
+ {
+ "type": "thinking",
+ "provider": "openai",
+ "thinking": "",
+ "finalTime": 1786080148956,
+ "signature": "",
+ "startTime": 1786080148623,
+ "blockState": "complete",
+ "openAIReasoning": {
+ "id": "rs_024c15c4116beb35016a756b94965481918aa16fed80d399c1",
+ "encryptedContent": "gAAAAABqdWuWHT3l85Fn1vQyuu7W1Fal8eZphvwLhP9r_-4ABuxFsVVrApwjkzil0pu0O6aggba5XtX8RSMaujaTcyp2-9QCFCMU70JDY3-VkDzpSe03kbiP9NifX3Uel8FeBX7maHG27B-Eg0yGdqbF-7s86anKvYQR4ONIYYLLRDq9dwD9pgEmYQwX-iBd7dKI-PdKOA3xdMhfEWqLt2G0fm2gU3DKJlysYDtlwU0lpeco3LAlqC3B9xB0ed1IwYDPnoQ1ISEdZsBL30ZqXj281OJmsEJbYVJwqKMkEnHjzigC9cfXXg2DY-OQM6qITjGvJl2Byn00QAwoUe8ZHJWlWVle_r0f2KnR4lDJXHrcVDOC59U2_iSEtiAZxSXjmbKcjsyxz6XvW4AKByHRQVc4KH3ku33yiuE1fjU71D-yHqOX2vNJCjDAiaBMVIWwL93urycj35eYK1G91w7YFzJ1rJaEjfd-iCdXQVXZBsqluAbFtGD8NEVVx9iq_q6j6trIAIm_qnSdhdbJUWX6ZwGbF49NNIvUhO92Nks5vLoXlfSqwR2d1dMDVbdEmwbSkjH9XjebKjm9_joZm47ZB5LJRd90wNyLNTps08WiXJ2koN7N2S4qcWOvn3By3rM67GbaKWXqEjP3KHvY6wxwLslpqloGVoBBf4TuSEaw3VNm2NRk_ytzPl8eRVEXzlATVk3_XkyVU6qXtSGeXYy8-n_2m0WyiXYAM2mp73N028sFtYZNI0PTVr567xo47ixpRth0sk-QQqE1ReXFFWFKYKN46kFUrwZ3LgwBGXBIkGQR-3e0Bi1rvXAswb9OY20yE6ssQEZRfKSVKvNm_-U02odMqAHPDZF0iRwz0MtPWndLyNQCk1gz9g0kdj6xWvwyhFAgAZug4npYVx_SMXpWwcMdMsQRW87oMdQA6WtP6wfDsDBVyYF5ZRyPEzsm6c2Qg5gKlvLUUqih"
+ }
+ },
+ {
+ "id": "TU-0342qQNOiJrXxteXzKf9te",
+ "name": "web_search",
+ "type": "tool_use",
+ "input": {
+ "objective": "T\u00ecm gi\u00e1 Bitcoin (BTC) hi\u1ec7n t\u1ea1i m\u1edbi nh\u1ea5t theo USD, bi\u1ebfn \u0111\u1ed9ng 24 gi\u1edd v\u00e0 bi\u00ean \u0111\u1ed9 gi\u00e1 24 gi\u1edd. \u01afu ti\u00ean CoinGecko ho\u1eb7c Binance v\u00e0 d\u1eef li\u1ec7u c\u1eadp nh\u1eadt theo th\u1eddi gian th\u1ef1c.",
+ "max_results": 3,
+ "search_queries": [
+ "Bitcoin BTC price USD today CoinGecko",
+ "BTC price 24 hour range"
+ ]
+ },
+ "complete": true,
+ "blockState": "complete",
+ "providerToolUseId": "call_EewNEeyLk9UaUO4AdJvd2biI"
+ }
+ ],
+ "messageId": 16,
+ "protocolMessageID": "M-0342qQLNFzsij9BkiWCo7S",
+ "protocolMessageVersion": 1
+ },
+ {
+ "role": "user",
+ "readAt": null,
+ "content": [
+ {
+ "run": {
+ "result": [
+ {
+ "url": "https://www.coingecko.com/en/coins/bitcoin",
+ "title": "Bitcoin Price: BTC/USD Live Price Chart, Market Cap & News Today | CoinGecko",
+ "excerpts": [
+ "\u2026trimmed for the fixture\u2026"
+ ]
+ },
+ {
+ "url": "https://www.coingecko.com/",
+ "title": "Cryptocurrency Prices, Charts, and Crypto Market Cap | CoinGecko",
+ "excerpts": [
+ "\u2026trimmed for the fixture\u2026"
+ ]
+ },
+ {
+ "url": "https://www.coinbase.com/price/bitcoin",
+ "title": "Bitcoin (BTC) Price USD Today, News, Charts, Market Cap",
+ "excerpts": [
+ "\u2026trimmed for the fixture\u2026"
+ ]
+ }
+ ],
+ "status": "done"
+ },
+ "type": "tool_result",
+ "toolUseID": "TU-0342qQNOiJrXxteXzKf9te"
+ }
+ ],
+ "messageId": 17,
+ "protocolMessageID": "M-0342qQSff68P8a9y8WLbvk",
+ "protocolMessageVersion": 0
+ },
+ {
+ "meta": {
+ "openAIResponsePhase": "final_answer"
+ },
+ "role": "assistant",
+ "state": {
+ "type": "complete",
+ "stopReason": "end_turn"
+ },
+ "usage": {
+ "model": "gpt-5.6-sol",
+ "timestamp": "2026-08-07T05:22:38.418Z",
+ "inputTokens": 0,
+ "outputTokens": 263,
+ "maxInputTokens": 272000,
+ "totalInputTokens": 40170,
+ "cacheReadInputTokens": 30599,
+ "cacheCreationInputTokens": 9571
+ },
+ "readAt": "2026-08-07T05:22:38.776Z",
+ "content": [
+ {
+ "type": "thinking",
+ "provider": "openai",
+ "thinking": "**Calculating currency value**\n\nI\u2019m computing VND 64,191.35 multiplied by 26,278. I estimate that 64k times 26,278 is around 1.682 million. For precision, it's actually 64,191.35 times 26,278, which breaks down to 1,681,792,000 for the main part. Then I calculate for the decimals, with 191.35 leading to a total of approximately 1,686,820,295, roughly 1.687 billion. There's a potential trend discrepancy mentioned, indicating a decline of about -0.8.",
+ "finalTime": 1786080157529,
+ "signature": "",
+ "startTime": 1786080153692,
+ "blockState": "complete",
+ "openAIReasoning": {
+ "id": "rs_024c15c4116beb35016a756b99a8f48191ba1aa4288e4d1944",
+ "encryptedContent": "gAAAAABqdWueIqKm6AWbB1ch6C2-HTp5sLmHZ6uV5nbtiJW8J7DORwMf-SXhT7fkD7iW8VZbbSd_TlRiN4uTtVlxVQ6ElQYOxrXFPWj3_BWX3eH9riR89zqJxay7t9pHlrYcRlWgykyjU0OAGz6csMQbZJTAEHEH4aB4sACt-5sPCN26yKSyO3xMCgNO0MHKFYToY4taelZyueE4a1EBNVIeq49tijSWWzY_3qoKU5UEArJB0JNF_OWb0KBn10RGE7_4gKr8bCONW7btOjPZX2ETMu89Ki5xP_lT0_ZAaJo8nohQCeic_txyKOIZ6DIQtoF0BgQ7npVliHRePAx_-vdCPfxEGJoyND-yM0-Ro7Q4xmMy0ZD7_c4fnNtDqVAQrkR8uaDe81IYoQyRwEz6ncEw133WFIJQ_4TN0f-3Mmkuz5lPp34OwX29TASf0k8ga4CEl1ixtyAOb2goAQVraJlPspA45kMlbNfI4l1wzsAJtTZG9FLdpv50mKaSc_G_Z20JQVL7mK1eNt6N0DqT7o9NhHh8W0Wy4PXw7PjGBAYqoGiCnaFAcHbvfVgS93fpysqqXw4OsoEui0yT82YkufdOfsYSe4YPchah_NXnBc4EeIKJ6W0dVYsyl0s063JibBdRMCWWiSCipwJuN2Vpg3S-KP_lgY_rtHJf0_yIudPptvCa8iYxv8JUQzuu9HPdBMgjLUQGnciM9hgCt8hCRgN-6jSjTvpaq1GQW8GF3xp4qPSTpyMF6WTqXb2YWhl4HN4DLNUu6tUOSjGuACciqId9LxxHqRxao9dlA3g55tlhy4HxnjkQbANcCp6A1N1bVlm3fUV7nhQLayhSUHL_SGQO6L3iI0t0a2JZwnA2eOw_keG3qrPghSU7TQsJoWrupxX1pXY5Mo4KaTgnNmPXWiF9ulsv790EIuX7Hvu9tZIPKfZmyM6DOarq711tWQtLNWkQ13ROJmr4-9fWjy-Uy2jJGbtYgOiVMMs7irJ5eD8UBouBZcjUabC-vFbju1h0UgwLa2z1Of9sjwfyJwm1y90a020wYnQVMkBqLpezjTDgfIhS_7dYgIEOpv61d9kLMT98ZbO09HJ_r2tOAIgLN69YzrNJI3LuQpxKqt5v4O_bJ3vlT6hFcXGJkJCsOKItzkRqYdBgIJP7ULRj09Y02iuFOZbJglPS4FUAWsQvdc5D_SFr6ijCK21xPxCirU0rQPWiZd6_LuzYUwhkJsZQfETSbruyoFOAxuqbWsjxQWBtJMttJB_bL11n4GI7P_E1wePto1rcaMrGw22O4pfhx0d524cGnoAncPWH85Kth3F3i2CvzfjZOmfVhxk2UCwRm2UBhUIod-TOfZieIzX-BA9bBq-RA4zK8w=="
+ }
+ },
+ {
+ "text": "BTC hi\u1ec7n kho\u1ea3ng **64.200 USD**, t\u01b0\u01a1ng \u0111\u01b0\u01a1ng kho\u1ea3ng **1,687 t\u1ef7 \u0111\u1ed3ng/BTC**.\n\n- **24 gi\u1edd:** gi\u1ea3m kho\u1ea3ng **0,8%**\n- **Bi\u00ean \u0111\u1ed9 24 gi\u1edd:** **64.114\u201364.916 USD**\n- **7 ng\u00e0y:** g\u1ea7n nh\u01b0 \u0111i ngang\n- **V\u1ed1n h\u00f3a:** kho\u1ea3ng **1.288 t\u1ef7 USD**\n\nNgu\u1ed3n: [CoinGecko](https://www.coingecko.com/en/coins/bitcoin). Gi\u00e1 tr\u00ean t\u1eebng s\u00e0n c\u00f3 th\u1ec3 ch\u00eanh nh\u1eb9.",
+ "type": "text",
+ "finalTime": 1786080158204,
+ "startTime": 1786080157531,
+ "blockState": "complete"
+ }
+ ],
+ "messageId": 18,
+ "protocolMessageID": "M-0342qQT16g45zmcYG88hOk",
+ "protocolMessageVersion": 2
+ }
+ ]
+}