@inspectr/mcplab-core 1.22.0 → 1.22.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/types.d.ts CHANGED
@@ -1,442 +1,417 @@
1
1
  export type TransportType = 'http';
2
2
  export interface ServerAuthBearer {
3
- type: 'bearer';
4
- env?: string;
5
- token?: string;
3
+ type: 'bearer';
4
+ env?: string;
5
+ token?: string;
6
6
  }
7
7
  export interface ServerAuthApiKey {
8
- type: 'api_key';
9
- header_name?: string;
10
- value: string;
8
+ type: 'api_key';
9
+ header_name?: string;
10
+ value: string;
11
11
  }
12
12
  export interface ServerAuthOauthClientCredentials {
13
- type: 'oauth_client_credentials';
14
- token_url: string;
15
- client_id_env: string;
16
- client_secret_env: string;
17
- scope?: string;
18
- audience?: string;
19
- token_params?: Record<string, string>;
13
+ type: 'oauth_client_credentials';
14
+ token_url: string;
15
+ client_id_env: string;
16
+ client_secret_env: string;
17
+ scope?: string;
18
+ audience?: string;
19
+ token_params?: Record<string, string>;
20
20
  }
21
21
  export interface ServerAuthOauthAuthorizationCode {
22
- type: 'oauth_authorization_code';
23
- mode?: 'pre_registered' | 'dcr';
24
- client_id?: string;
25
- client_secret?: string;
26
- redirect_url?: string;
27
- scope?: string;
28
- authorization_url?: string;
29
- token_url?: string;
30
- }
31
- export type ServerAuth =
32
- | ServerAuthBearer
33
- | ServerAuthApiKey
34
- | ServerAuthOauthClientCredentials
35
- | ServerAuthOauthAuthorizationCode;
22
+ type: 'oauth_authorization_code';
23
+ mode?: 'pre_registered' | 'dcr';
24
+ client_id?: string;
25
+ client_secret?: string;
26
+ redirect_url?: string;
27
+ scope?: string;
28
+ authorization_url?: string;
29
+ token_url?: string;
30
+ }
31
+ export type ServerAuth = ServerAuthBearer | ServerAuthApiKey | ServerAuthOauthClientCredentials | ServerAuthOauthAuthorizationCode;
36
32
  export interface ServerConfig {
37
- name?: string;
38
- transport: TransportType;
39
- url: string;
40
- headers?: Record<string, string>;
41
- auth?: ServerAuth;
33
+ name?: string;
34
+ transport: TransportType;
35
+ url: string;
36
+ headers?: Record<string, string>;
37
+ auth?: ServerAuth;
42
38
  }
43
39
  export interface ServerInlineEntry extends ServerConfig {
44
- id: string;
45
- name?: string;
40
+ id: string;
41
+ name?: string;
46
42
  }
47
43
  export interface ServerRefEntry {
48
- ref: string;
44
+ ref: string;
49
45
  }
50
46
  export type ServerListEntry = ServerInlineEntry | ServerRefEntry;
51
47
  export interface AgentConfig {
52
- name?: string;
53
- provider: 'openai' | 'anthropic' | 'azure_openai';
54
- model: string;
55
- temperature?: number;
56
- max_tokens?: number;
57
- max_turns?: number;
58
- system?: string;
48
+ name?: string;
49
+ provider: 'openai' | 'anthropic' | 'azure_openai';
50
+ model: string;
51
+ temperature?: number;
52
+ max_tokens?: number;
53
+ max_turns?: number;
54
+ system?: string;
59
55
  }
60
56
  export interface AgentInlineEntry extends AgentConfig {
61
- id: string;
62
- name?: string;
57
+ id: string;
58
+ name?: string;
63
59
  }
64
60
  export interface AgentRefEntry {
65
- ref: string;
61
+ ref: string;
66
62
  }
67
63
  export type AgentListEntry = AgentInlineEntry | AgentRefEntry;
68
64
  export interface ToolConstraints {
69
- required_tools?: string[];
70
- forbidden_tools?: string[];
65
+ required_tools?: string[];
66
+ forbidden_tools?: string[];
71
67
  }
72
68
  export interface ResponseAssertionRegex {
73
- type: 'regex';
74
- pattern: string;
69
+ type: 'regex';
70
+ pattern: string;
75
71
  }
76
72
  export interface ResponseAssertionContains {
77
- type: 'contains';
78
- value: string;
73
+ type: 'contains';
74
+ value: string;
79
75
  }
80
76
  export interface ResponseAssertionNotContains {
81
- type: 'not_contains';
82
- value: string;
77
+ type: 'not_contains';
78
+ value: string;
83
79
  }
84
80
  export interface ResponseAssertionStartsWith {
85
- type: 'starts_with';
86
- value: string;
81
+ type: 'starts_with';
82
+ value: string;
87
83
  }
88
84
  export interface ResponseAssertionEndsWith {
89
- type: 'ends_with';
90
- value: string;
85
+ type: 'ends_with';
86
+ value: string;
91
87
  }
92
88
  export interface ResponseAssertionEquals {
93
- type: 'equals';
94
- value: string;
89
+ type: 'equals';
90
+ value: string;
95
91
  }
96
92
  export interface ResponseAssertionJsonPath {
97
- type: 'jsonpath';
98
- path: string;
99
- equals?: string | number | boolean;
93
+ type: 'jsonpath';
94
+ path: string;
95
+ equals?: string | number | boolean;
100
96
  }
101
97
  export interface ResponseAssertionJsonPathExists {
102
- type: 'jsonpath_exists';
103
- path: string;
98
+ type: 'jsonpath_exists';
99
+ path: string;
104
100
  }
105
101
  export interface ResponseAssertionJsonPathNotExists {
106
- type: 'jsonpath_not_exists';
107
- path: string;
102
+ type: 'jsonpath_not_exists';
103
+ path: string;
108
104
  }
109
105
  export interface AgentAssertion {
110
- label: string;
111
- prompt: string;
106
+ label: string;
107
+ prompt: string;
112
108
  }
113
109
  export interface ToolInputAssertionBase {
114
- tool: string;
110
+ tool: string;
115
111
  }
116
112
  export interface ToolInputAssertionContains extends ToolInputAssertionBase {
117
- type: 'contains';
118
- value: string;
113
+ type: 'contains';
114
+ value: string;
119
115
  }
120
116
  export interface ToolInputAssertionRegex extends ToolInputAssertionBase {
121
- type: 'regex';
122
- pattern: string;
117
+ type: 'regex';
118
+ pattern: string;
123
119
  }
124
120
  export interface ToolInputAssertionJsonPath extends ToolInputAssertionBase {
125
- type: 'jsonpath';
126
- path: string;
127
- equals?: string | number | boolean;
128
- }
129
- export type ToolInputAssertion =
130
- | ToolInputAssertionContains
131
- | ToolInputAssertionRegex
132
- | ToolInputAssertionJsonPath;
121
+ type: 'jsonpath';
122
+ path: string;
123
+ equals?: string | number | boolean;
124
+ }
125
+ export type ToolInputAssertion = ToolInputAssertionContains | ToolInputAssertionRegex | ToolInputAssertionJsonPath;
133
126
  export interface AgentContext {
134
- include_prompt?: boolean;
135
- include_tool_sequence?: boolean;
136
- include_tool_inputs?: boolean;
127
+ include_prompt?: boolean;
128
+ include_tool_sequence?: boolean;
129
+ include_tool_inputs?: boolean;
137
130
  }
138
131
  export interface AgentJudgeContext {
139
- scenario_prompt?: string;
140
- tool_sequence?: string[];
141
- tool_inputs?: Array<{
142
- tool: string;
143
- arguments: unknown;
144
- }>;
145
- }
146
- export type ResponseAssertion =
147
- | ResponseAssertionRegex
148
- | ResponseAssertionContains
149
- | ResponseAssertionNotContains
150
- | ResponseAssertionStartsWith
151
- | ResponseAssertionEndsWith
152
- | ResponseAssertionEquals
153
- | ResponseAssertionJsonPath
154
- | ResponseAssertionJsonPathExists
155
- | ResponseAssertionJsonPathNotExists;
132
+ scenario_prompt?: string;
133
+ tool_sequence?: string[];
134
+ tool_inputs?: Array<{
135
+ tool: string;
136
+ arguments: unknown;
137
+ }>;
138
+ }
139
+ export type ResponseAssertion = ResponseAssertionRegex | ResponseAssertionContains | ResponseAssertionNotContains | ResponseAssertionStartsWith | ResponseAssertionEndsWith | ResponseAssertionEquals | ResponseAssertionJsonPath | ResponseAssertionJsonPathExists | ResponseAssertionJsonPathNotExists;
156
140
  export interface EvalRules {
157
- tool_constraints?: ToolConstraints;
158
- tool_sequence?: string[];
159
- tool_input_assertions?: ToolInputAssertion[];
160
- response_assertions?: ResponseAssertion[];
161
- agent_assertions?: AgentAssertion[];
162
- agent_context?: AgentContext;
141
+ tool_constraints?: ToolConstraints;
142
+ tool_sequence?: string[];
143
+ tool_input_assertions?: ToolInputAssertion[];
144
+ response_assertions?: ResponseAssertion[];
145
+ agent_assertions?: AgentAssertion[];
146
+ agent_context?: AgentContext;
163
147
  }
164
148
  export type CheckResultStatus = 'passed' | 'failed' | 'not_evaluated';
165
149
  export interface CheckResult {
166
- type: string;
167
- label: string;
168
- status: CheckResultStatus;
169
- reason?: string;
170
- metadata?: Record<string, unknown>;
150
+ type: string;
151
+ label: string;
152
+ status: CheckResultStatus;
153
+ reason?: string;
154
+ metadata?: Record<string, unknown>;
171
155
  }
172
156
  export interface CheckCounts {
173
- passed: number;
174
- failed: number;
175
- not_evaluated: number;
176
- total: number;
157
+ passed: number;
158
+ failed: number;
159
+ not_evaluated: number;
160
+ total: number;
177
161
  }
178
162
  export interface ExtractRule {
179
- name: string;
180
- from: 'final_text';
181
- regex: string;
163
+ name: string;
164
+ from: 'final_text';
165
+ regex: string;
182
166
  }
183
167
  export interface ScenarioAttachment {
184
- type: 'image' | 'document';
185
- media_type: string;
186
- data: string;
187
- url?: string;
188
- name?: string;
168
+ type: 'image' | 'document';
169
+ media_type: string;
170
+ data: string;
171
+ url?: string;
172
+ name?: string;
189
173
  }
190
174
  export interface SourceScenarioAttachment extends Omit<ScenarioAttachment, 'media_type' | 'data'> {
191
- media_type?: string;
192
- data?: string;
193
- path?: string;
175
+ media_type?: string;
176
+ data?: string;
177
+ path?: string;
194
178
  }
195
179
  export interface Scenario {
196
- id: string;
197
- name?: string;
198
- mcp_servers?: ServerListEntry[];
199
- servers: string[];
200
- prompt: string;
201
- attachments?: ScenarioAttachment[];
202
- eval?: EvalRules;
203
- extract?: ExtractRule[];
180
+ id: string;
181
+ name?: string;
182
+ mcp_servers?: ServerListEntry[];
183
+ servers: string[];
184
+ prompt: string;
185
+ attachments?: ScenarioAttachment[];
186
+ eval?: EvalRules;
187
+ extract?: ExtractRule[];
204
188
  }
205
189
  export interface ScenarioRefEntry {
206
- ref: string;
207
- mcp_servers?: ServerListEntry[];
190
+ ref: string;
191
+ mcp_servers?: ServerListEntry[];
208
192
  }
209
193
  export interface SourceScenario extends Omit<Scenario, 'servers' | 'attachments'> {
210
- servers?: string[];
211
- attachments?: SourceScenarioAttachment[];
194
+ servers?: string[];
195
+ attachments?: SourceScenarioAttachment[];
212
196
  }
213
197
  export type ScenarioListEntry = SourceScenario | ScenarioRefEntry;
214
198
  export interface EvalConfig {
215
- name?: string;
216
- servers: Record<string, ServerConfig>;
217
- agents: Record<string, AgentConfig>;
218
- scenarios: Scenario[];
219
- run_defaults?: {
220
- selected_agents?: string[];
221
- };
199
+ name?: string;
200
+ description?: string;
201
+ servers: Record<string, ServerConfig>;
202
+ agents: Record<string, AgentConfig>;
203
+ scenarios: Scenario[];
204
+ run_defaults?: {
205
+ selected_agents?: string[];
206
+ };
222
207
  }
223
208
  export interface SourceEvalConfig extends Omit<EvalConfig, 'scenarios' | 'agents' | 'servers'> {
224
- servers?: ServerListEntry[];
225
- agents: AgentListEntry[];
226
- scenarios: ScenarioListEntry[];
209
+ servers?: ServerListEntry[];
210
+ agents: AgentListEntry[];
211
+ scenarios: ScenarioListEntry[];
227
212
  }
228
213
  export interface ExecutableScenario extends Scenario {
229
- agent: string;
230
- scenario_exec_id?: string;
214
+ agent: string;
215
+ scenario_exec_id?: string;
231
216
  }
232
217
  export interface ExecutableEvalConfig extends Omit<EvalConfig, 'scenarios'> {
233
- scenarios: ExecutableScenario[];
218
+ scenarios: ExecutableScenario[];
234
219
  }
235
220
  export interface ToolDef {
236
- name: string;
237
- title?: string;
238
- description?: string;
239
- inputSchema?: unknown;
240
- outputSchema?: unknown;
241
- annotations?: {
221
+ name: string;
242
222
  title?: string;
243
- readOnlyHint?: boolean;
244
- idempotentHint?: boolean;
245
- destructiveHint?: boolean;
246
- openWorldHint?: boolean;
247
- [key: string]: unknown;
248
- };
223
+ description?: string;
224
+ inputSchema?: unknown;
225
+ outputSchema?: unknown;
226
+ annotations?: {
227
+ title?: string;
228
+ readOnlyHint?: boolean;
229
+ idempotentHint?: boolean;
230
+ destructiveHint?: boolean;
231
+ openWorldHint?: boolean;
232
+ [key: string]: unknown;
233
+ };
249
234
  }
250
235
  export interface ToolCall {
251
- id?: string;
252
- name: string;
253
- arguments: Record<string, unknown> | unknown;
254
- server?: string;
236
+ id?: string;
237
+ name: string;
238
+ arguments: Record<string, unknown> | unknown;
239
+ server?: string;
255
240
  }
256
241
  export interface LlmMessage {
257
- role: 'system' | 'user' | 'assistant' | 'tool';
258
- content: string;
259
- attachments?: ScenarioAttachment[];
260
- tool_call_id?: string;
261
- name?: string;
262
- tool_calls?: ToolCall[];
242
+ role: 'system' | 'user' | 'assistant' | 'tool';
243
+ content: string;
244
+ attachments?: ScenarioAttachment[];
245
+ tool_call_id?: string;
246
+ name?: string;
247
+ tool_calls?: ToolCall[];
263
248
  }
264
249
  export interface LlmResponse {
265
- content?: string;
266
- tool_calls?: ToolCall[];
267
- raw?: unknown;
268
- usage?: {
250
+ content?: string;
251
+ tool_calls?: ToolCall[];
252
+ raw?: unknown;
253
+ usage?: {
254
+ input_tokens?: number;
255
+ output_tokens?: number;
256
+ total_tokens?: number;
257
+ };
258
+ }
259
+ export interface TraceMessageUsage {
269
260
  input_tokens?: number;
270
261
  output_tokens?: number;
271
262
  total_tokens?: number;
272
- };
273
- }
274
- export interface TraceMessageUsage {
275
- input_tokens?: number;
276
- output_tokens?: number;
277
- total_tokens?: number;
278
263
  }
279
264
  export interface EstimatedTokens {
280
- input: number;
281
- output: number;
282
- total: number;
283
- method: 'js_tiktoken_estimate' | 'js_tiktoken_fallback';
284
- }
285
- export type TraceMessageContentBlock =
286
- | {
287
- type: 'text';
288
- text: string;
289
- }
290
- | {
291
- type: 'image';
292
- media_type: string;
293
- data: string;
294
- name?: string;
295
- }
296
- | {
297
- type: 'document';
298
- media_type: string;
299
- data: string;
300
- name?: string;
301
- }
302
- | {
303
- type: 'tool_use';
304
- id: string;
305
- name: string;
306
- input: unknown;
307
- server: string;
308
- estimated_tokens?: EstimatedTokens;
309
- }
310
- | {
311
- type: 'tool_result';
312
- tool_use_id: string;
313
- name: string;
314
- content: Array<{
265
+ input: number;
266
+ output: number;
267
+ total: number;
268
+ method: 'js_tiktoken_estimate' | 'js_tiktoken_fallback';
269
+ }
270
+ export type TraceMessageContentBlock = {
271
+ type: 'text';
272
+ text: string;
273
+ } | {
274
+ type: 'image';
275
+ media_type: string;
276
+ data: string;
277
+ name?: string;
278
+ } | {
279
+ type: 'document';
280
+ media_type: string;
281
+ data: string;
282
+ name?: string;
283
+ } | {
284
+ type: 'tool_use';
285
+ id: string;
286
+ name: string;
287
+ input: unknown;
288
+ server: string;
289
+ estimated_tokens?: EstimatedTokens;
290
+ } | {
291
+ type: 'tool_result';
292
+ tool_use_id: string;
293
+ name: string;
294
+ content: Array<{
315
295
  type: 'text';
316
296
  text: string;
317
- }>;
318
- is_error: boolean;
319
- duration_ms?: number;
320
- ts_start?: string;
321
- ts_end?: string;
322
- server?: string;
323
- estimated_tokens?: EstimatedTokens;
324
- };
297
+ }>;
298
+ is_error: boolean;
299
+ duration_ms?: number;
300
+ ts_start?: string;
301
+ ts_end?: string;
302
+ server?: string;
303
+ estimated_tokens?: EstimatedTokens;
304
+ };
325
305
  export interface TraceMessage {
326
- role: 'user' | 'assistant' | 'tool';
327
- ts?: string;
328
- usage?: TraceMessageUsage;
329
- content: TraceMessageContentBlock[];
306
+ role: 'user' | 'assistant' | 'tool';
307
+ ts?: string;
308
+ usage?: TraceMessageUsage;
309
+ content: TraceMessageContentBlock[];
330
310
  }
331
311
  export interface ScenarioRunTraceRecord {
332
- type: 'scenario_run';
333
- trace_version: 3;
334
- run_index: number;
335
- request_id?: string;
336
- scenario_id: string;
337
- agent: string;
338
- provider: string;
339
- model: string;
340
- ts_start: string;
341
- ts_end: string;
342
- pass: boolean;
343
- error?: string;
344
- messages: TraceMessage[];
345
- metrics?: {
346
- tool_call_count: number;
347
- total_tool_duration_ms: number;
348
- };
312
+ type: 'scenario_run';
313
+ trace_version: 3;
314
+ run_index: number;
315
+ request_id?: string;
316
+ scenario_id: string;
317
+ agent: string;
318
+ provider: string;
319
+ model: string;
320
+ ts_start: string;
321
+ ts_end: string;
322
+ pass: boolean;
323
+ error?: string;
324
+ messages: TraceMessage[];
325
+ metrics?: {
326
+ tool_call_count: number;
327
+ total_tool_duration_ms: number;
328
+ };
349
329
  }
350
330
  export interface TraceFileLegacyMeta {
351
- type: 'trace_meta';
352
- trace_version: number;
353
- run_id: string;
354
- ts: string;
355
- }
356
- export type PersistedTraceRecord =
357
- | ScenarioRunTraceRecord
358
- | TraceFileLegacyMeta
359
- | Record<string, unknown>;
331
+ type: 'trace_meta';
332
+ trace_version: number;
333
+ run_id: string;
334
+ ts: string;
335
+ }
336
+ export type PersistedTraceRecord = ScenarioRunTraceRecord | TraceFileLegacyMeta | Record<string, unknown>;
360
337
  export interface ScenarioRunResult {
361
- run_index: number;
362
- request_id?: string;
363
- pass: boolean;
364
- error?: string;
365
- failures: string[];
366
- check_results?: CheckResult[];
367
- tool_calls: string[];
368
- tool_call_count: number;
369
- tool_sequence: string[];
370
- tool_usage: Record<string, number>;
371
- tool_durations_ms: number[];
372
- run_duration_ms?: number;
373
- final_text: string;
374
- extracted: Record<string, string | number | boolean | null>;
338
+ run_index: number;
339
+ request_id?: string;
340
+ pass: boolean;
341
+ error?: string;
342
+ failures: string[];
343
+ check_results?: CheckResult[];
344
+ tool_calls: string[];
345
+ tool_call_count: number;
346
+ tool_sequence: string[];
347
+ tool_usage: Record<string, number>;
348
+ tool_durations_ms: number[];
349
+ run_duration_ms?: number;
350
+ final_text: string;
351
+ extracted: Record<string, string | number | boolean | null>;
375
352
  }
376
353
  export interface ScenarioAggregate {
377
- scenario_id: string;
378
- scenario_name?: string;
379
- agent: string;
380
- provider?: string;
381
- model?: string;
382
- eval?: EvalRules;
383
- tool_constraints_stats?: {
384
- required: Record<string, number>;
385
- forbidden: Record<string, number>;
386
- };
387
- runs: ScenarioRunResult[];
388
- pass_rate: number;
389
- distinct_sequences: Record<string, number>;
390
- tool_usage_frequency: Record<string, number>;
391
- extracted_values: Record<string, Record<string, number>>;
392
- last_final_answer: string;
393
- }
394
- export type HealthMcpConnectionInfo =
395
- | {
396
- enabled: false;
397
- }
398
- | {
399
- enabled: true;
400
- transport: 'streamable-http';
401
- host: string;
402
- port: number;
403
- path: string;
404
- proxyUrl: string;
405
- directUrl: string;
406
- serverPackageVersion: string;
407
- environment: {
354
+ scenario_id: string;
355
+ scenario_name?: string;
356
+ agent: string;
357
+ provider?: string;
358
+ model?: string;
359
+ eval?: EvalRules;
360
+ tool_constraints_stats?: {
361
+ required: Record<string, number>;
362
+ forbidden: Record<string, number>;
363
+ };
364
+ runs: ScenarioRunResult[];
365
+ pass_rate: number;
366
+ distinct_sequences: Record<string, number>;
367
+ tool_usage_frequency: Record<string, number>;
368
+ extracted_values: Record<string, Record<string, number>>;
369
+ last_final_answer: string;
370
+ }
371
+ export type HealthMcpConnectionInfo = {
372
+ enabled: false;
373
+ } | {
374
+ enabled: true;
375
+ transport: 'streamable-http';
376
+ host: string;
377
+ port: number;
378
+ path: string;
379
+ proxyUrl: string;
380
+ directUrl: string;
381
+ serverPackageVersion: string;
382
+ environment: {
408
383
  MCP_HOST: string;
409
384
  MCP_PORT: string;
410
385
  MCP_PATH: string;
411
- };
412
386
  };
387
+ };
413
388
  export interface ResultsJson {
414
- metadata: {
415
- run_id: string;
416
- timestamp: string;
417
- run_note?: string;
418
- git_commit?: string;
419
- config_hash: string;
420
- langsmith_trace_urls?: Record<string, string>;
421
- config_path?: string;
422
- config_name?: string;
423
- rerun_agents?: string[];
424
- rerun_scenario_ids?: string[];
425
- rerun_server_override_all?: string[];
426
- rerun_scenario_server_overrides?: Record<string, string[]>;
427
- tool_tokens_total?: number | null;
428
- total_duration_ms?: number;
429
- total_tool_duration_ms?: number;
430
- cli_version: string;
431
- mcp_server_versions: Record<string, string | null>;
432
- };
433
- summary: {
434
- total_scenarios: number;
435
- total_runs: number;
436
- pass_rate: number;
437
- avg_tool_calls_per_run: number;
438
- avg_tool_latency_ms: number | null;
439
- };
440
- scenarios: ScenarioAggregate[];
389
+ metadata: {
390
+ run_id: string;
391
+ timestamp: string;
392
+ run_note?: string;
393
+ git_commit?: string;
394
+ config_hash: string;
395
+ langsmith_trace_urls?: Record<string, string>;
396
+ config_path?: string;
397
+ config_name?: string;
398
+ rerun_agents?: string[];
399
+ rerun_scenario_ids?: string[];
400
+ rerun_server_override_all?: string[];
401
+ rerun_scenario_server_overrides?: Record<string, string[]>;
402
+ tool_tokens_total?: number | null;
403
+ total_duration_ms?: number;
404
+ total_tool_duration_ms?: number;
405
+ cli_version: string;
406
+ mcp_server_versions: Record<string, string | null>;
407
+ };
408
+ summary: {
409
+ total_scenarios: number;
410
+ total_runs: number;
411
+ pass_rate: number;
412
+ avg_tool_calls_per_run: number;
413
+ avg_tool_latency_ms: number | null;
414
+ };
415
+ scenarios: ScenarioAggregate[];
441
416
  }
442
- //# sourceMappingURL=types.d.ts.map
417
+ //# sourceMappingURL=types.d.ts.map