src/vs/platform/agentHost/test/node/claudeMapSessionEventsTestUtils.ts
305 LOC · 305 covered · 0 uncovered · 32 ranges · 446 concepts · 16 introducers · 240 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
claudeMapSessionEventsTestUtils.ts ×16
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import type Anthropic from '@anthropic-ai/sdk';
7
>
import type { SDKAssistantMessage, SDKPartialAssistantMessage, SDKResultError, SDKResultSuccess, SDKSystemMessage, SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
8
>
9
>
// Beta event-stream type aliases. The `Anthropic` namespace re-exports
10
>
// these from `@anthropic-ai/sdk/resources/beta/messages.js`, but
11
>
// importing that subpath directly trips the `local/code-import-patterns`
12
>
// allowlist (the agentHost rule only permits the bare
13
>
// `@anthropic-ai/sdk` specifier). Local aliases via the `Anthropic`
14
>
// import keep the body of this file readable without extending the
15
>
// allowlist.
16
>
export type BetaRawContentBlockDeltaEvent = Anthropic.Beta.BetaRawContentBlockDeltaEvent;
17
>
export type BetaRawContentBlockStartEvent = Anthropic.Beta.BetaRawContentBlockStartEvent;
18
>
export type BetaRawContentBlockStopEvent = Anthropic.Beta.BetaRawContentBlockStopEvent;
19
>
export type BetaRawMessageStartEvent = Anthropic.Beta.BetaRawMessageStartEvent;
20
>
export type BetaRawMessageStopEvent = Anthropic.Beta.BetaRawMessageStopEvent;
21
>
export type BetaContentBlock = Anthropic.Beta.BetaContentBlock;
22
>
23
>
/**
24
>
* Static fixture uuid used by every helper that needs to emit a
25
>
* `${string}-${string}-${string}-${string}-${string}`-shaped value.
26
>
* Tests that exercise uuid-sensitive logic (e.g. the Cycle C send-seam
27
>
* test) construct their own uuids instead of relying on this constant.
28
>
*/
29
>
export const TEST_UUID = '11111111-2222-3333-4444-555555555555';
30
>
31
>
/**
32
>
* Builds the non-nullable shape of {@link SDKResultSuccess.usage}. Most
33
>
* fields are zeroed; the mapper only reads `input_tokens`,
34
>
* `output_tokens`, and `cache_read_input_tokens`.
35
>
*/
36
>
export function makeNonNullableUsage(): SDKResultSuccess['usage'] {
38
>
cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
39
>
cache_creation_input_tokens: 0,
40
>
cache_read_input_tokens: 0,
41
>
inference_geo: 'unknown',
42
>
input_tokens: 0,
43
>
iterations: [],
44
>
output_tokens: 0,
45
>
server_tool_use: { web_fetch_requests: 0, web_search_requests: 0 },
46
>
service_tier: 'standard',
47
>
speed: 'standard',
48
>
};
49
>
}
51
>
export function makeSystemInitMessage(sessionId: string): SDKSystemMessage {
53
>
type: 'system',
54
>
subtype: 'init',
55
>
apiKeySource: 'user',
56
>
claude_code_version: '0.0.0-test',
57
>
cwd: '/workspace',
58
>
tools: [],
59
>
mcp_servers: [],
60
>
model: 'claude-test',
61
>
permissionMode: 'default',
62
>
slash_commands: [],
63
>
output_style: 'default',
64
>
skills: [],
65
>
plugins: [],
66
>
uuid: TEST_UUID,
67
>
session_id: sessionId,
68
>
};
69
>
}
71
>
export function makeResultSuccess(sessionId: string): SDKResultSuccess {
73
>
type: 'result',
74
>
subtype: 'success',
75
>
duration_ms: 0,
76
>
duration_api_ms: 0,
77
>
is_error: false,
78
>
num_turns: 1,
79
>
result: '',
80
>
stop_reason: 'end_turn',
81
>
total_cost_usd: 0,
82
>
usage: makeNonNullableUsage(),
83
>
modelUsage: {},
84
>
permission_denials: [],
85
>
uuid: TEST_UUID,
86
>
session_id: sessionId,
87
>
};
88
>
}
90
>
export function makeResultError(sessionId: string, errors: string[]): SDKResultError {
92
>
type: 'result',
93
>
subtype: 'error_during_execution',
94
>
duration_ms: 0,
95
>
duration_api_ms: 0,
96
>
is_error: true,
97
>
num_turns: 1,
98
>
stop_reason: null,
99
>
total_cost_usd: 0,
100
>
usage: makeNonNullableUsage(),
101
>
modelUsage: {},
102
>
permission_denials: [],
103
>
errors,
104
>
uuid: TEST_UUID,
105
>
session_id: sessionId,
106
>
};
107
>
}
109
>
// `stream_event` (SDKPartialAssistantMessage) builders. The SDK's
110
>
// `Options.includePartialMessages: true` setting (Phase 6 §3.4) routes
111
>
// raw `BetaRawMessageStreamEvent`s through to the agent so we can map
112
>
// per-token. The deep `BetaMessage` shape on `message_start` carries
113
>
// many required fields irrelevant to mapping; these helpers populate
114
>
// only what the mapper reads, with everything else set to safe zero
115
>
// values so the SDK type-checks pass without `as unknown` casts.
116
>
117
>
export function makeStreamEvent(
119
>
event: SDKPartialAssistantMessage['event'],
120
>
): SDKPartialAssistantMessage {
121
>
return {
122
>
type: 'stream_event',
123
>
event,
124
>
parent_tool_use_id: null,
125
>
uuid: TEST_UUID,
126
>
session_id: sessionId,
127
>
};
128
>
}
130
>
export function makeMessageStart(messageId: string = 'msg_test'): BetaRawMessageStartEvent {
132
>
type: 'message_start',
133
>
message: {
134
>
id: messageId,
135
>
type: 'message',
136
>
role: 'assistant',
137
>
model: 'claude-test',
138
>
content: [],
139
>
stop_reason: null,
140
>
stop_sequence: null,
141
>
stop_details: null,
142
>
container: null,
143
>
context_management: null,
144
>
usage: {
145
>
cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
146
>
cache_creation_input_tokens: 0,
147
>
cache_read_input_tokens: 0,
148
>
inference_geo: 'unknown',
149
>
input_tokens: 0,
150
>
iterations: [],
151
>
output_tokens: 0,
152
>
server_tool_use: { web_fetch_requests: 0, web_search_requests: 0 },
153
>
service_tier: 'standard',
154
>
speed: 'standard',
155
>
},
156
>
},
157
>
};
158
>
}
160
>
export function makeContentBlockStartText(index: number): BetaRawContentBlockStartEvent {
162
>
type: 'content_block_start',
163
>
index,
164
>
content_block: { type: 'text', text: '', citations: null },
165
>
};
166
>
}
168
>
export function makeContentBlockStartThinking(index: number): BetaRawContentBlockStartEvent {
170
>
type: 'content_block_start',
171
>
index,
172
>
content_block: { type: 'thinking', thinking: '', signature: '' },
173
>
};
174
>
}
176
>
export function makeContentBlockStartToolUse(
178
>
id: string,
179
>
name: string,
180
>
): BetaRawContentBlockStartEvent {
181
>
return {
182
>
type: 'content_block_start',
183
>
index,
184
>
content_block: { type: 'tool_use', id, name, input: {} },
185
>
};
186
>
}
188
>
export function makeTextDelta(index: number, text: string): BetaRawContentBlockDeltaEvent {
190
>
type: 'content_block_delta',
191
>
index,
192
>
delta: { type: 'text_delta', text },
193
>
};
194
>
}
196
>
export function makeThinkingDelta(index: number, thinking: string): BetaRawContentBlockDeltaEvent {
198
>
type: 'content_block_delta',
199
>
index,
200
>
delta: { type: 'thinking_delta', thinking },
201
>
};
202
>
}
204
>
/**
205
>
* Phase 7 §3.3: `content_block_delta` with `input_json_delta` is the
206
>
* stream of partial parameter JSON for an open `tool_use` block.
207
>
*/
208
>
export function makeInputJsonDelta(index: number, partialJson: string): BetaRawContentBlockDeltaEvent {
210
>
type: 'content_block_delta',
211
>
index,
212
>
delta: { type: 'input_json_delta', partial_json: partialJson },
213
>
};
214
>
}
216
>
export function makeContentBlockStop(index: number): BetaRawContentBlockStopEvent {
218
>
type: 'content_block_stop',
219
>
index,
220
>
};
221
>
}
223
>
export function makeMessageStop(): BetaRawMessageStopEvent {
225
>
}
227
>
/**
228
>
* Builds the canonical {@link SDKAssistantMessage} envelope (`type:
229
>
* 'assistant'`) the SDK delivers as the final, authoritative message
230
>
* for a turn alongside its `'stream_event'` partials. The {@link
231
>
* content} blocks mirror what the partial accumulator should already
232
>
* have produced via `content_block_*` events. Only the fields the
233
>
* mapper inspects are filled with real values; the rest are zeroed so
234
>
* the SDK type-checks pass.
235
>
*/
236
>
export function makeAssistantMessage(
238
>
content: BetaContentBlock[],
239
>
): SDKAssistantMessage {
240
>
return {
241
>
type: 'assistant',
242
>
message: {
243
>
id: 'msg_test',
244
>
type: 'message',
245
>
role: 'assistant',
246
>
model: 'claude-test',
247
>
content,
248
>
stop_reason: 'end_turn',
249
>
stop_sequence: null,
250
>
stop_details: null,
251
>
container: null,
252
>
context_management: null,
253
>
usage: {
254
>
cache_creation: { ephemeral_1h_input_tokens: 0, ephemeral_5m_input_tokens: 0 },
255
>
cache_creation_input_tokens: 0,
256
>
cache_read_input_tokens: 0,
257
>
inference_geo: 'unknown',
258
>
input_tokens: 0,
259
>
iterations: [],
260
>
output_tokens: 0,
261
>
server_tool_use: { web_fetch_requests: 0, web_search_requests: 0 },
262
>
service_tier: 'standard',
263
>
speed: 'standard',
264
>
},
265
>
},
266
>
parent_tool_use_id: null,
267
>
uuid: TEST_UUID,
268
>
session_id: sessionId,
269
>
};
270
>
}
272
>
/**
273
>
* Builds the synthetic {@link SDKUserMessage} envelope (`type: 'user'`)
274
>
* the SDK delivers as the response to a previously-emitted `tool_use`.
275
>
* Phase 7 §3.3.4 — the mapper detects this by walking
276
>
* `message.content` for `tool_result` blocks and emits a
277
>
* `ChatToolCallComplete` per match. The `content` field is the SDK's
278
>
* `string | (TextBlockParam | ImageBlockParam | ...)[]` shape; the
279
>
* helper accepts a string or pre-built block array verbatim.
280
>
*/
281
>
export function makeUserToolResultMessage(
283
>
toolUseId: string,
284
>
content: string | Array<{ type: 'text'; text: string }>,
285
>
options?: { isError?: boolean },
286
>
): SDKUserMessage {
287
>
return {
288
>
type: 'user',
289
>
message: {
290
>
role: 'user',
291
>
content: [
292
>
{
293
>
type: 'tool_result',
294
>
tool_use_id: toolUseId,
295
>
content,
296
>
...(options?.isError ? { is_error: true } : {}),
297
>
},
298
>
],
299
>
},
300
>
parent_tool_use_id: null,
301
>
isSynthetic: true,
302
>
uuid: TEST_UUID,
303
>
session_id: sessionId,
304
>
};
305
>
}