@codeworksh/harness 0.2.0-canary.17.1.gd1cf9b0f → 0.2.0-canary.18.1.gc4473ccb
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/effect.d.mts +768 -768
- package/effect.mjs +284 -42
- package/effect.mjs.map +1 -1
- package/package.json +3 -3
package/effect.d.mts
CHANGED
|
@@ -4807,14 +4807,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4807
4807
|
type: "image";
|
|
4808
4808
|
data: string;
|
|
4809
4809
|
mimeType: string;
|
|
4810
|
+
} | {
|
|
4811
|
+
type: "thinking";
|
|
4812
|
+
thinking: string;
|
|
4813
|
+
thinkingSignature?: string;
|
|
4814
|
+
redacted?: boolean;
|
|
4810
4815
|
} | {
|
|
4811
4816
|
addedToolNames?: string[];
|
|
4812
4817
|
arguments: Record<string, any>;
|
|
4813
4818
|
callID: string;
|
|
4814
4819
|
name: string;
|
|
4815
4820
|
namespace?: string;
|
|
4816
|
-
|
|
4817
|
-
content
|
|
4821
|
+
partial?: {
|
|
4822
|
+
content?: ({
|
|
4818
4823
|
type: "text";
|
|
4819
4824
|
text: string;
|
|
4820
4825
|
textSignature?: string;
|
|
@@ -4824,9 +4829,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4824
4829
|
mimeType: string;
|
|
4825
4830
|
})[];
|
|
4826
4831
|
details?: any;
|
|
4827
|
-
isError: false;
|
|
4828
4832
|
};
|
|
4829
|
-
status: "
|
|
4833
|
+
status: "running";
|
|
4830
4834
|
thoughtSignature?: string;
|
|
4831
4835
|
time: {
|
|
4832
4836
|
start: number;
|
|
@@ -4850,9 +4854,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4850
4854
|
mimeType: string;
|
|
4851
4855
|
})[];
|
|
4852
4856
|
details?: any;
|
|
4853
|
-
isError:
|
|
4857
|
+
isError: false;
|
|
4854
4858
|
};
|
|
4855
|
-
status: "
|
|
4859
|
+
status: "completed";
|
|
4856
4860
|
thoughtSignature?: string;
|
|
4857
4861
|
time: {
|
|
4858
4862
|
start: number;
|
|
@@ -4878,7 +4882,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4878
4882
|
details?: any;
|
|
4879
4883
|
isError: true;
|
|
4880
4884
|
};
|
|
4881
|
-
status: "
|
|
4885
|
+
status: "error";
|
|
4882
4886
|
thoughtSignature?: string;
|
|
4883
4887
|
time: {
|
|
4884
4888
|
start: number;
|
|
@@ -4904,26 +4908,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4904
4908
|
details?: any;
|
|
4905
4909
|
isError: true;
|
|
4906
4910
|
};
|
|
4907
|
-
status: "
|
|
4911
|
+
status: "skipped";
|
|
4908
4912
|
thoughtSignature?: string;
|
|
4909
4913
|
time: {
|
|
4910
4914
|
start: number;
|
|
4911
4915
|
end: number;
|
|
4912
4916
|
};
|
|
4913
4917
|
type: "toolCall";
|
|
4914
|
-
} | {
|
|
4915
|
-
type: "thinking";
|
|
4916
|
-
thinking: string;
|
|
4917
|
-
thinkingSignature?: string;
|
|
4918
|
-
redacted?: boolean;
|
|
4919
4918
|
} | {
|
|
4920
4919
|
addedToolNames?: string[];
|
|
4921
4920
|
arguments: Record<string, any>;
|
|
4922
4921
|
callID: string;
|
|
4923
4922
|
name: string;
|
|
4924
4923
|
namespace?: string;
|
|
4925
|
-
|
|
4926
|
-
content
|
|
4924
|
+
result: {
|
|
4925
|
+
content: ({
|
|
4927
4926
|
type: "text";
|
|
4928
4927
|
text: string;
|
|
4929
4928
|
textSignature?: string;
|
|
@@ -4933,8 +4932,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4933
4932
|
mimeType: string;
|
|
4934
4933
|
})[];
|
|
4935
4934
|
details?: any;
|
|
4935
|
+
isError: true;
|
|
4936
4936
|
};
|
|
4937
|
-
status: "
|
|
4937
|
+
status: "aborted";
|
|
4938
4938
|
thoughtSignature?: string;
|
|
4939
4939
|
time: {
|
|
4940
4940
|
start: number;
|
|
@@ -5109,14 +5109,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5109
5109
|
type: "image";
|
|
5110
5110
|
data: string;
|
|
5111
5111
|
mimeType: string;
|
|
5112
|
+
} | {
|
|
5113
|
+
type: "thinking";
|
|
5114
|
+
thinking: string;
|
|
5115
|
+
thinkingSignature?: string;
|
|
5116
|
+
redacted?: boolean;
|
|
5112
5117
|
} | {
|
|
5113
5118
|
addedToolNames?: string[];
|
|
5114
5119
|
arguments: Record<string, any>;
|
|
5115
5120
|
callID: string;
|
|
5116
5121
|
name: string;
|
|
5117
5122
|
namespace?: string;
|
|
5118
|
-
|
|
5119
|
-
content
|
|
5123
|
+
partial?: {
|
|
5124
|
+
content?: ({
|
|
5120
5125
|
type: "text";
|
|
5121
5126
|
text: string;
|
|
5122
5127
|
textSignature?: string;
|
|
@@ -5126,9 +5131,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5126
5131
|
mimeType: string;
|
|
5127
5132
|
})[];
|
|
5128
5133
|
details?: any;
|
|
5129
|
-
isError: false;
|
|
5130
5134
|
};
|
|
5131
|
-
status: "
|
|
5135
|
+
status: "running";
|
|
5132
5136
|
thoughtSignature?: string;
|
|
5133
5137
|
time: {
|
|
5134
5138
|
start: number;
|
|
@@ -5152,9 +5156,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5152
5156
|
mimeType: string;
|
|
5153
5157
|
})[];
|
|
5154
5158
|
details?: any;
|
|
5155
|
-
isError:
|
|
5159
|
+
isError: false;
|
|
5156
5160
|
};
|
|
5157
|
-
status: "
|
|
5161
|
+
status: "completed";
|
|
5158
5162
|
thoughtSignature?: string;
|
|
5159
5163
|
time: {
|
|
5160
5164
|
start: number;
|
|
@@ -5180,7 +5184,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5180
5184
|
details?: any;
|
|
5181
5185
|
isError: true;
|
|
5182
5186
|
};
|
|
5183
|
-
status: "
|
|
5187
|
+
status: "error";
|
|
5184
5188
|
thoughtSignature?: string;
|
|
5185
5189
|
time: {
|
|
5186
5190
|
start: number;
|
|
@@ -5206,26 +5210,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5206
5210
|
details?: any;
|
|
5207
5211
|
isError: true;
|
|
5208
5212
|
};
|
|
5209
|
-
status: "
|
|
5213
|
+
status: "skipped";
|
|
5210
5214
|
thoughtSignature?: string;
|
|
5211
5215
|
time: {
|
|
5212
5216
|
start: number;
|
|
5213
5217
|
end: number;
|
|
5214
5218
|
};
|
|
5215
5219
|
type: "toolCall";
|
|
5216
|
-
} | {
|
|
5217
|
-
type: "thinking";
|
|
5218
|
-
thinking: string;
|
|
5219
|
-
thinkingSignature?: string;
|
|
5220
|
-
redacted?: boolean;
|
|
5221
5220
|
} | {
|
|
5222
5221
|
addedToolNames?: string[];
|
|
5223
5222
|
arguments: Record<string, any>;
|
|
5224
5223
|
callID: string;
|
|
5225
5224
|
name: string;
|
|
5226
5225
|
namespace?: string;
|
|
5227
|
-
|
|
5228
|
-
content
|
|
5226
|
+
result: {
|
|
5227
|
+
content: ({
|
|
5229
5228
|
type: "text";
|
|
5230
5229
|
text: string;
|
|
5231
5230
|
textSignature?: string;
|
|
@@ -5235,8 +5234,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5235
5234
|
mimeType: string;
|
|
5236
5235
|
})[];
|
|
5237
5236
|
details?: any;
|
|
5237
|
+
isError: true;
|
|
5238
5238
|
};
|
|
5239
|
-
status: "
|
|
5239
|
+
status: "aborted";
|
|
5240
5240
|
thoughtSignature?: string;
|
|
5241
5241
|
time: {
|
|
5242
5242
|
start: number;
|
|
@@ -5429,14 +5429,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5429
5429
|
type: "image";
|
|
5430
5430
|
data: string;
|
|
5431
5431
|
mimeType: string;
|
|
5432
|
+
} | {
|
|
5433
|
+
type: "thinking";
|
|
5434
|
+
thinking: string;
|
|
5435
|
+
thinkingSignature?: string;
|
|
5436
|
+
redacted?: boolean;
|
|
5432
5437
|
} | {
|
|
5433
5438
|
addedToolNames?: string[];
|
|
5434
5439
|
arguments: Record<string, any>;
|
|
5435
5440
|
callID: string;
|
|
5436
5441
|
name: string;
|
|
5437
5442
|
namespace?: string;
|
|
5438
|
-
|
|
5439
|
-
content
|
|
5443
|
+
partial?: {
|
|
5444
|
+
content?: ({
|
|
5440
5445
|
type: "text";
|
|
5441
5446
|
text: string;
|
|
5442
5447
|
textSignature?: string;
|
|
@@ -5446,9 +5451,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5446
5451
|
mimeType: string;
|
|
5447
5452
|
})[];
|
|
5448
5453
|
details?: any;
|
|
5449
|
-
isError: false;
|
|
5450
5454
|
};
|
|
5451
|
-
status: "
|
|
5455
|
+
status: "running";
|
|
5452
5456
|
thoughtSignature?: string;
|
|
5453
5457
|
time: {
|
|
5454
5458
|
start: number;
|
|
@@ -5472,9 +5476,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5472
5476
|
mimeType: string;
|
|
5473
5477
|
})[];
|
|
5474
5478
|
details?: any;
|
|
5475
|
-
isError:
|
|
5479
|
+
isError: false;
|
|
5476
5480
|
};
|
|
5477
|
-
status: "
|
|
5481
|
+
status: "completed";
|
|
5478
5482
|
thoughtSignature?: string;
|
|
5479
5483
|
time: {
|
|
5480
5484
|
start: number;
|
|
@@ -5500,7 +5504,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5500
5504
|
details?: any;
|
|
5501
5505
|
isError: true;
|
|
5502
5506
|
};
|
|
5503
|
-
status: "
|
|
5507
|
+
status: "error";
|
|
5504
5508
|
thoughtSignature?: string;
|
|
5505
5509
|
time: {
|
|
5506
5510
|
start: number;
|
|
@@ -5526,26 +5530,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5526
5530
|
details?: any;
|
|
5527
5531
|
isError: true;
|
|
5528
5532
|
};
|
|
5529
|
-
status: "
|
|
5533
|
+
status: "skipped";
|
|
5530
5534
|
thoughtSignature?: string;
|
|
5531
5535
|
time: {
|
|
5532
5536
|
start: number;
|
|
5533
5537
|
end: number;
|
|
5534
5538
|
};
|
|
5535
5539
|
type: "toolCall";
|
|
5536
|
-
} | {
|
|
5537
|
-
type: "thinking";
|
|
5538
|
-
thinking: string;
|
|
5539
|
-
thinkingSignature?: string;
|
|
5540
|
-
redacted?: boolean;
|
|
5541
5540
|
} | {
|
|
5542
5541
|
addedToolNames?: string[];
|
|
5543
5542
|
arguments: Record<string, any>;
|
|
5544
5543
|
callID: string;
|
|
5545
5544
|
name: string;
|
|
5546
5545
|
namespace?: string;
|
|
5547
|
-
|
|
5548
|
-
content
|
|
5546
|
+
result: {
|
|
5547
|
+
content: ({
|
|
5549
5548
|
type: "text";
|
|
5550
5549
|
text: string;
|
|
5551
5550
|
textSignature?: string;
|
|
@@ -5555,8 +5554,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5555
5554
|
mimeType: string;
|
|
5556
5555
|
})[];
|
|
5557
5556
|
details?: any;
|
|
5557
|
+
isError: true;
|
|
5558
5558
|
};
|
|
5559
|
-
status: "
|
|
5559
|
+
status: "aborted";
|
|
5560
5560
|
thoughtSignature?: string;
|
|
5561
5561
|
time: {
|
|
5562
5562
|
start: number;
|
|
@@ -5731,14 +5731,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5731
5731
|
type: "image";
|
|
5732
5732
|
data: string;
|
|
5733
5733
|
mimeType: string;
|
|
5734
|
+
} | {
|
|
5735
|
+
type: "thinking";
|
|
5736
|
+
thinking: string;
|
|
5737
|
+
thinkingSignature?: string;
|
|
5738
|
+
redacted?: boolean;
|
|
5734
5739
|
} | {
|
|
5735
5740
|
addedToolNames?: string[];
|
|
5736
5741
|
arguments: Record<string, any>;
|
|
5737
5742
|
callID: string;
|
|
5738
5743
|
name: string;
|
|
5739
5744
|
namespace?: string;
|
|
5740
|
-
|
|
5741
|
-
content
|
|
5745
|
+
partial?: {
|
|
5746
|
+
content?: ({
|
|
5742
5747
|
type: "text";
|
|
5743
5748
|
text: string;
|
|
5744
5749
|
textSignature?: string;
|
|
@@ -5748,9 +5753,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5748
5753
|
mimeType: string;
|
|
5749
5754
|
})[];
|
|
5750
5755
|
details?: any;
|
|
5751
|
-
isError: false;
|
|
5752
5756
|
};
|
|
5753
|
-
status: "
|
|
5757
|
+
status: "running";
|
|
5754
5758
|
thoughtSignature?: string;
|
|
5755
5759
|
time: {
|
|
5756
5760
|
start: number;
|
|
@@ -5774,9 +5778,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5774
5778
|
mimeType: string;
|
|
5775
5779
|
})[];
|
|
5776
5780
|
details?: any;
|
|
5777
|
-
isError:
|
|
5781
|
+
isError: false;
|
|
5778
5782
|
};
|
|
5779
|
-
status: "
|
|
5783
|
+
status: "completed";
|
|
5780
5784
|
thoughtSignature?: string;
|
|
5781
5785
|
time: {
|
|
5782
5786
|
start: number;
|
|
@@ -5802,7 +5806,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5802
5806
|
details?: any;
|
|
5803
5807
|
isError: true;
|
|
5804
5808
|
};
|
|
5805
|
-
status: "
|
|
5809
|
+
status: "error";
|
|
5806
5810
|
thoughtSignature?: string;
|
|
5807
5811
|
time: {
|
|
5808
5812
|
start: number;
|
|
@@ -5828,26 +5832,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5828
5832
|
details?: any;
|
|
5829
5833
|
isError: true;
|
|
5830
5834
|
};
|
|
5831
|
-
status: "
|
|
5835
|
+
status: "skipped";
|
|
5832
5836
|
thoughtSignature?: string;
|
|
5833
5837
|
time: {
|
|
5834
5838
|
start: number;
|
|
5835
5839
|
end: number;
|
|
5836
5840
|
};
|
|
5837
5841
|
type: "toolCall";
|
|
5838
|
-
} | {
|
|
5839
|
-
type: "thinking";
|
|
5840
|
-
thinking: string;
|
|
5841
|
-
thinkingSignature?: string;
|
|
5842
|
-
redacted?: boolean;
|
|
5843
5842
|
} | {
|
|
5844
5843
|
addedToolNames?: string[];
|
|
5845
5844
|
arguments: Record<string, any>;
|
|
5846
5845
|
callID: string;
|
|
5847
5846
|
name: string;
|
|
5848
5847
|
namespace?: string;
|
|
5849
|
-
|
|
5850
|
-
content
|
|
5848
|
+
result: {
|
|
5849
|
+
content: ({
|
|
5851
5850
|
type: "text";
|
|
5852
5851
|
text: string;
|
|
5853
5852
|
textSignature?: string;
|
|
@@ -5857,8 +5856,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5857
5856
|
mimeType: string;
|
|
5858
5857
|
})[];
|
|
5859
5858
|
details?: any;
|
|
5859
|
+
isError: true;
|
|
5860
5860
|
};
|
|
5861
|
-
status: "
|
|
5861
|
+
status: "aborted";
|
|
5862
5862
|
thoughtSignature?: string;
|
|
5863
5863
|
time: {
|
|
5864
5864
|
start: number;
|
|
@@ -6354,14 +6354,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6354
6354
|
type: "image";
|
|
6355
6355
|
data: string;
|
|
6356
6356
|
mimeType: string;
|
|
6357
|
+
} | {
|
|
6358
|
+
type: "thinking";
|
|
6359
|
+
thinking: string;
|
|
6360
|
+
thinkingSignature?: string;
|
|
6361
|
+
redacted?: boolean;
|
|
6357
6362
|
} | {
|
|
6358
6363
|
addedToolNames?: string[];
|
|
6359
6364
|
arguments: Record<string, any>;
|
|
6360
6365
|
callID: string;
|
|
6361
6366
|
name: string;
|
|
6362
6367
|
namespace?: string;
|
|
6363
|
-
|
|
6364
|
-
content
|
|
6368
|
+
partial?: {
|
|
6369
|
+
content?: ({
|
|
6365
6370
|
type: "text";
|
|
6366
6371
|
text: string;
|
|
6367
6372
|
textSignature?: string;
|
|
@@ -6371,9 +6376,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6371
6376
|
mimeType: string;
|
|
6372
6377
|
})[];
|
|
6373
6378
|
details?: any;
|
|
6374
|
-
isError: false;
|
|
6375
6379
|
};
|
|
6376
|
-
status: "
|
|
6380
|
+
status: "running";
|
|
6377
6381
|
thoughtSignature?: string;
|
|
6378
6382
|
time: {
|
|
6379
6383
|
start: number;
|
|
@@ -6397,9 +6401,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6397
6401
|
mimeType: string;
|
|
6398
6402
|
})[];
|
|
6399
6403
|
details?: any;
|
|
6400
|
-
isError:
|
|
6404
|
+
isError: false;
|
|
6401
6405
|
};
|
|
6402
|
-
status: "
|
|
6406
|
+
status: "completed";
|
|
6403
6407
|
thoughtSignature?: string;
|
|
6404
6408
|
time: {
|
|
6405
6409
|
start: number;
|
|
@@ -6425,7 +6429,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6425
6429
|
details?: any;
|
|
6426
6430
|
isError: true;
|
|
6427
6431
|
};
|
|
6428
|
-
status: "
|
|
6432
|
+
status: "error";
|
|
6429
6433
|
thoughtSignature?: string;
|
|
6430
6434
|
time: {
|
|
6431
6435
|
start: number;
|
|
@@ -6451,26 +6455,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6451
6455
|
details?: any;
|
|
6452
6456
|
isError: true;
|
|
6453
6457
|
};
|
|
6454
|
-
status: "
|
|
6458
|
+
status: "skipped";
|
|
6455
6459
|
thoughtSignature?: string;
|
|
6456
6460
|
time: {
|
|
6457
6461
|
start: number;
|
|
6458
6462
|
end: number;
|
|
6459
6463
|
};
|
|
6460
6464
|
type: "toolCall";
|
|
6461
|
-
} | {
|
|
6462
|
-
type: "thinking";
|
|
6463
|
-
thinking: string;
|
|
6464
|
-
thinkingSignature?: string;
|
|
6465
|
-
redacted?: boolean;
|
|
6466
6465
|
} | {
|
|
6467
6466
|
addedToolNames?: string[];
|
|
6468
6467
|
arguments: Record<string, any>;
|
|
6469
6468
|
callID: string;
|
|
6470
6469
|
name: string;
|
|
6471
6470
|
namespace?: string;
|
|
6472
|
-
|
|
6473
|
-
content
|
|
6471
|
+
result: {
|
|
6472
|
+
content: ({
|
|
6474
6473
|
type: "text";
|
|
6475
6474
|
text: string;
|
|
6476
6475
|
textSignature?: string;
|
|
@@ -6480,8 +6479,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6480
6479
|
mimeType: string;
|
|
6481
6480
|
})[];
|
|
6482
6481
|
details?: any;
|
|
6482
|
+
isError: true;
|
|
6483
6483
|
};
|
|
6484
|
-
status: "
|
|
6484
|
+
status: "aborted";
|
|
6485
6485
|
thoughtSignature?: string;
|
|
6486
6486
|
time: {
|
|
6487
6487
|
start: number;
|
|
@@ -6656,14 +6656,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6656
6656
|
type: "image";
|
|
6657
6657
|
data: string;
|
|
6658
6658
|
mimeType: string;
|
|
6659
|
+
} | {
|
|
6660
|
+
type: "thinking";
|
|
6661
|
+
thinking: string;
|
|
6662
|
+
thinkingSignature?: string;
|
|
6663
|
+
redacted?: boolean;
|
|
6659
6664
|
} | {
|
|
6660
6665
|
addedToolNames?: string[];
|
|
6661
6666
|
arguments: Record<string, any>;
|
|
6662
6667
|
callID: string;
|
|
6663
6668
|
name: string;
|
|
6664
6669
|
namespace?: string;
|
|
6665
|
-
|
|
6666
|
-
content
|
|
6670
|
+
partial?: {
|
|
6671
|
+
content?: ({
|
|
6667
6672
|
type: "text";
|
|
6668
6673
|
text: string;
|
|
6669
6674
|
textSignature?: string;
|
|
@@ -6673,9 +6678,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6673
6678
|
mimeType: string;
|
|
6674
6679
|
})[];
|
|
6675
6680
|
details?: any;
|
|
6676
|
-
isError: false;
|
|
6677
6681
|
};
|
|
6678
|
-
status: "
|
|
6682
|
+
status: "running";
|
|
6679
6683
|
thoughtSignature?: string;
|
|
6680
6684
|
time: {
|
|
6681
6685
|
start: number;
|
|
@@ -6699,9 +6703,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6699
6703
|
mimeType: string;
|
|
6700
6704
|
})[];
|
|
6701
6705
|
details?: any;
|
|
6702
|
-
isError:
|
|
6706
|
+
isError: false;
|
|
6703
6707
|
};
|
|
6704
|
-
status: "
|
|
6708
|
+
status: "completed";
|
|
6705
6709
|
thoughtSignature?: string;
|
|
6706
6710
|
time: {
|
|
6707
6711
|
start: number;
|
|
@@ -6727,7 +6731,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6727
6731
|
details?: any;
|
|
6728
6732
|
isError: true;
|
|
6729
6733
|
};
|
|
6730
|
-
status: "
|
|
6734
|
+
status: "error";
|
|
6731
6735
|
thoughtSignature?: string;
|
|
6732
6736
|
time: {
|
|
6733
6737
|
start: number;
|
|
@@ -6753,26 +6757,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6753
6757
|
details?: any;
|
|
6754
6758
|
isError: true;
|
|
6755
6759
|
};
|
|
6756
|
-
status: "
|
|
6760
|
+
status: "skipped";
|
|
6757
6761
|
thoughtSignature?: string;
|
|
6758
6762
|
time: {
|
|
6759
6763
|
start: number;
|
|
6760
6764
|
end: number;
|
|
6761
6765
|
};
|
|
6762
6766
|
type: "toolCall";
|
|
6763
|
-
} | {
|
|
6764
|
-
type: "thinking";
|
|
6765
|
-
thinking: string;
|
|
6766
|
-
thinkingSignature?: string;
|
|
6767
|
-
redacted?: boolean;
|
|
6768
6767
|
} | {
|
|
6769
6768
|
addedToolNames?: string[];
|
|
6770
6769
|
arguments: Record<string, any>;
|
|
6771
6770
|
callID: string;
|
|
6772
6771
|
name: string;
|
|
6773
6772
|
namespace?: string;
|
|
6774
|
-
|
|
6775
|
-
content
|
|
6773
|
+
result: {
|
|
6774
|
+
content: ({
|
|
6776
6775
|
type: "text";
|
|
6777
6776
|
text: string;
|
|
6778
6777
|
textSignature?: string;
|
|
@@ -6782,8 +6781,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6782
6781
|
mimeType: string;
|
|
6783
6782
|
})[];
|
|
6784
6783
|
details?: any;
|
|
6784
|
+
isError: true;
|
|
6785
6785
|
};
|
|
6786
|
-
status: "
|
|
6786
|
+
status: "aborted";
|
|
6787
6787
|
thoughtSignature?: string;
|
|
6788
6788
|
time: {
|
|
6789
6789
|
start: number;
|
|
@@ -6977,14 +6977,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6977
6977
|
type: "image";
|
|
6978
6978
|
data: string;
|
|
6979
6979
|
mimeType: string;
|
|
6980
|
+
} | {
|
|
6981
|
+
type: "thinking";
|
|
6982
|
+
thinking: string;
|
|
6983
|
+
thinkingSignature?: string;
|
|
6984
|
+
redacted?: boolean;
|
|
6980
6985
|
} | {
|
|
6981
6986
|
addedToolNames?: string[];
|
|
6982
6987
|
arguments: Record<string, any>;
|
|
6983
6988
|
callID: string;
|
|
6984
6989
|
name: string;
|
|
6985
6990
|
namespace?: string;
|
|
6986
|
-
|
|
6987
|
-
content
|
|
6991
|
+
partial?: {
|
|
6992
|
+
content?: ({
|
|
6988
6993
|
type: "text";
|
|
6989
6994
|
text: string;
|
|
6990
6995
|
textSignature?: string;
|
|
@@ -6994,9 +6999,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6994
6999
|
mimeType: string;
|
|
6995
7000
|
})[];
|
|
6996
7001
|
details?: any;
|
|
6997
|
-
isError: false;
|
|
6998
7002
|
};
|
|
6999
|
-
status: "
|
|
7003
|
+
status: "running";
|
|
7000
7004
|
thoughtSignature?: string;
|
|
7001
7005
|
time: {
|
|
7002
7006
|
start: number;
|
|
@@ -7020,9 +7024,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7020
7024
|
mimeType: string;
|
|
7021
7025
|
})[];
|
|
7022
7026
|
details?: any;
|
|
7023
|
-
isError:
|
|
7027
|
+
isError: false;
|
|
7024
7028
|
};
|
|
7025
|
-
status: "
|
|
7029
|
+
status: "completed";
|
|
7026
7030
|
thoughtSignature?: string;
|
|
7027
7031
|
time: {
|
|
7028
7032
|
start: number;
|
|
@@ -7048,7 +7052,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7048
7052
|
details?: any;
|
|
7049
7053
|
isError: true;
|
|
7050
7054
|
};
|
|
7051
|
-
status: "
|
|
7055
|
+
status: "error";
|
|
7052
7056
|
thoughtSignature?: string;
|
|
7053
7057
|
time: {
|
|
7054
7058
|
start: number;
|
|
@@ -7074,26 +7078,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7074
7078
|
details?: any;
|
|
7075
7079
|
isError: true;
|
|
7076
7080
|
};
|
|
7077
|
-
status: "
|
|
7081
|
+
status: "skipped";
|
|
7078
7082
|
thoughtSignature?: string;
|
|
7079
7083
|
time: {
|
|
7080
7084
|
start: number;
|
|
7081
7085
|
end: number;
|
|
7082
7086
|
};
|
|
7083
7087
|
type: "toolCall";
|
|
7084
|
-
} | {
|
|
7085
|
-
type: "thinking";
|
|
7086
|
-
thinking: string;
|
|
7087
|
-
thinkingSignature?: string;
|
|
7088
|
-
redacted?: boolean;
|
|
7089
7088
|
} | {
|
|
7090
7089
|
addedToolNames?: string[];
|
|
7091
7090
|
arguments: Record<string, any>;
|
|
7092
7091
|
callID: string;
|
|
7093
7092
|
name: string;
|
|
7094
7093
|
namespace?: string;
|
|
7095
|
-
|
|
7096
|
-
content
|
|
7094
|
+
result: {
|
|
7095
|
+
content: ({
|
|
7097
7096
|
type: "text";
|
|
7098
7097
|
text: string;
|
|
7099
7098
|
textSignature?: string;
|
|
@@ -7103,8 +7102,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7103
7102
|
mimeType: string;
|
|
7104
7103
|
})[];
|
|
7105
7104
|
details?: any;
|
|
7105
|
+
isError: true;
|
|
7106
7106
|
};
|
|
7107
|
-
status: "
|
|
7107
|
+
status: "aborted";
|
|
7108
7108
|
thoughtSignature?: string;
|
|
7109
7109
|
time: {
|
|
7110
7110
|
start: number;
|
|
@@ -7279,14 +7279,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7279
7279
|
type: "image";
|
|
7280
7280
|
data: string;
|
|
7281
7281
|
mimeType: string;
|
|
7282
|
+
} | {
|
|
7283
|
+
type: "thinking";
|
|
7284
|
+
thinking: string;
|
|
7285
|
+
thinkingSignature?: string;
|
|
7286
|
+
redacted?: boolean;
|
|
7282
7287
|
} | {
|
|
7283
7288
|
addedToolNames?: string[];
|
|
7284
7289
|
arguments: Record<string, any>;
|
|
7285
7290
|
callID: string;
|
|
7286
7291
|
name: string;
|
|
7287
7292
|
namespace?: string;
|
|
7288
|
-
|
|
7289
|
-
content
|
|
7293
|
+
partial?: {
|
|
7294
|
+
content?: ({
|
|
7290
7295
|
type: "text";
|
|
7291
7296
|
text: string;
|
|
7292
7297
|
textSignature?: string;
|
|
@@ -7296,9 +7301,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7296
7301
|
mimeType: string;
|
|
7297
7302
|
})[];
|
|
7298
7303
|
details?: any;
|
|
7299
|
-
isError: false;
|
|
7300
7304
|
};
|
|
7301
|
-
status: "
|
|
7305
|
+
status: "running";
|
|
7302
7306
|
thoughtSignature?: string;
|
|
7303
7307
|
time: {
|
|
7304
7308
|
start: number;
|
|
@@ -7322,9 +7326,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7322
7326
|
mimeType: string;
|
|
7323
7327
|
})[];
|
|
7324
7328
|
details?: any;
|
|
7325
|
-
isError:
|
|
7329
|
+
isError: false;
|
|
7326
7330
|
};
|
|
7327
|
-
status: "
|
|
7331
|
+
status: "completed";
|
|
7328
7332
|
thoughtSignature?: string;
|
|
7329
7333
|
time: {
|
|
7330
7334
|
start: number;
|
|
@@ -7350,7 +7354,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7350
7354
|
details?: any;
|
|
7351
7355
|
isError: true;
|
|
7352
7356
|
};
|
|
7353
|
-
status: "
|
|
7357
|
+
status: "error";
|
|
7354
7358
|
thoughtSignature?: string;
|
|
7355
7359
|
time: {
|
|
7356
7360
|
start: number;
|
|
@@ -7376,26 +7380,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7376
7380
|
details?: any;
|
|
7377
7381
|
isError: true;
|
|
7378
7382
|
};
|
|
7379
|
-
status: "
|
|
7383
|
+
status: "skipped";
|
|
7380
7384
|
thoughtSignature?: string;
|
|
7381
7385
|
time: {
|
|
7382
7386
|
start: number;
|
|
7383
7387
|
end: number;
|
|
7384
7388
|
};
|
|
7385
7389
|
type: "toolCall";
|
|
7386
|
-
} | {
|
|
7387
|
-
type: "thinking";
|
|
7388
|
-
thinking: string;
|
|
7389
|
-
thinkingSignature?: string;
|
|
7390
|
-
redacted?: boolean;
|
|
7391
7390
|
} | {
|
|
7392
7391
|
addedToolNames?: string[];
|
|
7393
7392
|
arguments: Record<string, any>;
|
|
7394
7393
|
callID: string;
|
|
7395
7394
|
name: string;
|
|
7396
7395
|
namespace?: string;
|
|
7397
|
-
|
|
7398
|
-
content
|
|
7396
|
+
result: {
|
|
7397
|
+
content: ({
|
|
7399
7398
|
type: "text";
|
|
7400
7399
|
text: string;
|
|
7401
7400
|
textSignature?: string;
|
|
@@ -7405,8 +7404,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7405
7404
|
mimeType: string;
|
|
7406
7405
|
})[];
|
|
7407
7406
|
details?: any;
|
|
7407
|
+
isError: true;
|
|
7408
7408
|
};
|
|
7409
|
-
status: "
|
|
7409
|
+
status: "aborted";
|
|
7410
7410
|
thoughtSignature?: string;
|
|
7411
7411
|
time: {
|
|
7412
7412
|
start: number;
|
|
@@ -7612,14 +7612,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7612
7612
|
type: "image";
|
|
7613
7613
|
data: string;
|
|
7614
7614
|
mimeType: string;
|
|
7615
|
+
} | {
|
|
7616
|
+
type: "thinking";
|
|
7617
|
+
thinking: string;
|
|
7618
|
+
thinkingSignature?: string;
|
|
7619
|
+
redacted?: boolean;
|
|
7615
7620
|
} | {
|
|
7616
7621
|
addedToolNames?: string[];
|
|
7617
7622
|
arguments: Record<string, any>;
|
|
7618
7623
|
callID: string;
|
|
7619
7624
|
name: string;
|
|
7620
7625
|
namespace?: string;
|
|
7621
|
-
|
|
7622
|
-
content
|
|
7626
|
+
partial?: {
|
|
7627
|
+
content?: ({
|
|
7623
7628
|
type: "text";
|
|
7624
7629
|
text: string;
|
|
7625
7630
|
textSignature?: string;
|
|
@@ -7629,9 +7634,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7629
7634
|
mimeType: string;
|
|
7630
7635
|
})[];
|
|
7631
7636
|
details?: any;
|
|
7632
|
-
isError: false;
|
|
7633
7637
|
};
|
|
7634
|
-
status: "
|
|
7638
|
+
status: "running";
|
|
7635
7639
|
thoughtSignature?: string;
|
|
7636
7640
|
time: {
|
|
7637
7641
|
start: number;
|
|
@@ -7655,9 +7659,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7655
7659
|
mimeType: string;
|
|
7656
7660
|
})[];
|
|
7657
7661
|
details?: any;
|
|
7658
|
-
isError:
|
|
7662
|
+
isError: false;
|
|
7659
7663
|
};
|
|
7660
|
-
status: "
|
|
7664
|
+
status: "completed";
|
|
7661
7665
|
thoughtSignature?: string;
|
|
7662
7666
|
time: {
|
|
7663
7667
|
start: number;
|
|
@@ -7683,7 +7687,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7683
7687
|
details?: any;
|
|
7684
7688
|
isError: true;
|
|
7685
7689
|
};
|
|
7686
|
-
status: "
|
|
7690
|
+
status: "error";
|
|
7687
7691
|
thoughtSignature?: string;
|
|
7688
7692
|
time: {
|
|
7689
7693
|
start: number;
|
|
@@ -7709,26 +7713,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7709
7713
|
details?: any;
|
|
7710
7714
|
isError: true;
|
|
7711
7715
|
};
|
|
7712
|
-
status: "
|
|
7716
|
+
status: "skipped";
|
|
7713
7717
|
thoughtSignature?: string;
|
|
7714
7718
|
time: {
|
|
7715
7719
|
start: number;
|
|
7716
7720
|
end: number;
|
|
7717
7721
|
};
|
|
7718
7722
|
type: "toolCall";
|
|
7719
|
-
} | {
|
|
7720
|
-
type: "thinking";
|
|
7721
|
-
thinking: string;
|
|
7722
|
-
thinkingSignature?: string;
|
|
7723
|
-
redacted?: boolean;
|
|
7724
7723
|
} | {
|
|
7725
7724
|
addedToolNames?: string[];
|
|
7726
7725
|
arguments: Record<string, any>;
|
|
7727
7726
|
callID: string;
|
|
7728
7727
|
name: string;
|
|
7729
7728
|
namespace?: string;
|
|
7730
|
-
|
|
7731
|
-
content
|
|
7729
|
+
result: {
|
|
7730
|
+
content: ({
|
|
7732
7731
|
type: "text";
|
|
7733
7732
|
text: string;
|
|
7734
7733
|
textSignature?: string;
|
|
@@ -7738,8 +7737,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7738
7737
|
mimeType: string;
|
|
7739
7738
|
})[];
|
|
7740
7739
|
details?: any;
|
|
7740
|
+
isError: true;
|
|
7741
7741
|
};
|
|
7742
|
-
status: "
|
|
7742
|
+
status: "aborted";
|
|
7743
7743
|
thoughtSignature?: string;
|
|
7744
7744
|
time: {
|
|
7745
7745
|
start: number;
|
|
@@ -7914,14 +7914,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7914
7914
|
type: "image";
|
|
7915
7915
|
data: string;
|
|
7916
7916
|
mimeType: string;
|
|
7917
|
+
} | {
|
|
7918
|
+
type: "thinking";
|
|
7919
|
+
thinking: string;
|
|
7920
|
+
thinkingSignature?: string;
|
|
7921
|
+
redacted?: boolean;
|
|
7917
7922
|
} | {
|
|
7918
7923
|
addedToolNames?: string[];
|
|
7919
7924
|
arguments: Record<string, any>;
|
|
7920
7925
|
callID: string;
|
|
7921
7926
|
name: string;
|
|
7922
7927
|
namespace?: string;
|
|
7923
|
-
|
|
7924
|
-
content
|
|
7928
|
+
partial?: {
|
|
7929
|
+
content?: ({
|
|
7925
7930
|
type: "text";
|
|
7926
7931
|
text: string;
|
|
7927
7932
|
textSignature?: string;
|
|
@@ -7931,9 +7936,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7931
7936
|
mimeType: string;
|
|
7932
7937
|
})[];
|
|
7933
7938
|
details?: any;
|
|
7934
|
-
isError: false;
|
|
7935
7939
|
};
|
|
7936
|
-
status: "
|
|
7940
|
+
status: "running";
|
|
7937
7941
|
thoughtSignature?: string;
|
|
7938
7942
|
time: {
|
|
7939
7943
|
start: number;
|
|
@@ -7957,9 +7961,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7957
7961
|
mimeType: string;
|
|
7958
7962
|
})[];
|
|
7959
7963
|
details?: any;
|
|
7960
|
-
isError:
|
|
7964
|
+
isError: false;
|
|
7961
7965
|
};
|
|
7962
|
-
status: "
|
|
7966
|
+
status: "completed";
|
|
7963
7967
|
thoughtSignature?: string;
|
|
7964
7968
|
time: {
|
|
7965
7969
|
start: number;
|
|
@@ -7985,7 +7989,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7985
7989
|
details?: any;
|
|
7986
7990
|
isError: true;
|
|
7987
7991
|
};
|
|
7988
|
-
status: "
|
|
7992
|
+
status: "error";
|
|
7989
7993
|
thoughtSignature?: string;
|
|
7990
7994
|
time: {
|
|
7991
7995
|
start: number;
|
|
@@ -8011,26 +8015,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8011
8015
|
details?: any;
|
|
8012
8016
|
isError: true;
|
|
8013
8017
|
};
|
|
8014
|
-
status: "
|
|
8018
|
+
status: "skipped";
|
|
8015
8019
|
thoughtSignature?: string;
|
|
8016
8020
|
time: {
|
|
8017
8021
|
start: number;
|
|
8018
8022
|
end: number;
|
|
8019
8023
|
};
|
|
8020
8024
|
type: "toolCall";
|
|
8021
|
-
} | {
|
|
8022
|
-
type: "thinking";
|
|
8023
|
-
thinking: string;
|
|
8024
|
-
thinkingSignature?: string;
|
|
8025
|
-
redacted?: boolean;
|
|
8026
8025
|
} | {
|
|
8027
8026
|
addedToolNames?: string[];
|
|
8028
8027
|
arguments: Record<string, any>;
|
|
8029
8028
|
callID: string;
|
|
8030
8029
|
name: string;
|
|
8031
8030
|
namespace?: string;
|
|
8032
|
-
|
|
8033
|
-
content
|
|
8031
|
+
result: {
|
|
8032
|
+
content: ({
|
|
8034
8033
|
type: "text";
|
|
8035
8034
|
text: string;
|
|
8036
8035
|
textSignature?: string;
|
|
@@ -8040,8 +8039,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8040
8039
|
mimeType: string;
|
|
8041
8040
|
})[];
|
|
8042
8041
|
details?: any;
|
|
8042
|
+
isError: true;
|
|
8043
8043
|
};
|
|
8044
|
-
status: "
|
|
8044
|
+
status: "aborted";
|
|
8045
8045
|
thoughtSignature?: string;
|
|
8046
8046
|
time: {
|
|
8047
8047
|
start: number;
|
|
@@ -8235,14 +8235,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8235
8235
|
type: "image";
|
|
8236
8236
|
data: string;
|
|
8237
8237
|
mimeType: string;
|
|
8238
|
+
} | {
|
|
8239
|
+
type: "thinking";
|
|
8240
|
+
thinking: string;
|
|
8241
|
+
thinkingSignature?: string;
|
|
8242
|
+
redacted?: boolean;
|
|
8238
8243
|
} | {
|
|
8239
8244
|
addedToolNames?: string[];
|
|
8240
8245
|
arguments: Record<string, any>;
|
|
8241
8246
|
callID: string;
|
|
8242
8247
|
name: string;
|
|
8243
8248
|
namespace?: string;
|
|
8244
|
-
|
|
8245
|
-
content
|
|
8249
|
+
partial?: {
|
|
8250
|
+
content?: ({
|
|
8246
8251
|
type: "text";
|
|
8247
8252
|
text: string;
|
|
8248
8253
|
textSignature?: string;
|
|
@@ -8252,9 +8257,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8252
8257
|
mimeType: string;
|
|
8253
8258
|
})[];
|
|
8254
8259
|
details?: any;
|
|
8255
|
-
isError: false;
|
|
8256
8260
|
};
|
|
8257
|
-
status: "
|
|
8261
|
+
status: "running";
|
|
8258
8262
|
thoughtSignature?: string;
|
|
8259
8263
|
time: {
|
|
8260
8264
|
start: number;
|
|
@@ -8278,9 +8282,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8278
8282
|
mimeType: string;
|
|
8279
8283
|
})[];
|
|
8280
8284
|
details?: any;
|
|
8281
|
-
isError:
|
|
8285
|
+
isError: false;
|
|
8282
8286
|
};
|
|
8283
|
-
status: "
|
|
8287
|
+
status: "completed";
|
|
8284
8288
|
thoughtSignature?: string;
|
|
8285
8289
|
time: {
|
|
8286
8290
|
start: number;
|
|
@@ -8306,7 +8310,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8306
8310
|
details?: any;
|
|
8307
8311
|
isError: true;
|
|
8308
8312
|
};
|
|
8309
|
-
status: "
|
|
8313
|
+
status: "error";
|
|
8310
8314
|
thoughtSignature?: string;
|
|
8311
8315
|
time: {
|
|
8312
8316
|
start: number;
|
|
@@ -8332,26 +8336,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8332
8336
|
details?: any;
|
|
8333
8337
|
isError: true;
|
|
8334
8338
|
};
|
|
8335
|
-
status: "
|
|
8339
|
+
status: "skipped";
|
|
8336
8340
|
thoughtSignature?: string;
|
|
8337
8341
|
time: {
|
|
8338
8342
|
start: number;
|
|
8339
8343
|
end: number;
|
|
8340
8344
|
};
|
|
8341
8345
|
type: "toolCall";
|
|
8342
|
-
} | {
|
|
8343
|
-
type: "thinking";
|
|
8344
|
-
thinking: string;
|
|
8345
|
-
thinkingSignature?: string;
|
|
8346
|
-
redacted?: boolean;
|
|
8347
8346
|
} | {
|
|
8348
8347
|
addedToolNames?: string[];
|
|
8349
8348
|
arguments: Record<string, any>;
|
|
8350
8349
|
callID: string;
|
|
8351
8350
|
name: string;
|
|
8352
8351
|
namespace?: string;
|
|
8353
|
-
|
|
8354
|
-
content
|
|
8352
|
+
result: {
|
|
8353
|
+
content: ({
|
|
8355
8354
|
type: "text";
|
|
8356
8355
|
text: string;
|
|
8357
8356
|
textSignature?: string;
|
|
@@ -8361,8 +8360,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8361
8360
|
mimeType: string;
|
|
8362
8361
|
})[];
|
|
8363
8362
|
details?: any;
|
|
8363
|
+
isError: true;
|
|
8364
8364
|
};
|
|
8365
|
-
status: "
|
|
8365
|
+
status: "aborted";
|
|
8366
8366
|
thoughtSignature?: string;
|
|
8367
8367
|
time: {
|
|
8368
8368
|
start: number;
|
|
@@ -8537,14 +8537,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8537
8537
|
type: "image";
|
|
8538
8538
|
data: string;
|
|
8539
8539
|
mimeType: string;
|
|
8540
|
+
} | {
|
|
8541
|
+
type: "thinking";
|
|
8542
|
+
thinking: string;
|
|
8543
|
+
thinkingSignature?: string;
|
|
8544
|
+
redacted?: boolean;
|
|
8540
8545
|
} | {
|
|
8541
8546
|
addedToolNames?: string[];
|
|
8542
8547
|
arguments: Record<string, any>;
|
|
8543
8548
|
callID: string;
|
|
8544
8549
|
name: string;
|
|
8545
8550
|
namespace?: string;
|
|
8546
|
-
|
|
8547
|
-
content
|
|
8551
|
+
partial?: {
|
|
8552
|
+
content?: ({
|
|
8548
8553
|
type: "text";
|
|
8549
8554
|
text: string;
|
|
8550
8555
|
textSignature?: string;
|
|
@@ -8554,9 +8559,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8554
8559
|
mimeType: string;
|
|
8555
8560
|
})[];
|
|
8556
8561
|
details?: any;
|
|
8557
|
-
isError: false;
|
|
8558
8562
|
};
|
|
8559
|
-
status: "
|
|
8563
|
+
status: "running";
|
|
8560
8564
|
thoughtSignature?: string;
|
|
8561
8565
|
time: {
|
|
8562
8566
|
start: number;
|
|
@@ -8580,9 +8584,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8580
8584
|
mimeType: string;
|
|
8581
8585
|
})[];
|
|
8582
8586
|
details?: any;
|
|
8583
|
-
isError:
|
|
8587
|
+
isError: false;
|
|
8584
8588
|
};
|
|
8585
|
-
status: "
|
|
8589
|
+
status: "completed";
|
|
8586
8590
|
thoughtSignature?: string;
|
|
8587
8591
|
time: {
|
|
8588
8592
|
start: number;
|
|
@@ -8608,7 +8612,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8608
8612
|
details?: any;
|
|
8609
8613
|
isError: true;
|
|
8610
8614
|
};
|
|
8611
|
-
status: "
|
|
8615
|
+
status: "error";
|
|
8612
8616
|
thoughtSignature?: string;
|
|
8613
8617
|
time: {
|
|
8614
8618
|
start: number;
|
|
@@ -8634,26 +8638,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8634
8638
|
details?: any;
|
|
8635
8639
|
isError: true;
|
|
8636
8640
|
};
|
|
8637
|
-
status: "
|
|
8641
|
+
status: "skipped";
|
|
8638
8642
|
thoughtSignature?: string;
|
|
8639
8643
|
time: {
|
|
8640
8644
|
start: number;
|
|
8641
8645
|
end: number;
|
|
8642
8646
|
};
|
|
8643
8647
|
type: "toolCall";
|
|
8644
|
-
} | {
|
|
8645
|
-
type: "thinking";
|
|
8646
|
-
thinking: string;
|
|
8647
|
-
thinkingSignature?: string;
|
|
8648
|
-
redacted?: boolean;
|
|
8649
8648
|
} | {
|
|
8650
8649
|
addedToolNames?: string[];
|
|
8651
8650
|
arguments: Record<string, any>;
|
|
8652
8651
|
callID: string;
|
|
8653
8652
|
name: string;
|
|
8654
8653
|
namespace?: string;
|
|
8655
|
-
|
|
8656
|
-
content
|
|
8654
|
+
result: {
|
|
8655
|
+
content: ({
|
|
8657
8656
|
type: "text";
|
|
8658
8657
|
text: string;
|
|
8659
8658
|
textSignature?: string;
|
|
@@ -8663,8 +8662,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8663
8662
|
mimeType: string;
|
|
8664
8663
|
})[];
|
|
8665
8664
|
details?: any;
|
|
8665
|
+
isError: true;
|
|
8666
8666
|
};
|
|
8667
|
-
status: "
|
|
8667
|
+
status: "aborted";
|
|
8668
8668
|
thoughtSignature?: string;
|
|
8669
8669
|
time: {
|
|
8670
8670
|
start: number;
|
|
@@ -10412,14 +10412,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10412
10412
|
type: "image";
|
|
10413
10413
|
data: string;
|
|
10414
10414
|
mimeType: string;
|
|
10415
|
+
} | {
|
|
10416
|
+
type: "thinking";
|
|
10417
|
+
thinking: string;
|
|
10418
|
+
thinkingSignature?: string;
|
|
10419
|
+
redacted?: boolean;
|
|
10415
10420
|
} | {
|
|
10416
10421
|
addedToolNames?: string[];
|
|
10417
10422
|
arguments: Record<string, any>;
|
|
10418
10423
|
callID: string;
|
|
10419
10424
|
name: string;
|
|
10420
10425
|
namespace?: string;
|
|
10421
|
-
|
|
10422
|
-
content
|
|
10426
|
+
partial?: {
|
|
10427
|
+
content?: ({
|
|
10423
10428
|
type: "text";
|
|
10424
10429
|
text: string;
|
|
10425
10430
|
textSignature?: string;
|
|
@@ -10429,9 +10434,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10429
10434
|
mimeType: string;
|
|
10430
10435
|
})[];
|
|
10431
10436
|
details?: any;
|
|
10432
|
-
isError: false;
|
|
10433
10437
|
};
|
|
10434
|
-
status: "
|
|
10438
|
+
status: "running";
|
|
10435
10439
|
thoughtSignature?: string;
|
|
10436
10440
|
time: {
|
|
10437
10441
|
start: number;
|
|
@@ -10455,9 +10459,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10455
10459
|
mimeType: string;
|
|
10456
10460
|
})[];
|
|
10457
10461
|
details?: any;
|
|
10458
|
-
isError:
|
|
10462
|
+
isError: false;
|
|
10459
10463
|
};
|
|
10460
|
-
status: "
|
|
10464
|
+
status: "completed";
|
|
10461
10465
|
thoughtSignature?: string;
|
|
10462
10466
|
time: {
|
|
10463
10467
|
start: number;
|
|
@@ -10483,7 +10487,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10483
10487
|
details?: any;
|
|
10484
10488
|
isError: true;
|
|
10485
10489
|
};
|
|
10486
|
-
status: "
|
|
10490
|
+
status: "error";
|
|
10487
10491
|
thoughtSignature?: string;
|
|
10488
10492
|
time: {
|
|
10489
10493
|
start: number;
|
|
@@ -10509,26 +10513,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10509
10513
|
details?: any;
|
|
10510
10514
|
isError: true;
|
|
10511
10515
|
};
|
|
10512
|
-
status: "
|
|
10516
|
+
status: "skipped";
|
|
10513
10517
|
thoughtSignature?: string;
|
|
10514
10518
|
time: {
|
|
10515
10519
|
start: number;
|
|
10516
10520
|
end: number;
|
|
10517
10521
|
};
|
|
10518
10522
|
type: "toolCall";
|
|
10519
|
-
} | {
|
|
10520
|
-
type: "thinking";
|
|
10521
|
-
thinking: string;
|
|
10522
|
-
thinkingSignature?: string;
|
|
10523
|
-
redacted?: boolean;
|
|
10524
10523
|
} | {
|
|
10525
10524
|
addedToolNames?: string[];
|
|
10526
10525
|
arguments: Record<string, any>;
|
|
10527
10526
|
callID: string;
|
|
10528
10527
|
name: string;
|
|
10529
10528
|
namespace?: string;
|
|
10530
|
-
|
|
10531
|
-
content
|
|
10529
|
+
result: {
|
|
10530
|
+
content: ({
|
|
10532
10531
|
type: "text";
|
|
10533
10532
|
text: string;
|
|
10534
10533
|
textSignature?: string;
|
|
@@ -10538,8 +10537,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10538
10537
|
mimeType: string;
|
|
10539
10538
|
})[];
|
|
10540
10539
|
details?: any;
|
|
10540
|
+
isError: true;
|
|
10541
10541
|
};
|
|
10542
|
-
status: "
|
|
10542
|
+
status: "aborted";
|
|
10543
10543
|
thoughtSignature?: string;
|
|
10544
10544
|
time: {
|
|
10545
10545
|
start: number;
|
|
@@ -10714,14 +10714,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10714
10714
|
type: "image";
|
|
10715
10715
|
data: string;
|
|
10716
10716
|
mimeType: string;
|
|
10717
|
+
} | {
|
|
10718
|
+
type: "thinking";
|
|
10719
|
+
thinking: string;
|
|
10720
|
+
thinkingSignature?: string;
|
|
10721
|
+
redacted?: boolean;
|
|
10717
10722
|
} | {
|
|
10718
10723
|
addedToolNames?: string[];
|
|
10719
10724
|
arguments: Record<string, any>;
|
|
10720
10725
|
callID: string;
|
|
10721
10726
|
name: string;
|
|
10722
10727
|
namespace?: string;
|
|
10723
|
-
|
|
10724
|
-
content
|
|
10728
|
+
partial?: {
|
|
10729
|
+
content?: ({
|
|
10725
10730
|
type: "text";
|
|
10726
10731
|
text: string;
|
|
10727
10732
|
textSignature?: string;
|
|
@@ -10731,9 +10736,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10731
10736
|
mimeType: string;
|
|
10732
10737
|
})[];
|
|
10733
10738
|
details?: any;
|
|
10734
|
-
isError: false;
|
|
10735
10739
|
};
|
|
10736
|
-
status: "
|
|
10740
|
+
status: "running";
|
|
10737
10741
|
thoughtSignature?: string;
|
|
10738
10742
|
time: {
|
|
10739
10743
|
start: number;
|
|
@@ -10757,9 +10761,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10757
10761
|
mimeType: string;
|
|
10758
10762
|
})[];
|
|
10759
10763
|
details?: any;
|
|
10760
|
-
isError:
|
|
10764
|
+
isError: false;
|
|
10761
10765
|
};
|
|
10762
|
-
status: "
|
|
10766
|
+
status: "completed";
|
|
10763
10767
|
thoughtSignature?: string;
|
|
10764
10768
|
time: {
|
|
10765
10769
|
start: number;
|
|
@@ -10785,7 +10789,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10785
10789
|
details?: any;
|
|
10786
10790
|
isError: true;
|
|
10787
10791
|
};
|
|
10788
|
-
status: "
|
|
10792
|
+
status: "error";
|
|
10789
10793
|
thoughtSignature?: string;
|
|
10790
10794
|
time: {
|
|
10791
10795
|
start: number;
|
|
@@ -10811,26 +10815,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10811
10815
|
details?: any;
|
|
10812
10816
|
isError: true;
|
|
10813
10817
|
};
|
|
10814
|
-
status: "
|
|
10818
|
+
status: "skipped";
|
|
10815
10819
|
thoughtSignature?: string;
|
|
10816
10820
|
time: {
|
|
10817
10821
|
start: number;
|
|
10818
10822
|
end: number;
|
|
10819
10823
|
};
|
|
10820
10824
|
type: "toolCall";
|
|
10821
|
-
} | {
|
|
10822
|
-
type: "thinking";
|
|
10823
|
-
thinking: string;
|
|
10824
|
-
thinkingSignature?: string;
|
|
10825
|
-
redacted?: boolean;
|
|
10826
10825
|
} | {
|
|
10827
10826
|
addedToolNames?: string[];
|
|
10828
10827
|
arguments: Record<string, any>;
|
|
10829
10828
|
callID: string;
|
|
10830
10829
|
name: string;
|
|
10831
10830
|
namespace?: string;
|
|
10832
|
-
|
|
10833
|
-
content
|
|
10831
|
+
result: {
|
|
10832
|
+
content: ({
|
|
10834
10833
|
type: "text";
|
|
10835
10834
|
text: string;
|
|
10836
10835
|
textSignature?: string;
|
|
@@ -10840,8 +10839,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10840
10839
|
mimeType: string;
|
|
10841
10840
|
})[];
|
|
10842
10841
|
details?: any;
|
|
10842
|
+
isError: true;
|
|
10843
10843
|
};
|
|
10844
|
-
status: "
|
|
10844
|
+
status: "aborted";
|
|
10845
10845
|
thoughtSignature?: string;
|
|
10846
10846
|
time: {
|
|
10847
10847
|
start: number;
|
|
@@ -11034,14 +11034,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11034
11034
|
type: "image";
|
|
11035
11035
|
data: string;
|
|
11036
11036
|
mimeType: string;
|
|
11037
|
+
} | {
|
|
11038
|
+
type: "thinking";
|
|
11039
|
+
thinking: string;
|
|
11040
|
+
thinkingSignature?: string;
|
|
11041
|
+
redacted?: boolean;
|
|
11037
11042
|
} | {
|
|
11038
11043
|
addedToolNames?: string[];
|
|
11039
11044
|
arguments: Record<string, any>;
|
|
11040
11045
|
callID: string;
|
|
11041
11046
|
name: string;
|
|
11042
11047
|
namespace?: string;
|
|
11043
|
-
|
|
11044
|
-
content
|
|
11048
|
+
partial?: {
|
|
11049
|
+
content?: ({
|
|
11045
11050
|
type: "text";
|
|
11046
11051
|
text: string;
|
|
11047
11052
|
textSignature?: string;
|
|
@@ -11051,9 +11056,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11051
11056
|
mimeType: string;
|
|
11052
11057
|
})[];
|
|
11053
11058
|
details?: any;
|
|
11054
|
-
isError: false;
|
|
11055
11059
|
};
|
|
11056
|
-
status: "
|
|
11060
|
+
status: "running";
|
|
11057
11061
|
thoughtSignature?: string;
|
|
11058
11062
|
time: {
|
|
11059
11063
|
start: number;
|
|
@@ -11077,9 +11081,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11077
11081
|
mimeType: string;
|
|
11078
11082
|
})[];
|
|
11079
11083
|
details?: any;
|
|
11080
|
-
isError:
|
|
11084
|
+
isError: false;
|
|
11081
11085
|
};
|
|
11082
|
-
status: "
|
|
11086
|
+
status: "completed";
|
|
11083
11087
|
thoughtSignature?: string;
|
|
11084
11088
|
time: {
|
|
11085
11089
|
start: number;
|
|
@@ -11105,7 +11109,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11105
11109
|
details?: any;
|
|
11106
11110
|
isError: true;
|
|
11107
11111
|
};
|
|
11108
|
-
status: "
|
|
11112
|
+
status: "error";
|
|
11109
11113
|
thoughtSignature?: string;
|
|
11110
11114
|
time: {
|
|
11111
11115
|
start: number;
|
|
@@ -11131,26 +11135,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11131
11135
|
details?: any;
|
|
11132
11136
|
isError: true;
|
|
11133
11137
|
};
|
|
11134
|
-
status: "
|
|
11138
|
+
status: "skipped";
|
|
11135
11139
|
thoughtSignature?: string;
|
|
11136
11140
|
time: {
|
|
11137
11141
|
start: number;
|
|
11138
11142
|
end: number;
|
|
11139
11143
|
};
|
|
11140
11144
|
type: "toolCall";
|
|
11141
|
-
} | {
|
|
11142
|
-
type: "thinking";
|
|
11143
|
-
thinking: string;
|
|
11144
|
-
thinkingSignature?: string;
|
|
11145
|
-
redacted?: boolean;
|
|
11146
11145
|
} | {
|
|
11147
11146
|
addedToolNames?: string[];
|
|
11148
11147
|
arguments: Record<string, any>;
|
|
11149
11148
|
callID: string;
|
|
11150
11149
|
name: string;
|
|
11151
11150
|
namespace?: string;
|
|
11152
|
-
|
|
11153
|
-
content
|
|
11151
|
+
result: {
|
|
11152
|
+
content: ({
|
|
11154
11153
|
type: "text";
|
|
11155
11154
|
text: string;
|
|
11156
11155
|
textSignature?: string;
|
|
@@ -11160,8 +11159,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11160
11159
|
mimeType: string;
|
|
11161
11160
|
})[];
|
|
11162
11161
|
details?: any;
|
|
11162
|
+
isError: true;
|
|
11163
11163
|
};
|
|
11164
|
-
status: "
|
|
11164
|
+
status: "aborted";
|
|
11165
11165
|
thoughtSignature?: string;
|
|
11166
11166
|
time: {
|
|
11167
11167
|
start: number;
|
|
@@ -11336,14 +11336,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11336
11336
|
type: "image";
|
|
11337
11337
|
data: string;
|
|
11338
11338
|
mimeType: string;
|
|
11339
|
+
} | {
|
|
11340
|
+
type: "thinking";
|
|
11341
|
+
thinking: string;
|
|
11342
|
+
thinkingSignature?: string;
|
|
11343
|
+
redacted?: boolean;
|
|
11339
11344
|
} | {
|
|
11340
11345
|
addedToolNames?: string[];
|
|
11341
11346
|
arguments: Record<string, any>;
|
|
11342
11347
|
callID: string;
|
|
11343
11348
|
name: string;
|
|
11344
11349
|
namespace?: string;
|
|
11345
|
-
|
|
11346
|
-
content
|
|
11350
|
+
partial?: {
|
|
11351
|
+
content?: ({
|
|
11347
11352
|
type: "text";
|
|
11348
11353
|
text: string;
|
|
11349
11354
|
textSignature?: string;
|
|
@@ -11353,9 +11358,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11353
11358
|
mimeType: string;
|
|
11354
11359
|
})[];
|
|
11355
11360
|
details?: any;
|
|
11356
|
-
isError: false;
|
|
11357
11361
|
};
|
|
11358
|
-
status: "
|
|
11362
|
+
status: "running";
|
|
11359
11363
|
thoughtSignature?: string;
|
|
11360
11364
|
time: {
|
|
11361
11365
|
start: number;
|
|
@@ -11379,9 +11383,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11379
11383
|
mimeType: string;
|
|
11380
11384
|
})[];
|
|
11381
11385
|
details?: any;
|
|
11382
|
-
isError:
|
|
11386
|
+
isError: false;
|
|
11383
11387
|
};
|
|
11384
|
-
status: "
|
|
11388
|
+
status: "completed";
|
|
11385
11389
|
thoughtSignature?: string;
|
|
11386
11390
|
time: {
|
|
11387
11391
|
start: number;
|
|
@@ -11407,7 +11411,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11407
11411
|
details?: any;
|
|
11408
11412
|
isError: true;
|
|
11409
11413
|
};
|
|
11410
|
-
status: "
|
|
11414
|
+
status: "error";
|
|
11411
11415
|
thoughtSignature?: string;
|
|
11412
11416
|
time: {
|
|
11413
11417
|
start: number;
|
|
@@ -11433,26 +11437,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11433
11437
|
details?: any;
|
|
11434
11438
|
isError: true;
|
|
11435
11439
|
};
|
|
11436
|
-
status: "
|
|
11440
|
+
status: "skipped";
|
|
11437
11441
|
thoughtSignature?: string;
|
|
11438
11442
|
time: {
|
|
11439
11443
|
start: number;
|
|
11440
11444
|
end: number;
|
|
11441
11445
|
};
|
|
11442
11446
|
type: "toolCall";
|
|
11443
|
-
} | {
|
|
11444
|
-
type: "thinking";
|
|
11445
|
-
thinking: string;
|
|
11446
|
-
thinkingSignature?: string;
|
|
11447
|
-
redacted?: boolean;
|
|
11448
11447
|
} | {
|
|
11449
11448
|
addedToolNames?: string[];
|
|
11450
11449
|
arguments: Record<string, any>;
|
|
11451
11450
|
callID: string;
|
|
11452
11451
|
name: string;
|
|
11453
11452
|
namespace?: string;
|
|
11454
|
-
|
|
11455
|
-
content
|
|
11453
|
+
result: {
|
|
11454
|
+
content: ({
|
|
11456
11455
|
type: "text";
|
|
11457
11456
|
text: string;
|
|
11458
11457
|
textSignature?: string;
|
|
@@ -11462,8 +11461,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11462
11461
|
mimeType: string;
|
|
11463
11462
|
})[];
|
|
11464
11463
|
details?: any;
|
|
11464
|
+
isError: true;
|
|
11465
11465
|
};
|
|
11466
|
-
status: "
|
|
11466
|
+
status: "aborted";
|
|
11467
11467
|
thoughtSignature?: string;
|
|
11468
11468
|
time: {
|
|
11469
11469
|
start: number;
|
|
@@ -11944,14 +11944,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11944
11944
|
type: "image";
|
|
11945
11945
|
data: string;
|
|
11946
11946
|
mimeType: string;
|
|
11947
|
+
} | {
|
|
11948
|
+
type: "thinking";
|
|
11949
|
+
thinking: string;
|
|
11950
|
+
thinkingSignature?: string;
|
|
11951
|
+
redacted?: boolean;
|
|
11947
11952
|
} | {
|
|
11948
11953
|
addedToolNames?: string[];
|
|
11949
11954
|
arguments: Record<string, any>;
|
|
11950
11955
|
callID: string;
|
|
11951
11956
|
name: string;
|
|
11952
11957
|
namespace?: string;
|
|
11953
|
-
|
|
11954
|
-
content
|
|
11958
|
+
partial?: {
|
|
11959
|
+
content?: ({
|
|
11955
11960
|
type: "text";
|
|
11956
11961
|
text: string;
|
|
11957
11962
|
textSignature?: string;
|
|
@@ -11961,9 +11966,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11961
11966
|
mimeType: string;
|
|
11962
11967
|
})[];
|
|
11963
11968
|
details?: any;
|
|
11964
|
-
isError: false;
|
|
11965
11969
|
};
|
|
11966
|
-
status: "
|
|
11970
|
+
status: "running";
|
|
11967
11971
|
thoughtSignature?: string;
|
|
11968
11972
|
time: {
|
|
11969
11973
|
start: number;
|
|
@@ -11987,9 +11991,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11987
11991
|
mimeType: string;
|
|
11988
11992
|
})[];
|
|
11989
11993
|
details?: any;
|
|
11990
|
-
isError:
|
|
11994
|
+
isError: false;
|
|
11991
11995
|
};
|
|
11992
|
-
status: "
|
|
11996
|
+
status: "completed";
|
|
11993
11997
|
thoughtSignature?: string;
|
|
11994
11998
|
time: {
|
|
11995
11999
|
start: number;
|
|
@@ -12015,7 +12019,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12015
12019
|
details?: any;
|
|
12016
12020
|
isError: true;
|
|
12017
12021
|
};
|
|
12018
|
-
status: "
|
|
12022
|
+
status: "error";
|
|
12019
12023
|
thoughtSignature?: string;
|
|
12020
12024
|
time: {
|
|
12021
12025
|
start: number;
|
|
@@ -12041,26 +12045,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12041
12045
|
details?: any;
|
|
12042
12046
|
isError: true;
|
|
12043
12047
|
};
|
|
12044
|
-
status: "
|
|
12048
|
+
status: "skipped";
|
|
12045
12049
|
thoughtSignature?: string;
|
|
12046
12050
|
time: {
|
|
12047
12051
|
start: number;
|
|
12048
12052
|
end: number;
|
|
12049
12053
|
};
|
|
12050
12054
|
type: "toolCall";
|
|
12051
|
-
} | {
|
|
12052
|
-
type: "thinking";
|
|
12053
|
-
thinking: string;
|
|
12054
|
-
thinkingSignature?: string;
|
|
12055
|
-
redacted?: boolean;
|
|
12056
12055
|
} | {
|
|
12057
12056
|
addedToolNames?: string[];
|
|
12058
12057
|
arguments: Record<string, any>;
|
|
12059
12058
|
callID: string;
|
|
12060
12059
|
name: string;
|
|
12061
12060
|
namespace?: string;
|
|
12062
|
-
|
|
12063
|
-
content
|
|
12061
|
+
result: {
|
|
12062
|
+
content: ({
|
|
12064
12063
|
type: "text";
|
|
12065
12064
|
text: string;
|
|
12066
12065
|
textSignature?: string;
|
|
@@ -12070,8 +12069,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12070
12069
|
mimeType: string;
|
|
12071
12070
|
})[];
|
|
12072
12071
|
details?: any;
|
|
12072
|
+
isError: true;
|
|
12073
12073
|
};
|
|
12074
|
-
status: "
|
|
12074
|
+
status: "aborted";
|
|
12075
12075
|
thoughtSignature?: string;
|
|
12076
12076
|
time: {
|
|
12077
12077
|
start: number;
|
|
@@ -12246,14 +12246,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12246
12246
|
type: "image";
|
|
12247
12247
|
data: string;
|
|
12248
12248
|
mimeType: string;
|
|
12249
|
+
} | {
|
|
12250
|
+
type: "thinking";
|
|
12251
|
+
thinking: string;
|
|
12252
|
+
thinkingSignature?: string;
|
|
12253
|
+
redacted?: boolean;
|
|
12249
12254
|
} | {
|
|
12250
12255
|
addedToolNames?: string[];
|
|
12251
12256
|
arguments: Record<string, any>;
|
|
12252
12257
|
callID: string;
|
|
12253
12258
|
name: string;
|
|
12254
12259
|
namespace?: string;
|
|
12255
|
-
|
|
12256
|
-
content
|
|
12260
|
+
partial?: {
|
|
12261
|
+
content?: ({
|
|
12257
12262
|
type: "text";
|
|
12258
12263
|
text: string;
|
|
12259
12264
|
textSignature?: string;
|
|
@@ -12263,9 +12268,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12263
12268
|
mimeType: string;
|
|
12264
12269
|
})[];
|
|
12265
12270
|
details?: any;
|
|
12266
|
-
isError: false;
|
|
12267
12271
|
};
|
|
12268
|
-
status: "
|
|
12272
|
+
status: "running";
|
|
12269
12273
|
thoughtSignature?: string;
|
|
12270
12274
|
time: {
|
|
12271
12275
|
start: number;
|
|
@@ -12289,9 +12293,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12289
12293
|
mimeType: string;
|
|
12290
12294
|
})[];
|
|
12291
12295
|
details?: any;
|
|
12292
|
-
isError:
|
|
12296
|
+
isError: false;
|
|
12293
12297
|
};
|
|
12294
|
-
status: "
|
|
12298
|
+
status: "completed";
|
|
12295
12299
|
thoughtSignature?: string;
|
|
12296
12300
|
time: {
|
|
12297
12301
|
start: number;
|
|
@@ -12317,7 +12321,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12317
12321
|
details?: any;
|
|
12318
12322
|
isError: true;
|
|
12319
12323
|
};
|
|
12320
|
-
status: "
|
|
12324
|
+
status: "error";
|
|
12321
12325
|
thoughtSignature?: string;
|
|
12322
12326
|
time: {
|
|
12323
12327
|
start: number;
|
|
@@ -12343,26 +12347,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12343
12347
|
details?: any;
|
|
12344
12348
|
isError: true;
|
|
12345
12349
|
};
|
|
12346
|
-
status: "
|
|
12350
|
+
status: "skipped";
|
|
12347
12351
|
thoughtSignature?: string;
|
|
12348
12352
|
time: {
|
|
12349
12353
|
start: number;
|
|
12350
12354
|
end: number;
|
|
12351
12355
|
};
|
|
12352
12356
|
type: "toolCall";
|
|
12353
|
-
} | {
|
|
12354
|
-
type: "thinking";
|
|
12355
|
-
thinking: string;
|
|
12356
|
-
thinkingSignature?: string;
|
|
12357
|
-
redacted?: boolean;
|
|
12358
12357
|
} | {
|
|
12359
12358
|
addedToolNames?: string[];
|
|
12360
12359
|
arguments: Record<string, any>;
|
|
12361
12360
|
callID: string;
|
|
12362
12361
|
name: string;
|
|
12363
12362
|
namespace?: string;
|
|
12364
|
-
|
|
12365
|
-
content
|
|
12363
|
+
result: {
|
|
12364
|
+
content: ({
|
|
12366
12365
|
type: "text";
|
|
12367
12366
|
text: string;
|
|
12368
12367
|
textSignature?: string;
|
|
@@ -12372,8 +12371,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12372
12371
|
mimeType: string;
|
|
12373
12372
|
})[];
|
|
12374
12373
|
details?: any;
|
|
12374
|
+
isError: true;
|
|
12375
12375
|
};
|
|
12376
|
-
status: "
|
|
12376
|
+
status: "aborted";
|
|
12377
12377
|
thoughtSignature?: string;
|
|
12378
12378
|
time: {
|
|
12379
12379
|
start: number;
|
|
@@ -12567,14 +12567,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12567
12567
|
type: "image";
|
|
12568
12568
|
data: string;
|
|
12569
12569
|
mimeType: string;
|
|
12570
|
+
} | {
|
|
12571
|
+
type: "thinking";
|
|
12572
|
+
thinking: string;
|
|
12573
|
+
thinkingSignature?: string;
|
|
12574
|
+
redacted?: boolean;
|
|
12570
12575
|
} | {
|
|
12571
12576
|
addedToolNames?: string[];
|
|
12572
12577
|
arguments: Record<string, any>;
|
|
12573
12578
|
callID: string;
|
|
12574
12579
|
name: string;
|
|
12575
12580
|
namespace?: string;
|
|
12576
|
-
|
|
12577
|
-
content
|
|
12581
|
+
partial?: {
|
|
12582
|
+
content?: ({
|
|
12578
12583
|
type: "text";
|
|
12579
12584
|
text: string;
|
|
12580
12585
|
textSignature?: string;
|
|
@@ -12584,9 +12589,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12584
12589
|
mimeType: string;
|
|
12585
12590
|
})[];
|
|
12586
12591
|
details?: any;
|
|
12587
|
-
isError: false;
|
|
12588
12592
|
};
|
|
12589
|
-
status: "
|
|
12593
|
+
status: "running";
|
|
12590
12594
|
thoughtSignature?: string;
|
|
12591
12595
|
time: {
|
|
12592
12596
|
start: number;
|
|
@@ -12610,9 +12614,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12610
12614
|
mimeType: string;
|
|
12611
12615
|
})[];
|
|
12612
12616
|
details?: any;
|
|
12613
|
-
isError:
|
|
12617
|
+
isError: false;
|
|
12614
12618
|
};
|
|
12615
|
-
status: "
|
|
12619
|
+
status: "completed";
|
|
12616
12620
|
thoughtSignature?: string;
|
|
12617
12621
|
time: {
|
|
12618
12622
|
start: number;
|
|
@@ -12638,7 +12642,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12638
12642
|
details?: any;
|
|
12639
12643
|
isError: true;
|
|
12640
12644
|
};
|
|
12641
|
-
status: "
|
|
12645
|
+
status: "error";
|
|
12642
12646
|
thoughtSignature?: string;
|
|
12643
12647
|
time: {
|
|
12644
12648
|
start: number;
|
|
@@ -12664,26 +12668,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12664
12668
|
details?: any;
|
|
12665
12669
|
isError: true;
|
|
12666
12670
|
};
|
|
12667
|
-
status: "
|
|
12671
|
+
status: "skipped";
|
|
12668
12672
|
thoughtSignature?: string;
|
|
12669
12673
|
time: {
|
|
12670
12674
|
start: number;
|
|
12671
12675
|
end: number;
|
|
12672
12676
|
};
|
|
12673
12677
|
type: "toolCall";
|
|
12674
|
-
} | {
|
|
12675
|
-
type: "thinking";
|
|
12676
|
-
thinking: string;
|
|
12677
|
-
thinkingSignature?: string;
|
|
12678
|
-
redacted?: boolean;
|
|
12679
12678
|
} | {
|
|
12680
12679
|
addedToolNames?: string[];
|
|
12681
12680
|
arguments: Record<string, any>;
|
|
12682
12681
|
callID: string;
|
|
12683
12682
|
name: string;
|
|
12684
12683
|
namespace?: string;
|
|
12685
|
-
|
|
12686
|
-
content
|
|
12684
|
+
result: {
|
|
12685
|
+
content: ({
|
|
12687
12686
|
type: "text";
|
|
12688
12687
|
text: string;
|
|
12689
12688
|
textSignature?: string;
|
|
@@ -12693,8 +12692,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12693
12692
|
mimeType: string;
|
|
12694
12693
|
})[];
|
|
12695
12694
|
details?: any;
|
|
12695
|
+
isError: true;
|
|
12696
12696
|
};
|
|
12697
|
-
status: "
|
|
12697
|
+
status: "aborted";
|
|
12698
12698
|
thoughtSignature?: string;
|
|
12699
12699
|
time: {
|
|
12700
12700
|
start: number;
|
|
@@ -12869,14 +12869,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12869
12869
|
type: "image";
|
|
12870
12870
|
data: string;
|
|
12871
12871
|
mimeType: string;
|
|
12872
|
+
} | {
|
|
12873
|
+
type: "thinking";
|
|
12874
|
+
thinking: string;
|
|
12875
|
+
thinkingSignature?: string;
|
|
12876
|
+
redacted?: boolean;
|
|
12872
12877
|
} | {
|
|
12873
12878
|
addedToolNames?: string[];
|
|
12874
12879
|
arguments: Record<string, any>;
|
|
12875
12880
|
callID: string;
|
|
12876
12881
|
name: string;
|
|
12877
12882
|
namespace?: string;
|
|
12878
|
-
|
|
12879
|
-
content
|
|
12883
|
+
partial?: {
|
|
12884
|
+
content?: ({
|
|
12880
12885
|
type: "text";
|
|
12881
12886
|
text: string;
|
|
12882
12887
|
textSignature?: string;
|
|
@@ -12886,9 +12891,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12886
12891
|
mimeType: string;
|
|
12887
12892
|
})[];
|
|
12888
12893
|
details?: any;
|
|
12889
|
-
isError: false;
|
|
12890
12894
|
};
|
|
12891
|
-
status: "
|
|
12895
|
+
status: "running";
|
|
12892
12896
|
thoughtSignature?: string;
|
|
12893
12897
|
time: {
|
|
12894
12898
|
start: number;
|
|
@@ -12912,9 +12916,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12912
12916
|
mimeType: string;
|
|
12913
12917
|
})[];
|
|
12914
12918
|
details?: any;
|
|
12915
|
-
isError:
|
|
12919
|
+
isError: false;
|
|
12916
12920
|
};
|
|
12917
|
-
status: "
|
|
12921
|
+
status: "completed";
|
|
12918
12922
|
thoughtSignature?: string;
|
|
12919
12923
|
time: {
|
|
12920
12924
|
start: number;
|
|
@@ -12940,7 +12944,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12940
12944
|
details?: any;
|
|
12941
12945
|
isError: true;
|
|
12942
12946
|
};
|
|
12943
|
-
status: "
|
|
12947
|
+
status: "error";
|
|
12944
12948
|
thoughtSignature?: string;
|
|
12945
12949
|
time: {
|
|
12946
12950
|
start: number;
|
|
@@ -12966,26 +12970,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12966
12970
|
details?: any;
|
|
12967
12971
|
isError: true;
|
|
12968
12972
|
};
|
|
12969
|
-
status: "
|
|
12973
|
+
status: "skipped";
|
|
12970
12974
|
thoughtSignature?: string;
|
|
12971
12975
|
time: {
|
|
12972
12976
|
start: number;
|
|
12973
12977
|
end: number;
|
|
12974
12978
|
};
|
|
12975
12979
|
type: "toolCall";
|
|
12976
|
-
} | {
|
|
12977
|
-
type: "thinking";
|
|
12978
|
-
thinking: string;
|
|
12979
|
-
thinkingSignature?: string;
|
|
12980
|
-
redacted?: boolean;
|
|
12981
12980
|
} | {
|
|
12982
12981
|
addedToolNames?: string[];
|
|
12983
12982
|
arguments: Record<string, any>;
|
|
12984
12983
|
callID: string;
|
|
12985
12984
|
name: string;
|
|
12986
12985
|
namespace?: string;
|
|
12987
|
-
|
|
12988
|
-
content
|
|
12986
|
+
result: {
|
|
12987
|
+
content: ({
|
|
12989
12988
|
type: "text";
|
|
12990
12989
|
text: string;
|
|
12991
12990
|
textSignature?: string;
|
|
@@ -12995,8 +12994,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12995
12994
|
mimeType: string;
|
|
12996
12995
|
})[];
|
|
12997
12996
|
details?: any;
|
|
12997
|
+
isError: true;
|
|
12998
12998
|
};
|
|
12999
|
-
status: "
|
|
12999
|
+
status: "aborted";
|
|
13000
13000
|
thoughtSignature?: string;
|
|
13001
13001
|
time: {
|
|
13002
13002
|
start: number;
|
|
@@ -13199,14 +13199,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13199
13199
|
type: "image";
|
|
13200
13200
|
data: string;
|
|
13201
13201
|
mimeType: string;
|
|
13202
|
+
} | {
|
|
13203
|
+
type: "thinking";
|
|
13204
|
+
thinking: string;
|
|
13205
|
+
thinkingSignature?: string;
|
|
13206
|
+
redacted?: boolean;
|
|
13202
13207
|
} | {
|
|
13203
13208
|
addedToolNames?: string[];
|
|
13204
13209
|
arguments: Record<string, any>;
|
|
13205
13210
|
callID: string;
|
|
13206
13211
|
name: string;
|
|
13207
13212
|
namespace?: string;
|
|
13208
|
-
|
|
13209
|
-
content
|
|
13213
|
+
partial?: {
|
|
13214
|
+
content?: ({
|
|
13210
13215
|
type: "text";
|
|
13211
13216
|
text: string;
|
|
13212
13217
|
textSignature?: string;
|
|
@@ -13216,9 +13221,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13216
13221
|
mimeType: string;
|
|
13217
13222
|
})[];
|
|
13218
13223
|
details?: any;
|
|
13219
|
-
isError: false;
|
|
13220
13224
|
};
|
|
13221
|
-
status: "
|
|
13225
|
+
status: "running";
|
|
13222
13226
|
thoughtSignature?: string;
|
|
13223
13227
|
time: {
|
|
13224
13228
|
start: number;
|
|
@@ -13242,9 +13246,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13242
13246
|
mimeType: string;
|
|
13243
13247
|
})[];
|
|
13244
13248
|
details?: any;
|
|
13245
|
-
isError:
|
|
13249
|
+
isError: false;
|
|
13246
13250
|
};
|
|
13247
|
-
status: "
|
|
13251
|
+
status: "completed";
|
|
13248
13252
|
thoughtSignature?: string;
|
|
13249
13253
|
time: {
|
|
13250
13254
|
start: number;
|
|
@@ -13270,7 +13274,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13270
13274
|
details?: any;
|
|
13271
13275
|
isError: true;
|
|
13272
13276
|
};
|
|
13273
|
-
status: "
|
|
13277
|
+
status: "error";
|
|
13274
13278
|
thoughtSignature?: string;
|
|
13275
13279
|
time: {
|
|
13276
13280
|
start: number;
|
|
@@ -13296,26 +13300,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13296
13300
|
details?: any;
|
|
13297
13301
|
isError: true;
|
|
13298
13302
|
};
|
|
13299
|
-
status: "
|
|
13303
|
+
status: "skipped";
|
|
13300
13304
|
thoughtSignature?: string;
|
|
13301
13305
|
time: {
|
|
13302
13306
|
start: number;
|
|
13303
13307
|
end: number;
|
|
13304
13308
|
};
|
|
13305
13309
|
type: "toolCall";
|
|
13306
|
-
} | {
|
|
13307
|
-
type: "thinking";
|
|
13308
|
-
thinking: string;
|
|
13309
|
-
thinkingSignature?: string;
|
|
13310
|
-
redacted?: boolean;
|
|
13311
13310
|
} | {
|
|
13312
13311
|
addedToolNames?: string[];
|
|
13313
13312
|
arguments: Record<string, any>;
|
|
13314
13313
|
callID: string;
|
|
13315
13314
|
name: string;
|
|
13316
13315
|
namespace?: string;
|
|
13317
|
-
|
|
13318
|
-
content
|
|
13316
|
+
result: {
|
|
13317
|
+
content: ({
|
|
13319
13318
|
type: "text";
|
|
13320
13319
|
text: string;
|
|
13321
13320
|
textSignature?: string;
|
|
@@ -13325,8 +13324,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13325
13324
|
mimeType: string;
|
|
13326
13325
|
})[];
|
|
13327
13326
|
details?: any;
|
|
13327
|
+
isError: true;
|
|
13328
13328
|
};
|
|
13329
|
-
status: "
|
|
13329
|
+
status: "aborted";
|
|
13330
13330
|
thoughtSignature?: string;
|
|
13331
13331
|
time: {
|
|
13332
13332
|
start: number;
|
|
@@ -13501,14 +13501,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13501
13501
|
type: "image";
|
|
13502
13502
|
data: string;
|
|
13503
13503
|
mimeType: string;
|
|
13504
|
+
} | {
|
|
13505
|
+
type: "thinking";
|
|
13506
|
+
thinking: string;
|
|
13507
|
+
thinkingSignature?: string;
|
|
13508
|
+
redacted?: boolean;
|
|
13504
13509
|
} | {
|
|
13505
13510
|
addedToolNames?: string[];
|
|
13506
13511
|
arguments: Record<string, any>;
|
|
13507
13512
|
callID: string;
|
|
13508
13513
|
name: string;
|
|
13509
13514
|
namespace?: string;
|
|
13510
|
-
|
|
13511
|
-
content
|
|
13515
|
+
partial?: {
|
|
13516
|
+
content?: ({
|
|
13512
13517
|
type: "text";
|
|
13513
13518
|
text: string;
|
|
13514
13519
|
textSignature?: string;
|
|
@@ -13518,9 +13523,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13518
13523
|
mimeType: string;
|
|
13519
13524
|
})[];
|
|
13520
13525
|
details?: any;
|
|
13521
|
-
isError: false;
|
|
13522
13526
|
};
|
|
13523
|
-
status: "
|
|
13527
|
+
status: "running";
|
|
13524
13528
|
thoughtSignature?: string;
|
|
13525
13529
|
time: {
|
|
13526
13530
|
start: number;
|
|
@@ -13544,9 +13548,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13544
13548
|
mimeType: string;
|
|
13545
13549
|
})[];
|
|
13546
13550
|
details?: any;
|
|
13547
|
-
isError:
|
|
13551
|
+
isError: false;
|
|
13548
13552
|
};
|
|
13549
|
-
status: "
|
|
13553
|
+
status: "completed";
|
|
13550
13554
|
thoughtSignature?: string;
|
|
13551
13555
|
time: {
|
|
13552
13556
|
start: number;
|
|
@@ -13572,7 +13576,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13572
13576
|
details?: any;
|
|
13573
13577
|
isError: true;
|
|
13574
13578
|
};
|
|
13575
|
-
status: "
|
|
13579
|
+
status: "error";
|
|
13576
13580
|
thoughtSignature?: string;
|
|
13577
13581
|
time: {
|
|
13578
13582
|
start: number;
|
|
@@ -13598,26 +13602,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13598
13602
|
details?: any;
|
|
13599
13603
|
isError: true;
|
|
13600
13604
|
};
|
|
13601
|
-
status: "
|
|
13605
|
+
status: "skipped";
|
|
13602
13606
|
thoughtSignature?: string;
|
|
13603
13607
|
time: {
|
|
13604
13608
|
start: number;
|
|
13605
13609
|
end: number;
|
|
13606
13610
|
};
|
|
13607
13611
|
type: "toolCall";
|
|
13608
|
-
} | {
|
|
13609
|
-
type: "thinking";
|
|
13610
|
-
thinking: string;
|
|
13611
|
-
thinkingSignature?: string;
|
|
13612
|
-
redacted?: boolean;
|
|
13613
13612
|
} | {
|
|
13614
13613
|
addedToolNames?: string[];
|
|
13615
13614
|
arguments: Record<string, any>;
|
|
13616
13615
|
callID: string;
|
|
13617
13616
|
name: string;
|
|
13618
13617
|
namespace?: string;
|
|
13619
|
-
|
|
13620
|
-
content
|
|
13618
|
+
result: {
|
|
13619
|
+
content: ({
|
|
13621
13620
|
type: "text";
|
|
13622
13621
|
text: string;
|
|
13623
13622
|
textSignature?: string;
|
|
@@ -13627,8 +13626,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13627
13626
|
mimeType: string;
|
|
13628
13627
|
})[];
|
|
13629
13628
|
details?: any;
|
|
13629
|
+
isError: true;
|
|
13630
13630
|
};
|
|
13631
|
-
status: "
|
|
13631
|
+
status: "aborted";
|
|
13632
13632
|
thoughtSignature?: string;
|
|
13633
13633
|
time: {
|
|
13634
13634
|
start: number;
|
|
@@ -13822,14 +13822,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13822
13822
|
type: "image";
|
|
13823
13823
|
data: string;
|
|
13824
13824
|
mimeType: string;
|
|
13825
|
+
} | {
|
|
13826
|
+
type: "thinking";
|
|
13827
|
+
thinking: string;
|
|
13828
|
+
thinkingSignature?: string;
|
|
13829
|
+
redacted?: boolean;
|
|
13825
13830
|
} | {
|
|
13826
13831
|
addedToolNames?: string[];
|
|
13827
13832
|
arguments: Record<string, any>;
|
|
13828
13833
|
callID: string;
|
|
13829
13834
|
name: string;
|
|
13830
13835
|
namespace?: string;
|
|
13831
|
-
|
|
13832
|
-
content
|
|
13836
|
+
partial?: {
|
|
13837
|
+
content?: ({
|
|
13833
13838
|
type: "text";
|
|
13834
13839
|
text: string;
|
|
13835
13840
|
textSignature?: string;
|
|
@@ -13839,9 +13844,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13839
13844
|
mimeType: string;
|
|
13840
13845
|
})[];
|
|
13841
13846
|
details?: any;
|
|
13842
|
-
isError: false;
|
|
13843
13847
|
};
|
|
13844
|
-
status: "
|
|
13848
|
+
status: "running";
|
|
13845
13849
|
thoughtSignature?: string;
|
|
13846
13850
|
time: {
|
|
13847
13851
|
start: number;
|
|
@@ -13865,9 +13869,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13865
13869
|
mimeType: string;
|
|
13866
13870
|
})[];
|
|
13867
13871
|
details?: any;
|
|
13868
|
-
isError:
|
|
13872
|
+
isError: false;
|
|
13869
13873
|
};
|
|
13870
|
-
status: "
|
|
13874
|
+
status: "completed";
|
|
13871
13875
|
thoughtSignature?: string;
|
|
13872
13876
|
time: {
|
|
13873
13877
|
start: number;
|
|
@@ -13893,7 +13897,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13893
13897
|
details?: any;
|
|
13894
13898
|
isError: true;
|
|
13895
13899
|
};
|
|
13896
|
-
status: "
|
|
13900
|
+
status: "error";
|
|
13897
13901
|
thoughtSignature?: string;
|
|
13898
13902
|
time: {
|
|
13899
13903
|
start: number;
|
|
@@ -13919,26 +13923,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13919
13923
|
details?: any;
|
|
13920
13924
|
isError: true;
|
|
13921
13925
|
};
|
|
13922
|
-
status: "
|
|
13926
|
+
status: "skipped";
|
|
13923
13927
|
thoughtSignature?: string;
|
|
13924
13928
|
time: {
|
|
13925
13929
|
start: number;
|
|
13926
13930
|
end: number;
|
|
13927
13931
|
};
|
|
13928
13932
|
type: "toolCall";
|
|
13929
|
-
} | {
|
|
13930
|
-
type: "thinking";
|
|
13931
|
-
thinking: string;
|
|
13932
|
-
thinkingSignature?: string;
|
|
13933
|
-
redacted?: boolean;
|
|
13934
13933
|
} | {
|
|
13935
13934
|
addedToolNames?: string[];
|
|
13936
13935
|
arguments: Record<string, any>;
|
|
13937
13936
|
callID: string;
|
|
13938
13937
|
name: string;
|
|
13939
13938
|
namespace?: string;
|
|
13940
|
-
|
|
13941
|
-
content
|
|
13939
|
+
result: {
|
|
13940
|
+
content: ({
|
|
13942
13941
|
type: "text";
|
|
13943
13942
|
text: string;
|
|
13944
13943
|
textSignature?: string;
|
|
@@ -13948,8 +13947,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13948
13947
|
mimeType: string;
|
|
13949
13948
|
})[];
|
|
13950
13949
|
details?: any;
|
|
13950
|
+
isError: true;
|
|
13951
13951
|
};
|
|
13952
|
-
status: "
|
|
13952
|
+
status: "aborted";
|
|
13953
13953
|
thoughtSignature?: string;
|
|
13954
13954
|
time: {
|
|
13955
13955
|
start: number;
|
|
@@ -14124,14 +14124,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14124
14124
|
type: "image";
|
|
14125
14125
|
data: string;
|
|
14126
14126
|
mimeType: string;
|
|
14127
|
+
} | {
|
|
14128
|
+
type: "thinking";
|
|
14129
|
+
thinking: string;
|
|
14130
|
+
thinkingSignature?: string;
|
|
14131
|
+
redacted?: boolean;
|
|
14127
14132
|
} | {
|
|
14128
14133
|
addedToolNames?: string[];
|
|
14129
14134
|
arguments: Record<string, any>;
|
|
14130
14135
|
callID: string;
|
|
14131
14136
|
name: string;
|
|
14132
14137
|
namespace?: string;
|
|
14133
|
-
|
|
14134
|
-
content
|
|
14138
|
+
partial?: {
|
|
14139
|
+
content?: ({
|
|
14135
14140
|
type: "text";
|
|
14136
14141
|
text: string;
|
|
14137
14142
|
textSignature?: string;
|
|
@@ -14141,9 +14146,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14141
14146
|
mimeType: string;
|
|
14142
14147
|
})[];
|
|
14143
14148
|
details?: any;
|
|
14144
|
-
isError: false;
|
|
14145
14149
|
};
|
|
14146
|
-
status: "
|
|
14150
|
+
status: "running";
|
|
14147
14151
|
thoughtSignature?: string;
|
|
14148
14152
|
time: {
|
|
14149
14153
|
start: number;
|
|
@@ -14167,9 +14171,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14167
14171
|
mimeType: string;
|
|
14168
14172
|
})[];
|
|
14169
14173
|
details?: any;
|
|
14170
|
-
isError:
|
|
14174
|
+
isError: false;
|
|
14171
14175
|
};
|
|
14172
|
-
status: "
|
|
14176
|
+
status: "completed";
|
|
14173
14177
|
thoughtSignature?: string;
|
|
14174
14178
|
time: {
|
|
14175
14179
|
start: number;
|
|
@@ -14195,7 +14199,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14195
14199
|
details?: any;
|
|
14196
14200
|
isError: true;
|
|
14197
14201
|
};
|
|
14198
|
-
status: "
|
|
14202
|
+
status: "error";
|
|
14199
14203
|
thoughtSignature?: string;
|
|
14200
14204
|
time: {
|
|
14201
14205
|
start: number;
|
|
@@ -14221,26 +14225,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14221
14225
|
details?: any;
|
|
14222
14226
|
isError: true;
|
|
14223
14227
|
};
|
|
14224
|
-
status: "
|
|
14228
|
+
status: "skipped";
|
|
14225
14229
|
thoughtSignature?: string;
|
|
14226
14230
|
time: {
|
|
14227
14231
|
start: number;
|
|
14228
14232
|
end: number;
|
|
14229
14233
|
};
|
|
14230
14234
|
type: "toolCall";
|
|
14231
|
-
} | {
|
|
14232
|
-
type: "thinking";
|
|
14233
|
-
thinking: string;
|
|
14234
|
-
thinkingSignature?: string;
|
|
14235
|
-
redacted?: boolean;
|
|
14236
14235
|
} | {
|
|
14237
14236
|
addedToolNames?: string[];
|
|
14238
14237
|
arguments: Record<string, any>;
|
|
14239
14238
|
callID: string;
|
|
14240
14239
|
name: string;
|
|
14241
14240
|
namespace?: string;
|
|
14242
|
-
|
|
14243
|
-
content
|
|
14241
|
+
result: {
|
|
14242
|
+
content: ({
|
|
14244
14243
|
type: "text";
|
|
14245
14244
|
text: string;
|
|
14246
14245
|
textSignature?: string;
|
|
@@ -14250,8 +14249,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14250
14249
|
mimeType: string;
|
|
14251
14250
|
})[];
|
|
14252
14251
|
details?: any;
|
|
14252
|
+
isError: true;
|
|
14253
14253
|
};
|
|
14254
|
-
status: "
|
|
14254
|
+
status: "aborted";
|
|
14255
14255
|
thoughtSignature?: string;
|
|
14256
14256
|
time: {
|
|
14257
14257
|
start: number;
|
|
@@ -15760,14 +15760,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15760
15760
|
type: "image";
|
|
15761
15761
|
data: string;
|
|
15762
15762
|
mimeType: string;
|
|
15763
|
+
} | {
|
|
15764
|
+
type: "thinking";
|
|
15765
|
+
thinking: string;
|
|
15766
|
+
thinkingSignature?: string;
|
|
15767
|
+
redacted?: boolean;
|
|
15763
15768
|
} | {
|
|
15764
15769
|
addedToolNames?: string[];
|
|
15765
15770
|
arguments: Record<string, any>;
|
|
15766
15771
|
callID: string;
|
|
15767
15772
|
name: string;
|
|
15768
15773
|
namespace?: string;
|
|
15769
|
-
|
|
15770
|
-
content
|
|
15774
|
+
partial?: {
|
|
15775
|
+
content?: ({
|
|
15771
15776
|
type: "text";
|
|
15772
15777
|
text: string;
|
|
15773
15778
|
textSignature?: string;
|
|
@@ -15777,9 +15782,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15777
15782
|
mimeType: string;
|
|
15778
15783
|
})[];
|
|
15779
15784
|
details?: any;
|
|
15780
|
-
isError: false;
|
|
15781
15785
|
};
|
|
15782
|
-
status: "
|
|
15786
|
+
status: "running";
|
|
15783
15787
|
thoughtSignature?: string;
|
|
15784
15788
|
time: {
|
|
15785
15789
|
start: number;
|
|
@@ -15803,9 +15807,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15803
15807
|
mimeType: string;
|
|
15804
15808
|
})[];
|
|
15805
15809
|
details?: any;
|
|
15806
|
-
isError:
|
|
15810
|
+
isError: false;
|
|
15807
15811
|
};
|
|
15808
|
-
status: "
|
|
15812
|
+
status: "completed";
|
|
15809
15813
|
thoughtSignature?: string;
|
|
15810
15814
|
time: {
|
|
15811
15815
|
start: number;
|
|
@@ -15831,7 +15835,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15831
15835
|
details?: any;
|
|
15832
15836
|
isError: true;
|
|
15833
15837
|
};
|
|
15834
|
-
status: "
|
|
15838
|
+
status: "error";
|
|
15835
15839
|
thoughtSignature?: string;
|
|
15836
15840
|
time: {
|
|
15837
15841
|
start: number;
|
|
@@ -15857,26 +15861,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15857
15861
|
details?: any;
|
|
15858
15862
|
isError: true;
|
|
15859
15863
|
};
|
|
15860
|
-
status: "
|
|
15864
|
+
status: "skipped";
|
|
15861
15865
|
thoughtSignature?: string;
|
|
15862
15866
|
time: {
|
|
15863
15867
|
start: number;
|
|
15864
15868
|
end: number;
|
|
15865
15869
|
};
|
|
15866
15870
|
type: "toolCall";
|
|
15867
|
-
} | {
|
|
15868
|
-
type: "thinking";
|
|
15869
|
-
thinking: string;
|
|
15870
|
-
thinkingSignature?: string;
|
|
15871
|
-
redacted?: boolean;
|
|
15872
15871
|
} | {
|
|
15873
15872
|
addedToolNames?: string[];
|
|
15874
15873
|
arguments: Record<string, any>;
|
|
15875
15874
|
callID: string;
|
|
15876
15875
|
name: string;
|
|
15877
15876
|
namespace?: string;
|
|
15878
|
-
|
|
15879
|
-
content
|
|
15877
|
+
result: {
|
|
15878
|
+
content: ({
|
|
15880
15879
|
type: "text";
|
|
15881
15880
|
text: string;
|
|
15882
15881
|
textSignature?: string;
|
|
@@ -15886,8 +15885,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15886
15885
|
mimeType: string;
|
|
15887
15886
|
})[];
|
|
15888
15887
|
details?: any;
|
|
15888
|
+
isError: true;
|
|
15889
15889
|
};
|
|
15890
|
-
status: "
|
|
15890
|
+
status: "aborted";
|
|
15891
15891
|
thoughtSignature?: string;
|
|
15892
15892
|
time: {
|
|
15893
15893
|
start: number;
|
|
@@ -16062,14 +16062,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16062
16062
|
type: "image";
|
|
16063
16063
|
data: string;
|
|
16064
16064
|
mimeType: string;
|
|
16065
|
+
} | {
|
|
16066
|
+
type: "thinking";
|
|
16067
|
+
thinking: string;
|
|
16068
|
+
thinkingSignature?: string;
|
|
16069
|
+
redacted?: boolean;
|
|
16065
16070
|
} | {
|
|
16066
16071
|
addedToolNames?: string[];
|
|
16067
16072
|
arguments: Record<string, any>;
|
|
16068
16073
|
callID: string;
|
|
16069
16074
|
name: string;
|
|
16070
16075
|
namespace?: string;
|
|
16071
|
-
|
|
16072
|
-
content
|
|
16076
|
+
partial?: {
|
|
16077
|
+
content?: ({
|
|
16073
16078
|
type: "text";
|
|
16074
16079
|
text: string;
|
|
16075
16080
|
textSignature?: string;
|
|
@@ -16079,9 +16084,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16079
16084
|
mimeType: string;
|
|
16080
16085
|
})[];
|
|
16081
16086
|
details?: any;
|
|
16082
|
-
isError: false;
|
|
16083
16087
|
};
|
|
16084
|
-
status: "
|
|
16088
|
+
status: "running";
|
|
16085
16089
|
thoughtSignature?: string;
|
|
16086
16090
|
time: {
|
|
16087
16091
|
start: number;
|
|
@@ -16105,9 +16109,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16105
16109
|
mimeType: string;
|
|
16106
16110
|
})[];
|
|
16107
16111
|
details?: any;
|
|
16108
|
-
isError:
|
|
16112
|
+
isError: false;
|
|
16109
16113
|
};
|
|
16110
|
-
status: "
|
|
16114
|
+
status: "completed";
|
|
16111
16115
|
thoughtSignature?: string;
|
|
16112
16116
|
time: {
|
|
16113
16117
|
start: number;
|
|
@@ -16133,7 +16137,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16133
16137
|
details?: any;
|
|
16134
16138
|
isError: true;
|
|
16135
16139
|
};
|
|
16136
|
-
status: "
|
|
16140
|
+
status: "error";
|
|
16137
16141
|
thoughtSignature?: string;
|
|
16138
16142
|
time: {
|
|
16139
16143
|
start: number;
|
|
@@ -16159,26 +16163,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16159
16163
|
details?: any;
|
|
16160
16164
|
isError: true;
|
|
16161
16165
|
};
|
|
16162
|
-
status: "
|
|
16166
|
+
status: "skipped";
|
|
16163
16167
|
thoughtSignature?: string;
|
|
16164
16168
|
time: {
|
|
16165
16169
|
start: number;
|
|
16166
16170
|
end: number;
|
|
16167
16171
|
};
|
|
16168
16172
|
type: "toolCall";
|
|
16169
|
-
} | {
|
|
16170
|
-
type: "thinking";
|
|
16171
|
-
thinking: string;
|
|
16172
|
-
thinkingSignature?: string;
|
|
16173
|
-
redacted?: boolean;
|
|
16174
16173
|
} | {
|
|
16175
16174
|
addedToolNames?: string[];
|
|
16176
16175
|
arguments: Record<string, any>;
|
|
16177
16176
|
callID: string;
|
|
16178
16177
|
name: string;
|
|
16179
16178
|
namespace?: string;
|
|
16180
|
-
|
|
16181
|
-
content
|
|
16179
|
+
result: {
|
|
16180
|
+
content: ({
|
|
16182
16181
|
type: "text";
|
|
16183
16182
|
text: string;
|
|
16184
16183
|
textSignature?: string;
|
|
@@ -16188,8 +16187,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16188
16187
|
mimeType: string;
|
|
16189
16188
|
})[];
|
|
16190
16189
|
details?: any;
|
|
16190
|
+
isError: true;
|
|
16191
16191
|
};
|
|
16192
|
-
status: "
|
|
16192
|
+
status: "aborted";
|
|
16193
16193
|
thoughtSignature?: string;
|
|
16194
16194
|
time: {
|
|
16195
16195
|
start: number;
|
|
@@ -16382,14 +16382,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16382
16382
|
type: "image";
|
|
16383
16383
|
data: string;
|
|
16384
16384
|
mimeType: string;
|
|
16385
|
+
} | {
|
|
16386
|
+
type: "thinking";
|
|
16387
|
+
thinking: string;
|
|
16388
|
+
thinkingSignature?: string;
|
|
16389
|
+
redacted?: boolean;
|
|
16385
16390
|
} | {
|
|
16386
16391
|
addedToolNames?: string[];
|
|
16387
16392
|
arguments: Record<string, any>;
|
|
16388
16393
|
callID: string;
|
|
16389
16394
|
name: string;
|
|
16390
16395
|
namespace?: string;
|
|
16391
|
-
|
|
16392
|
-
content
|
|
16396
|
+
partial?: {
|
|
16397
|
+
content?: ({
|
|
16393
16398
|
type: "text";
|
|
16394
16399
|
text: string;
|
|
16395
16400
|
textSignature?: string;
|
|
@@ -16399,9 +16404,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16399
16404
|
mimeType: string;
|
|
16400
16405
|
})[];
|
|
16401
16406
|
details?: any;
|
|
16402
|
-
isError: false;
|
|
16403
16407
|
};
|
|
16404
|
-
status: "
|
|
16408
|
+
status: "running";
|
|
16405
16409
|
thoughtSignature?: string;
|
|
16406
16410
|
time: {
|
|
16407
16411
|
start: number;
|
|
@@ -16425,9 +16429,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16425
16429
|
mimeType: string;
|
|
16426
16430
|
})[];
|
|
16427
16431
|
details?: any;
|
|
16428
|
-
isError:
|
|
16432
|
+
isError: false;
|
|
16429
16433
|
};
|
|
16430
|
-
status: "
|
|
16434
|
+
status: "completed";
|
|
16431
16435
|
thoughtSignature?: string;
|
|
16432
16436
|
time: {
|
|
16433
16437
|
start: number;
|
|
@@ -16453,7 +16457,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16453
16457
|
details?: any;
|
|
16454
16458
|
isError: true;
|
|
16455
16459
|
};
|
|
16456
|
-
status: "
|
|
16460
|
+
status: "error";
|
|
16457
16461
|
thoughtSignature?: string;
|
|
16458
16462
|
time: {
|
|
16459
16463
|
start: number;
|
|
@@ -16479,26 +16483,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16479
16483
|
details?: any;
|
|
16480
16484
|
isError: true;
|
|
16481
16485
|
};
|
|
16482
|
-
status: "
|
|
16486
|
+
status: "skipped";
|
|
16483
16487
|
thoughtSignature?: string;
|
|
16484
16488
|
time: {
|
|
16485
16489
|
start: number;
|
|
16486
16490
|
end: number;
|
|
16487
16491
|
};
|
|
16488
16492
|
type: "toolCall";
|
|
16489
|
-
} | {
|
|
16490
|
-
type: "thinking";
|
|
16491
|
-
thinking: string;
|
|
16492
|
-
thinkingSignature?: string;
|
|
16493
|
-
redacted?: boolean;
|
|
16494
16493
|
} | {
|
|
16495
16494
|
addedToolNames?: string[];
|
|
16496
16495
|
arguments: Record<string, any>;
|
|
16497
16496
|
callID: string;
|
|
16498
16497
|
name: string;
|
|
16499
16498
|
namespace?: string;
|
|
16500
|
-
|
|
16501
|
-
content
|
|
16499
|
+
result: {
|
|
16500
|
+
content: ({
|
|
16502
16501
|
type: "text";
|
|
16503
16502
|
text: string;
|
|
16504
16503
|
textSignature?: string;
|
|
@@ -16508,8 +16507,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16508
16507
|
mimeType: string;
|
|
16509
16508
|
})[];
|
|
16510
16509
|
details?: any;
|
|
16510
|
+
isError: true;
|
|
16511
16511
|
};
|
|
16512
|
-
status: "
|
|
16512
|
+
status: "aborted";
|
|
16513
16513
|
thoughtSignature?: string;
|
|
16514
16514
|
time: {
|
|
16515
16515
|
start: number;
|
|
@@ -16684,14 +16684,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16684
16684
|
type: "image";
|
|
16685
16685
|
data: string;
|
|
16686
16686
|
mimeType: string;
|
|
16687
|
+
} | {
|
|
16688
|
+
type: "thinking";
|
|
16689
|
+
thinking: string;
|
|
16690
|
+
thinkingSignature?: string;
|
|
16691
|
+
redacted?: boolean;
|
|
16687
16692
|
} | {
|
|
16688
16693
|
addedToolNames?: string[];
|
|
16689
16694
|
arguments: Record<string, any>;
|
|
16690
16695
|
callID: string;
|
|
16691
16696
|
name: string;
|
|
16692
16697
|
namespace?: string;
|
|
16693
|
-
|
|
16694
|
-
content
|
|
16698
|
+
partial?: {
|
|
16699
|
+
content?: ({
|
|
16695
16700
|
type: "text";
|
|
16696
16701
|
text: string;
|
|
16697
16702
|
textSignature?: string;
|
|
@@ -16701,9 +16706,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16701
16706
|
mimeType: string;
|
|
16702
16707
|
})[];
|
|
16703
16708
|
details?: any;
|
|
16704
|
-
isError: false;
|
|
16705
16709
|
};
|
|
16706
|
-
status: "
|
|
16710
|
+
status: "running";
|
|
16707
16711
|
thoughtSignature?: string;
|
|
16708
16712
|
time: {
|
|
16709
16713
|
start: number;
|
|
@@ -16727,9 +16731,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16727
16731
|
mimeType: string;
|
|
16728
16732
|
})[];
|
|
16729
16733
|
details?: any;
|
|
16730
|
-
isError:
|
|
16734
|
+
isError: false;
|
|
16731
16735
|
};
|
|
16732
|
-
status: "
|
|
16736
|
+
status: "completed";
|
|
16733
16737
|
thoughtSignature?: string;
|
|
16734
16738
|
time: {
|
|
16735
16739
|
start: number;
|
|
@@ -16755,7 +16759,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16755
16759
|
details?: any;
|
|
16756
16760
|
isError: true;
|
|
16757
16761
|
};
|
|
16758
|
-
status: "
|
|
16762
|
+
status: "error";
|
|
16759
16763
|
thoughtSignature?: string;
|
|
16760
16764
|
time: {
|
|
16761
16765
|
start: number;
|
|
@@ -16781,26 +16785,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16781
16785
|
details?: any;
|
|
16782
16786
|
isError: true;
|
|
16783
16787
|
};
|
|
16784
|
-
status: "
|
|
16788
|
+
status: "skipped";
|
|
16785
16789
|
thoughtSignature?: string;
|
|
16786
16790
|
time: {
|
|
16787
16791
|
start: number;
|
|
16788
16792
|
end: number;
|
|
16789
16793
|
};
|
|
16790
16794
|
type: "toolCall";
|
|
16791
|
-
} | {
|
|
16792
|
-
type: "thinking";
|
|
16793
|
-
thinking: string;
|
|
16794
|
-
thinkingSignature?: string;
|
|
16795
|
-
redacted?: boolean;
|
|
16796
16795
|
} | {
|
|
16797
16796
|
addedToolNames?: string[];
|
|
16798
16797
|
arguments: Record<string, any>;
|
|
16799
16798
|
callID: string;
|
|
16800
16799
|
name: string;
|
|
16801
16800
|
namespace?: string;
|
|
16802
|
-
|
|
16803
|
-
content
|
|
16801
|
+
result: {
|
|
16802
|
+
content: ({
|
|
16804
16803
|
type: "text";
|
|
16805
16804
|
text: string;
|
|
16806
16805
|
textSignature?: string;
|
|
@@ -16810,8 +16809,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16810
16809
|
mimeType: string;
|
|
16811
16810
|
})[];
|
|
16812
16811
|
details?: any;
|
|
16812
|
+
isError: true;
|
|
16813
16813
|
};
|
|
16814
|
-
status: "
|
|
16814
|
+
status: "aborted";
|
|
16815
16815
|
thoughtSignature?: string;
|
|
16816
16816
|
time: {
|
|
16817
16817
|
start: number;
|
|
@@ -17292,14 +17292,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17292
17292
|
type: "image";
|
|
17293
17293
|
data: string;
|
|
17294
17294
|
mimeType: string;
|
|
17295
|
+
} | {
|
|
17296
|
+
type: "thinking";
|
|
17297
|
+
thinking: string;
|
|
17298
|
+
thinkingSignature?: string;
|
|
17299
|
+
redacted?: boolean;
|
|
17295
17300
|
} | {
|
|
17296
17301
|
addedToolNames?: string[];
|
|
17297
17302
|
arguments: Record<string, any>;
|
|
17298
17303
|
callID: string;
|
|
17299
17304
|
name: string;
|
|
17300
17305
|
namespace?: string;
|
|
17301
|
-
|
|
17302
|
-
content
|
|
17306
|
+
partial?: {
|
|
17307
|
+
content?: ({
|
|
17303
17308
|
type: "text";
|
|
17304
17309
|
text: string;
|
|
17305
17310
|
textSignature?: string;
|
|
@@ -17309,9 +17314,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17309
17314
|
mimeType: string;
|
|
17310
17315
|
})[];
|
|
17311
17316
|
details?: any;
|
|
17312
|
-
isError: false;
|
|
17313
17317
|
};
|
|
17314
|
-
status: "
|
|
17318
|
+
status: "running";
|
|
17315
17319
|
thoughtSignature?: string;
|
|
17316
17320
|
time: {
|
|
17317
17321
|
start: number;
|
|
@@ -17335,9 +17339,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17335
17339
|
mimeType: string;
|
|
17336
17340
|
})[];
|
|
17337
17341
|
details?: any;
|
|
17338
|
-
isError:
|
|
17342
|
+
isError: false;
|
|
17339
17343
|
};
|
|
17340
|
-
status: "
|
|
17344
|
+
status: "completed";
|
|
17341
17345
|
thoughtSignature?: string;
|
|
17342
17346
|
time: {
|
|
17343
17347
|
start: number;
|
|
@@ -17363,7 +17367,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17363
17367
|
details?: any;
|
|
17364
17368
|
isError: true;
|
|
17365
17369
|
};
|
|
17366
|
-
status: "
|
|
17370
|
+
status: "error";
|
|
17367
17371
|
thoughtSignature?: string;
|
|
17368
17372
|
time: {
|
|
17369
17373
|
start: number;
|
|
@@ -17389,26 +17393,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17389
17393
|
details?: any;
|
|
17390
17394
|
isError: true;
|
|
17391
17395
|
};
|
|
17392
|
-
status: "
|
|
17396
|
+
status: "skipped";
|
|
17393
17397
|
thoughtSignature?: string;
|
|
17394
17398
|
time: {
|
|
17395
17399
|
start: number;
|
|
17396
17400
|
end: number;
|
|
17397
17401
|
};
|
|
17398
17402
|
type: "toolCall";
|
|
17399
|
-
} | {
|
|
17400
|
-
type: "thinking";
|
|
17401
|
-
thinking: string;
|
|
17402
|
-
thinkingSignature?: string;
|
|
17403
|
-
redacted?: boolean;
|
|
17404
17403
|
} | {
|
|
17405
17404
|
addedToolNames?: string[];
|
|
17406
17405
|
arguments: Record<string, any>;
|
|
17407
17406
|
callID: string;
|
|
17408
17407
|
name: string;
|
|
17409
17408
|
namespace?: string;
|
|
17410
|
-
|
|
17411
|
-
content
|
|
17409
|
+
result: {
|
|
17410
|
+
content: ({
|
|
17412
17411
|
type: "text";
|
|
17413
17412
|
text: string;
|
|
17414
17413
|
textSignature?: string;
|
|
@@ -17418,8 +17417,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17418
17417
|
mimeType: string;
|
|
17419
17418
|
})[];
|
|
17420
17419
|
details?: any;
|
|
17420
|
+
isError: true;
|
|
17421
17421
|
};
|
|
17422
|
-
status: "
|
|
17422
|
+
status: "aborted";
|
|
17423
17423
|
thoughtSignature?: string;
|
|
17424
17424
|
time: {
|
|
17425
17425
|
start: number;
|
|
@@ -17594,14 +17594,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17594
17594
|
type: "image";
|
|
17595
17595
|
data: string;
|
|
17596
17596
|
mimeType: string;
|
|
17597
|
+
} | {
|
|
17598
|
+
type: "thinking";
|
|
17599
|
+
thinking: string;
|
|
17600
|
+
thinkingSignature?: string;
|
|
17601
|
+
redacted?: boolean;
|
|
17597
17602
|
} | {
|
|
17598
17603
|
addedToolNames?: string[];
|
|
17599
17604
|
arguments: Record<string, any>;
|
|
17600
17605
|
callID: string;
|
|
17601
17606
|
name: string;
|
|
17602
17607
|
namespace?: string;
|
|
17603
|
-
|
|
17604
|
-
content
|
|
17608
|
+
partial?: {
|
|
17609
|
+
content?: ({
|
|
17605
17610
|
type: "text";
|
|
17606
17611
|
text: string;
|
|
17607
17612
|
textSignature?: string;
|
|
@@ -17611,9 +17616,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17611
17616
|
mimeType: string;
|
|
17612
17617
|
})[];
|
|
17613
17618
|
details?: any;
|
|
17614
|
-
isError: false;
|
|
17615
17619
|
};
|
|
17616
|
-
status: "
|
|
17620
|
+
status: "running";
|
|
17617
17621
|
thoughtSignature?: string;
|
|
17618
17622
|
time: {
|
|
17619
17623
|
start: number;
|
|
@@ -17637,9 +17641,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17637
17641
|
mimeType: string;
|
|
17638
17642
|
})[];
|
|
17639
17643
|
details?: any;
|
|
17640
|
-
isError:
|
|
17644
|
+
isError: false;
|
|
17641
17645
|
};
|
|
17642
|
-
status: "
|
|
17646
|
+
status: "completed";
|
|
17643
17647
|
thoughtSignature?: string;
|
|
17644
17648
|
time: {
|
|
17645
17649
|
start: number;
|
|
@@ -17665,7 +17669,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17665
17669
|
details?: any;
|
|
17666
17670
|
isError: true;
|
|
17667
17671
|
};
|
|
17668
|
-
status: "
|
|
17672
|
+
status: "error";
|
|
17669
17673
|
thoughtSignature?: string;
|
|
17670
17674
|
time: {
|
|
17671
17675
|
start: number;
|
|
@@ -17691,26 +17695,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17691
17695
|
details?: any;
|
|
17692
17696
|
isError: true;
|
|
17693
17697
|
};
|
|
17694
|
-
status: "
|
|
17698
|
+
status: "skipped";
|
|
17695
17699
|
thoughtSignature?: string;
|
|
17696
17700
|
time: {
|
|
17697
17701
|
start: number;
|
|
17698
17702
|
end: number;
|
|
17699
17703
|
};
|
|
17700
17704
|
type: "toolCall";
|
|
17701
|
-
} | {
|
|
17702
|
-
type: "thinking";
|
|
17703
|
-
thinking: string;
|
|
17704
|
-
thinkingSignature?: string;
|
|
17705
|
-
redacted?: boolean;
|
|
17706
17705
|
} | {
|
|
17707
17706
|
addedToolNames?: string[];
|
|
17708
17707
|
arguments: Record<string, any>;
|
|
17709
17708
|
callID: string;
|
|
17710
17709
|
name: string;
|
|
17711
17710
|
namespace?: string;
|
|
17712
|
-
|
|
17713
|
-
content
|
|
17711
|
+
result: {
|
|
17712
|
+
content: ({
|
|
17714
17713
|
type: "text";
|
|
17715
17714
|
text: string;
|
|
17716
17715
|
textSignature?: string;
|
|
@@ -17720,8 +17719,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17720
17719
|
mimeType: string;
|
|
17721
17720
|
})[];
|
|
17722
17721
|
details?: any;
|
|
17722
|
+
isError: true;
|
|
17723
17723
|
};
|
|
17724
|
-
status: "
|
|
17724
|
+
status: "aborted";
|
|
17725
17725
|
thoughtSignature?: string;
|
|
17726
17726
|
time: {
|
|
17727
17727
|
start: number;
|
|
@@ -17915,14 +17915,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17915
17915
|
type: "image";
|
|
17916
17916
|
data: string;
|
|
17917
17917
|
mimeType: string;
|
|
17918
|
+
} | {
|
|
17919
|
+
type: "thinking";
|
|
17920
|
+
thinking: string;
|
|
17921
|
+
thinkingSignature?: string;
|
|
17922
|
+
redacted?: boolean;
|
|
17918
17923
|
} | {
|
|
17919
17924
|
addedToolNames?: string[];
|
|
17920
17925
|
arguments: Record<string, any>;
|
|
17921
17926
|
callID: string;
|
|
17922
17927
|
name: string;
|
|
17923
17928
|
namespace?: string;
|
|
17924
|
-
|
|
17925
|
-
content
|
|
17929
|
+
partial?: {
|
|
17930
|
+
content?: ({
|
|
17926
17931
|
type: "text";
|
|
17927
17932
|
text: string;
|
|
17928
17933
|
textSignature?: string;
|
|
@@ -17932,9 +17937,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17932
17937
|
mimeType: string;
|
|
17933
17938
|
})[];
|
|
17934
17939
|
details?: any;
|
|
17935
|
-
isError: false;
|
|
17936
17940
|
};
|
|
17937
|
-
status: "
|
|
17941
|
+
status: "running";
|
|
17938
17942
|
thoughtSignature?: string;
|
|
17939
17943
|
time: {
|
|
17940
17944
|
start: number;
|
|
@@ -17958,9 +17962,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17958
17962
|
mimeType: string;
|
|
17959
17963
|
})[];
|
|
17960
17964
|
details?: any;
|
|
17961
|
-
isError:
|
|
17965
|
+
isError: false;
|
|
17962
17966
|
};
|
|
17963
|
-
status: "
|
|
17967
|
+
status: "completed";
|
|
17964
17968
|
thoughtSignature?: string;
|
|
17965
17969
|
time: {
|
|
17966
17970
|
start: number;
|
|
@@ -17986,7 +17990,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17986
17990
|
details?: any;
|
|
17987
17991
|
isError: true;
|
|
17988
17992
|
};
|
|
17989
|
-
status: "
|
|
17993
|
+
status: "error";
|
|
17990
17994
|
thoughtSignature?: string;
|
|
17991
17995
|
time: {
|
|
17992
17996
|
start: number;
|
|
@@ -18012,26 +18016,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18012
18016
|
details?: any;
|
|
18013
18017
|
isError: true;
|
|
18014
18018
|
};
|
|
18015
|
-
status: "
|
|
18019
|
+
status: "skipped";
|
|
18016
18020
|
thoughtSignature?: string;
|
|
18017
18021
|
time: {
|
|
18018
18022
|
start: number;
|
|
18019
18023
|
end: number;
|
|
18020
18024
|
};
|
|
18021
18025
|
type: "toolCall";
|
|
18022
|
-
} | {
|
|
18023
|
-
type: "thinking";
|
|
18024
|
-
thinking: string;
|
|
18025
|
-
thinkingSignature?: string;
|
|
18026
|
-
redacted?: boolean;
|
|
18027
18026
|
} | {
|
|
18028
18027
|
addedToolNames?: string[];
|
|
18029
18028
|
arguments: Record<string, any>;
|
|
18030
18029
|
callID: string;
|
|
18031
18030
|
name: string;
|
|
18032
18031
|
namespace?: string;
|
|
18033
|
-
|
|
18034
|
-
content
|
|
18032
|
+
result: {
|
|
18033
|
+
content: ({
|
|
18035
18034
|
type: "text";
|
|
18036
18035
|
text: string;
|
|
18037
18036
|
textSignature?: string;
|
|
@@ -18041,8 +18040,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18041
18040
|
mimeType: string;
|
|
18042
18041
|
})[];
|
|
18043
18042
|
details?: any;
|
|
18043
|
+
isError: true;
|
|
18044
18044
|
};
|
|
18045
|
-
status: "
|
|
18045
|
+
status: "aborted";
|
|
18046
18046
|
thoughtSignature?: string;
|
|
18047
18047
|
time: {
|
|
18048
18048
|
start: number;
|
|
@@ -18217,14 +18217,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18217
18217
|
type: "image";
|
|
18218
18218
|
data: string;
|
|
18219
18219
|
mimeType: string;
|
|
18220
|
+
} | {
|
|
18221
|
+
type: "thinking";
|
|
18222
|
+
thinking: string;
|
|
18223
|
+
thinkingSignature?: string;
|
|
18224
|
+
redacted?: boolean;
|
|
18220
18225
|
} | {
|
|
18221
18226
|
addedToolNames?: string[];
|
|
18222
18227
|
arguments: Record<string, any>;
|
|
18223
18228
|
callID: string;
|
|
18224
18229
|
name: string;
|
|
18225
18230
|
namespace?: string;
|
|
18226
|
-
|
|
18227
|
-
content
|
|
18231
|
+
partial?: {
|
|
18232
|
+
content?: ({
|
|
18228
18233
|
type: "text";
|
|
18229
18234
|
text: string;
|
|
18230
18235
|
textSignature?: string;
|
|
@@ -18234,9 +18239,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18234
18239
|
mimeType: string;
|
|
18235
18240
|
})[];
|
|
18236
18241
|
details?: any;
|
|
18237
|
-
isError: false;
|
|
18238
18242
|
};
|
|
18239
|
-
status: "
|
|
18243
|
+
status: "running";
|
|
18240
18244
|
thoughtSignature?: string;
|
|
18241
18245
|
time: {
|
|
18242
18246
|
start: number;
|
|
@@ -18260,9 +18264,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18260
18264
|
mimeType: string;
|
|
18261
18265
|
})[];
|
|
18262
18266
|
details?: any;
|
|
18263
|
-
isError:
|
|
18267
|
+
isError: false;
|
|
18264
18268
|
};
|
|
18265
|
-
status: "
|
|
18269
|
+
status: "completed";
|
|
18266
18270
|
thoughtSignature?: string;
|
|
18267
18271
|
time: {
|
|
18268
18272
|
start: number;
|
|
@@ -18288,7 +18292,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18288
18292
|
details?: any;
|
|
18289
18293
|
isError: true;
|
|
18290
18294
|
};
|
|
18291
|
-
status: "
|
|
18295
|
+
status: "error";
|
|
18292
18296
|
thoughtSignature?: string;
|
|
18293
18297
|
time: {
|
|
18294
18298
|
start: number;
|
|
@@ -18314,26 +18318,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18314
18318
|
details?: any;
|
|
18315
18319
|
isError: true;
|
|
18316
18320
|
};
|
|
18317
|
-
status: "
|
|
18321
|
+
status: "skipped";
|
|
18318
18322
|
thoughtSignature?: string;
|
|
18319
18323
|
time: {
|
|
18320
18324
|
start: number;
|
|
18321
18325
|
end: number;
|
|
18322
18326
|
};
|
|
18323
18327
|
type: "toolCall";
|
|
18324
|
-
} | {
|
|
18325
|
-
type: "thinking";
|
|
18326
|
-
thinking: string;
|
|
18327
|
-
thinkingSignature?: string;
|
|
18328
|
-
redacted?: boolean;
|
|
18329
18328
|
} | {
|
|
18330
18329
|
addedToolNames?: string[];
|
|
18331
18330
|
arguments: Record<string, any>;
|
|
18332
18331
|
callID: string;
|
|
18333
18332
|
name: string;
|
|
18334
18333
|
namespace?: string;
|
|
18335
|
-
|
|
18336
|
-
content
|
|
18334
|
+
result: {
|
|
18335
|
+
content: ({
|
|
18337
18336
|
type: "text";
|
|
18338
18337
|
text: string;
|
|
18339
18338
|
textSignature?: string;
|
|
@@ -18343,8 +18342,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18343
18342
|
mimeType: string;
|
|
18344
18343
|
})[];
|
|
18345
18344
|
details?: any;
|
|
18345
|
+
isError: true;
|
|
18346
18346
|
};
|
|
18347
|
-
status: "
|
|
18347
|
+
status: "aborted";
|
|
18348
18348
|
thoughtSignature?: string;
|
|
18349
18349
|
time: {
|
|
18350
18350
|
start: number;
|
|
@@ -18547,14 +18547,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18547
18547
|
type: "image";
|
|
18548
18548
|
data: string;
|
|
18549
18549
|
mimeType: string;
|
|
18550
|
+
} | {
|
|
18551
|
+
type: "thinking";
|
|
18552
|
+
thinking: string;
|
|
18553
|
+
thinkingSignature?: string;
|
|
18554
|
+
redacted?: boolean;
|
|
18550
18555
|
} | {
|
|
18551
18556
|
addedToolNames?: string[];
|
|
18552
18557
|
arguments: Record<string, any>;
|
|
18553
18558
|
callID: string;
|
|
18554
18559
|
name: string;
|
|
18555
18560
|
namespace?: string;
|
|
18556
|
-
|
|
18557
|
-
content
|
|
18561
|
+
partial?: {
|
|
18562
|
+
content?: ({
|
|
18558
18563
|
type: "text";
|
|
18559
18564
|
text: string;
|
|
18560
18565
|
textSignature?: string;
|
|
@@ -18564,9 +18569,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18564
18569
|
mimeType: string;
|
|
18565
18570
|
})[];
|
|
18566
18571
|
details?: any;
|
|
18567
|
-
isError: false;
|
|
18568
18572
|
};
|
|
18569
|
-
status: "
|
|
18573
|
+
status: "running";
|
|
18570
18574
|
thoughtSignature?: string;
|
|
18571
18575
|
time: {
|
|
18572
18576
|
start: number;
|
|
@@ -18590,9 +18594,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18590
18594
|
mimeType: string;
|
|
18591
18595
|
})[];
|
|
18592
18596
|
details?: any;
|
|
18593
|
-
isError:
|
|
18597
|
+
isError: false;
|
|
18594
18598
|
};
|
|
18595
|
-
status: "
|
|
18599
|
+
status: "completed";
|
|
18596
18600
|
thoughtSignature?: string;
|
|
18597
18601
|
time: {
|
|
18598
18602
|
start: number;
|
|
@@ -18618,7 +18622,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18618
18622
|
details?: any;
|
|
18619
18623
|
isError: true;
|
|
18620
18624
|
};
|
|
18621
|
-
status: "
|
|
18625
|
+
status: "error";
|
|
18622
18626
|
thoughtSignature?: string;
|
|
18623
18627
|
time: {
|
|
18624
18628
|
start: number;
|
|
@@ -18644,26 +18648,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18644
18648
|
details?: any;
|
|
18645
18649
|
isError: true;
|
|
18646
18650
|
};
|
|
18647
|
-
status: "
|
|
18651
|
+
status: "skipped";
|
|
18648
18652
|
thoughtSignature?: string;
|
|
18649
18653
|
time: {
|
|
18650
18654
|
start: number;
|
|
18651
18655
|
end: number;
|
|
18652
18656
|
};
|
|
18653
18657
|
type: "toolCall";
|
|
18654
|
-
} | {
|
|
18655
|
-
type: "thinking";
|
|
18656
|
-
thinking: string;
|
|
18657
|
-
thinkingSignature?: string;
|
|
18658
|
-
redacted?: boolean;
|
|
18659
18658
|
} | {
|
|
18660
18659
|
addedToolNames?: string[];
|
|
18661
18660
|
arguments: Record<string, any>;
|
|
18662
18661
|
callID: string;
|
|
18663
18662
|
name: string;
|
|
18664
18663
|
namespace?: string;
|
|
18665
|
-
|
|
18666
|
-
content
|
|
18664
|
+
result: {
|
|
18665
|
+
content: ({
|
|
18667
18666
|
type: "text";
|
|
18668
18667
|
text: string;
|
|
18669
18668
|
textSignature?: string;
|
|
@@ -18673,8 +18672,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18673
18672
|
mimeType: string;
|
|
18674
18673
|
})[];
|
|
18675
18674
|
details?: any;
|
|
18675
|
+
isError: true;
|
|
18676
18676
|
};
|
|
18677
|
-
status: "
|
|
18677
|
+
status: "aborted";
|
|
18678
18678
|
thoughtSignature?: string;
|
|
18679
18679
|
time: {
|
|
18680
18680
|
start: number;
|
|
@@ -18849,14 +18849,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18849
18849
|
type: "image";
|
|
18850
18850
|
data: string;
|
|
18851
18851
|
mimeType: string;
|
|
18852
|
+
} | {
|
|
18853
|
+
type: "thinking";
|
|
18854
|
+
thinking: string;
|
|
18855
|
+
thinkingSignature?: string;
|
|
18856
|
+
redacted?: boolean;
|
|
18852
18857
|
} | {
|
|
18853
18858
|
addedToolNames?: string[];
|
|
18854
18859
|
arguments: Record<string, any>;
|
|
18855
18860
|
callID: string;
|
|
18856
18861
|
name: string;
|
|
18857
18862
|
namespace?: string;
|
|
18858
|
-
|
|
18859
|
-
content
|
|
18863
|
+
partial?: {
|
|
18864
|
+
content?: ({
|
|
18860
18865
|
type: "text";
|
|
18861
18866
|
text: string;
|
|
18862
18867
|
textSignature?: string;
|
|
@@ -18866,9 +18871,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18866
18871
|
mimeType: string;
|
|
18867
18872
|
})[];
|
|
18868
18873
|
details?: any;
|
|
18869
|
-
isError: false;
|
|
18870
18874
|
};
|
|
18871
|
-
status: "
|
|
18875
|
+
status: "running";
|
|
18872
18876
|
thoughtSignature?: string;
|
|
18873
18877
|
time: {
|
|
18874
18878
|
start: number;
|
|
@@ -18892,9 +18896,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18892
18896
|
mimeType: string;
|
|
18893
18897
|
})[];
|
|
18894
18898
|
details?: any;
|
|
18895
|
-
isError:
|
|
18899
|
+
isError: false;
|
|
18896
18900
|
};
|
|
18897
|
-
status: "
|
|
18901
|
+
status: "completed";
|
|
18898
18902
|
thoughtSignature?: string;
|
|
18899
18903
|
time: {
|
|
18900
18904
|
start: number;
|
|
@@ -18920,7 +18924,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18920
18924
|
details?: any;
|
|
18921
18925
|
isError: true;
|
|
18922
18926
|
};
|
|
18923
|
-
status: "
|
|
18927
|
+
status: "error";
|
|
18924
18928
|
thoughtSignature?: string;
|
|
18925
18929
|
time: {
|
|
18926
18930
|
start: number;
|
|
@@ -18946,26 +18950,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18946
18950
|
details?: any;
|
|
18947
18951
|
isError: true;
|
|
18948
18952
|
};
|
|
18949
|
-
status: "
|
|
18953
|
+
status: "skipped";
|
|
18950
18954
|
thoughtSignature?: string;
|
|
18951
18955
|
time: {
|
|
18952
18956
|
start: number;
|
|
18953
18957
|
end: number;
|
|
18954
18958
|
};
|
|
18955
18959
|
type: "toolCall";
|
|
18956
|
-
} | {
|
|
18957
|
-
type: "thinking";
|
|
18958
|
-
thinking: string;
|
|
18959
|
-
thinkingSignature?: string;
|
|
18960
|
-
redacted?: boolean;
|
|
18961
18960
|
} | {
|
|
18962
18961
|
addedToolNames?: string[];
|
|
18963
18962
|
arguments: Record<string, any>;
|
|
18964
18963
|
callID: string;
|
|
18965
18964
|
name: string;
|
|
18966
18965
|
namespace?: string;
|
|
18967
|
-
|
|
18968
|
-
content
|
|
18966
|
+
result: {
|
|
18967
|
+
content: ({
|
|
18969
18968
|
type: "text";
|
|
18970
18969
|
text: string;
|
|
18971
18970
|
textSignature?: string;
|
|
@@ -18975,8 +18974,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18975
18974
|
mimeType: string;
|
|
18976
18975
|
})[];
|
|
18977
18976
|
details?: any;
|
|
18977
|
+
isError: true;
|
|
18978
18978
|
};
|
|
18979
|
-
status: "
|
|
18979
|
+
status: "aborted";
|
|
18980
18980
|
thoughtSignature?: string;
|
|
18981
18981
|
time: {
|
|
18982
18982
|
start: number;
|
|
@@ -19170,14 +19170,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19170
19170
|
type: "image";
|
|
19171
19171
|
data: string;
|
|
19172
19172
|
mimeType: string;
|
|
19173
|
+
} | {
|
|
19174
|
+
type: "thinking";
|
|
19175
|
+
thinking: string;
|
|
19176
|
+
thinkingSignature?: string;
|
|
19177
|
+
redacted?: boolean;
|
|
19173
19178
|
} | {
|
|
19174
19179
|
addedToolNames?: string[];
|
|
19175
19180
|
arguments: Record<string, any>;
|
|
19176
19181
|
callID: string;
|
|
19177
19182
|
name: string;
|
|
19178
19183
|
namespace?: string;
|
|
19179
|
-
|
|
19180
|
-
content
|
|
19184
|
+
partial?: {
|
|
19185
|
+
content?: ({
|
|
19181
19186
|
type: "text";
|
|
19182
19187
|
text: string;
|
|
19183
19188
|
textSignature?: string;
|
|
@@ -19187,9 +19192,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19187
19192
|
mimeType: string;
|
|
19188
19193
|
})[];
|
|
19189
19194
|
details?: any;
|
|
19190
|
-
isError: false;
|
|
19191
19195
|
};
|
|
19192
|
-
status: "
|
|
19196
|
+
status: "running";
|
|
19193
19197
|
thoughtSignature?: string;
|
|
19194
19198
|
time: {
|
|
19195
19199
|
start: number;
|
|
@@ -19213,9 +19217,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19213
19217
|
mimeType: string;
|
|
19214
19218
|
})[];
|
|
19215
19219
|
details?: any;
|
|
19216
|
-
isError:
|
|
19220
|
+
isError: false;
|
|
19217
19221
|
};
|
|
19218
|
-
status: "
|
|
19222
|
+
status: "completed";
|
|
19219
19223
|
thoughtSignature?: string;
|
|
19220
19224
|
time: {
|
|
19221
19225
|
start: number;
|
|
@@ -19241,7 +19245,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19241
19245
|
details?: any;
|
|
19242
19246
|
isError: true;
|
|
19243
19247
|
};
|
|
19244
|
-
status: "
|
|
19248
|
+
status: "error";
|
|
19245
19249
|
thoughtSignature?: string;
|
|
19246
19250
|
time: {
|
|
19247
19251
|
start: number;
|
|
@@ -19267,26 +19271,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19267
19271
|
details?: any;
|
|
19268
19272
|
isError: true;
|
|
19269
19273
|
};
|
|
19270
|
-
status: "
|
|
19274
|
+
status: "skipped";
|
|
19271
19275
|
thoughtSignature?: string;
|
|
19272
19276
|
time: {
|
|
19273
19277
|
start: number;
|
|
19274
19278
|
end: number;
|
|
19275
19279
|
};
|
|
19276
19280
|
type: "toolCall";
|
|
19277
|
-
} | {
|
|
19278
|
-
type: "thinking";
|
|
19279
|
-
thinking: string;
|
|
19280
|
-
thinkingSignature?: string;
|
|
19281
|
-
redacted?: boolean;
|
|
19282
19281
|
} | {
|
|
19283
19282
|
addedToolNames?: string[];
|
|
19284
19283
|
arguments: Record<string, any>;
|
|
19285
19284
|
callID: string;
|
|
19286
19285
|
name: string;
|
|
19287
19286
|
namespace?: string;
|
|
19288
|
-
|
|
19289
|
-
content
|
|
19287
|
+
result: {
|
|
19288
|
+
content: ({
|
|
19290
19289
|
type: "text";
|
|
19291
19290
|
text: string;
|
|
19292
19291
|
textSignature?: string;
|
|
@@ -19296,8 +19295,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19296
19295
|
mimeType: string;
|
|
19297
19296
|
})[];
|
|
19298
19297
|
details?: any;
|
|
19298
|
+
isError: true;
|
|
19299
19299
|
};
|
|
19300
|
-
status: "
|
|
19300
|
+
status: "aborted";
|
|
19301
19301
|
thoughtSignature?: string;
|
|
19302
19302
|
time: {
|
|
19303
19303
|
start: number;
|
|
@@ -19472,14 +19472,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19472
19472
|
type: "image";
|
|
19473
19473
|
data: string;
|
|
19474
19474
|
mimeType: string;
|
|
19475
|
+
} | {
|
|
19476
|
+
type: "thinking";
|
|
19477
|
+
thinking: string;
|
|
19478
|
+
thinkingSignature?: string;
|
|
19479
|
+
redacted?: boolean;
|
|
19475
19480
|
} | {
|
|
19476
19481
|
addedToolNames?: string[];
|
|
19477
19482
|
arguments: Record<string, any>;
|
|
19478
19483
|
callID: string;
|
|
19479
19484
|
name: string;
|
|
19480
19485
|
namespace?: string;
|
|
19481
|
-
|
|
19482
|
-
content
|
|
19486
|
+
partial?: {
|
|
19487
|
+
content?: ({
|
|
19483
19488
|
type: "text";
|
|
19484
19489
|
text: string;
|
|
19485
19490
|
textSignature?: string;
|
|
@@ -19489,9 +19494,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19489
19494
|
mimeType: string;
|
|
19490
19495
|
})[];
|
|
19491
19496
|
details?: any;
|
|
19492
|
-
isError: false;
|
|
19493
19497
|
};
|
|
19494
|
-
status: "
|
|
19498
|
+
status: "running";
|
|
19495
19499
|
thoughtSignature?: string;
|
|
19496
19500
|
time: {
|
|
19497
19501
|
start: number;
|
|
@@ -19515,9 +19519,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19515
19519
|
mimeType: string;
|
|
19516
19520
|
})[];
|
|
19517
19521
|
details?: any;
|
|
19518
|
-
isError:
|
|
19522
|
+
isError: false;
|
|
19519
19523
|
};
|
|
19520
|
-
status: "
|
|
19524
|
+
status: "completed";
|
|
19521
19525
|
thoughtSignature?: string;
|
|
19522
19526
|
time: {
|
|
19523
19527
|
start: number;
|
|
@@ -19543,7 +19547,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19543
19547
|
details?: any;
|
|
19544
19548
|
isError: true;
|
|
19545
19549
|
};
|
|
19546
|
-
status: "
|
|
19550
|
+
status: "error";
|
|
19547
19551
|
thoughtSignature?: string;
|
|
19548
19552
|
time: {
|
|
19549
19553
|
start: number;
|
|
@@ -19569,26 +19573,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19569
19573
|
details?: any;
|
|
19570
19574
|
isError: true;
|
|
19571
19575
|
};
|
|
19572
|
-
status: "
|
|
19576
|
+
status: "skipped";
|
|
19573
19577
|
thoughtSignature?: string;
|
|
19574
19578
|
time: {
|
|
19575
19579
|
start: number;
|
|
19576
19580
|
end: number;
|
|
19577
19581
|
};
|
|
19578
19582
|
type: "toolCall";
|
|
19579
|
-
} | {
|
|
19580
|
-
type: "thinking";
|
|
19581
|
-
thinking: string;
|
|
19582
|
-
thinkingSignature?: string;
|
|
19583
|
-
redacted?: boolean;
|
|
19584
19583
|
} | {
|
|
19585
19584
|
addedToolNames?: string[];
|
|
19586
19585
|
arguments: Record<string, any>;
|
|
19587
19586
|
callID: string;
|
|
19588
19587
|
name: string;
|
|
19589
19588
|
namespace?: string;
|
|
19590
|
-
|
|
19591
|
-
content
|
|
19589
|
+
result: {
|
|
19590
|
+
content: ({
|
|
19592
19591
|
type: "text";
|
|
19593
19592
|
text: string;
|
|
19594
19593
|
textSignature?: string;
|
|
@@ -19598,8 +19597,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19598
19597
|
mimeType: string;
|
|
19599
19598
|
})[];
|
|
19600
19599
|
details?: any;
|
|
19600
|
+
isError: true;
|
|
19601
19601
|
};
|
|
19602
|
-
status: "
|
|
19602
|
+
status: "aborted";
|
|
19603
19603
|
thoughtSignature?: string;
|
|
19604
19604
|
time: {
|
|
19605
19605
|
start: number;
|
|
@@ -20787,14 +20787,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20787
20787
|
type: "image";
|
|
20788
20788
|
data: string;
|
|
20789
20789
|
mimeType: string;
|
|
20790
|
+
} | {
|
|
20791
|
+
type: "thinking";
|
|
20792
|
+
thinking: string;
|
|
20793
|
+
thinkingSignature?: string;
|
|
20794
|
+
redacted?: boolean;
|
|
20790
20795
|
} | {
|
|
20791
20796
|
addedToolNames?: string[];
|
|
20792
20797
|
arguments: Record<string, any>;
|
|
20793
20798
|
callID: string;
|
|
20794
20799
|
name: string;
|
|
20795
20800
|
namespace?: string;
|
|
20796
|
-
|
|
20797
|
-
content
|
|
20801
|
+
partial?: {
|
|
20802
|
+
content?: ({
|
|
20798
20803
|
type: "text";
|
|
20799
20804
|
text: string;
|
|
20800
20805
|
textSignature?: string;
|
|
@@ -20804,9 +20809,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20804
20809
|
mimeType: string;
|
|
20805
20810
|
})[];
|
|
20806
20811
|
details?: any;
|
|
20807
|
-
isError: false;
|
|
20808
20812
|
};
|
|
20809
|
-
status: "
|
|
20813
|
+
status: "running";
|
|
20810
20814
|
thoughtSignature?: string;
|
|
20811
20815
|
time: {
|
|
20812
20816
|
start: number;
|
|
@@ -20830,9 +20834,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20830
20834
|
mimeType: string;
|
|
20831
20835
|
})[];
|
|
20832
20836
|
details?: any;
|
|
20833
|
-
isError:
|
|
20837
|
+
isError: false;
|
|
20834
20838
|
};
|
|
20835
|
-
status: "
|
|
20839
|
+
status: "completed";
|
|
20836
20840
|
thoughtSignature?: string;
|
|
20837
20841
|
time: {
|
|
20838
20842
|
start: number;
|
|
@@ -20858,7 +20862,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20858
20862
|
details?: any;
|
|
20859
20863
|
isError: true;
|
|
20860
20864
|
};
|
|
20861
|
-
status: "
|
|
20865
|
+
status: "error";
|
|
20862
20866
|
thoughtSignature?: string;
|
|
20863
20867
|
time: {
|
|
20864
20868
|
start: number;
|
|
@@ -20884,26 +20888,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20884
20888
|
details?: any;
|
|
20885
20889
|
isError: true;
|
|
20886
20890
|
};
|
|
20887
|
-
status: "
|
|
20891
|
+
status: "skipped";
|
|
20888
20892
|
thoughtSignature?: string;
|
|
20889
20893
|
time: {
|
|
20890
20894
|
start: number;
|
|
20891
20895
|
end: number;
|
|
20892
20896
|
};
|
|
20893
20897
|
type: "toolCall";
|
|
20894
|
-
} | {
|
|
20895
|
-
type: "thinking";
|
|
20896
|
-
thinking: string;
|
|
20897
|
-
thinkingSignature?: string;
|
|
20898
|
-
redacted?: boolean;
|
|
20899
20898
|
} | {
|
|
20900
20899
|
addedToolNames?: string[];
|
|
20901
20900
|
arguments: Record<string, any>;
|
|
20902
20901
|
callID: string;
|
|
20903
20902
|
name: string;
|
|
20904
20903
|
namespace?: string;
|
|
20905
|
-
|
|
20906
|
-
content
|
|
20904
|
+
result: {
|
|
20905
|
+
content: ({
|
|
20907
20906
|
type: "text";
|
|
20908
20907
|
text: string;
|
|
20909
20908
|
textSignature?: string;
|
|
@@ -20913,8 +20912,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20913
20912
|
mimeType: string;
|
|
20914
20913
|
})[];
|
|
20915
20914
|
details?: any;
|
|
20915
|
+
isError: true;
|
|
20916
20916
|
};
|
|
20917
|
-
status: "
|
|
20917
|
+
status: "aborted";
|
|
20918
20918
|
thoughtSignature?: string;
|
|
20919
20919
|
time: {
|
|
20920
20920
|
start: number;
|
|
@@ -21089,14 +21089,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21089
21089
|
type: "image";
|
|
21090
21090
|
data: string;
|
|
21091
21091
|
mimeType: string;
|
|
21092
|
+
} | {
|
|
21093
|
+
type: "thinking";
|
|
21094
|
+
thinking: string;
|
|
21095
|
+
thinkingSignature?: string;
|
|
21096
|
+
redacted?: boolean;
|
|
21092
21097
|
} | {
|
|
21093
21098
|
addedToolNames?: string[];
|
|
21094
21099
|
arguments: Record<string, any>;
|
|
21095
21100
|
callID: string;
|
|
21096
21101
|
name: string;
|
|
21097
21102
|
namespace?: string;
|
|
21098
|
-
|
|
21099
|
-
content
|
|
21103
|
+
partial?: {
|
|
21104
|
+
content?: ({
|
|
21100
21105
|
type: "text";
|
|
21101
21106
|
text: string;
|
|
21102
21107
|
textSignature?: string;
|
|
@@ -21106,9 +21111,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21106
21111
|
mimeType: string;
|
|
21107
21112
|
})[];
|
|
21108
21113
|
details?: any;
|
|
21109
|
-
isError: false;
|
|
21110
21114
|
};
|
|
21111
|
-
status: "
|
|
21115
|
+
status: "running";
|
|
21112
21116
|
thoughtSignature?: string;
|
|
21113
21117
|
time: {
|
|
21114
21118
|
start: number;
|
|
@@ -21132,9 +21136,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21132
21136
|
mimeType: string;
|
|
21133
21137
|
})[];
|
|
21134
21138
|
details?: any;
|
|
21135
|
-
isError:
|
|
21139
|
+
isError: false;
|
|
21136
21140
|
};
|
|
21137
|
-
status: "
|
|
21141
|
+
status: "completed";
|
|
21138
21142
|
thoughtSignature?: string;
|
|
21139
21143
|
time: {
|
|
21140
21144
|
start: number;
|
|
@@ -21160,7 +21164,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21160
21164
|
details?: any;
|
|
21161
21165
|
isError: true;
|
|
21162
21166
|
};
|
|
21163
|
-
status: "
|
|
21167
|
+
status: "error";
|
|
21164
21168
|
thoughtSignature?: string;
|
|
21165
21169
|
time: {
|
|
21166
21170
|
start: number;
|
|
@@ -21186,26 +21190,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21186
21190
|
details?: any;
|
|
21187
21191
|
isError: true;
|
|
21188
21192
|
};
|
|
21189
|
-
status: "
|
|
21193
|
+
status: "skipped";
|
|
21190
21194
|
thoughtSignature?: string;
|
|
21191
21195
|
time: {
|
|
21192
21196
|
start: number;
|
|
21193
21197
|
end: number;
|
|
21194
21198
|
};
|
|
21195
21199
|
type: "toolCall";
|
|
21196
|
-
} | {
|
|
21197
|
-
type: "thinking";
|
|
21198
|
-
thinking: string;
|
|
21199
|
-
thinkingSignature?: string;
|
|
21200
|
-
redacted?: boolean;
|
|
21201
21200
|
} | {
|
|
21202
21201
|
addedToolNames?: string[];
|
|
21203
21202
|
arguments: Record<string, any>;
|
|
21204
21203
|
callID: string;
|
|
21205
21204
|
name: string;
|
|
21206
21205
|
namespace?: string;
|
|
21207
|
-
|
|
21208
|
-
content
|
|
21206
|
+
result: {
|
|
21207
|
+
content: ({
|
|
21209
21208
|
type: "text";
|
|
21210
21209
|
text: string;
|
|
21211
21210
|
textSignature?: string;
|
|
@@ -21215,8 +21214,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21215
21214
|
mimeType: string;
|
|
21216
21215
|
})[];
|
|
21217
21216
|
details?: any;
|
|
21217
|
+
isError: true;
|
|
21218
21218
|
};
|
|
21219
|
-
status: "
|
|
21219
|
+
status: "aborted";
|
|
21220
21220
|
thoughtSignature?: string;
|
|
21221
21221
|
time: {
|
|
21222
21222
|
start: number;
|
|
@@ -21409,14 +21409,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21409
21409
|
type: "image";
|
|
21410
21410
|
data: string;
|
|
21411
21411
|
mimeType: string;
|
|
21412
|
+
} | {
|
|
21413
|
+
type: "thinking";
|
|
21414
|
+
thinking: string;
|
|
21415
|
+
thinkingSignature?: string;
|
|
21416
|
+
redacted?: boolean;
|
|
21412
21417
|
} | {
|
|
21413
21418
|
addedToolNames?: string[];
|
|
21414
21419
|
arguments: Record<string, any>;
|
|
21415
21420
|
callID: string;
|
|
21416
21421
|
name: string;
|
|
21417
21422
|
namespace?: string;
|
|
21418
|
-
|
|
21419
|
-
content
|
|
21423
|
+
partial?: {
|
|
21424
|
+
content?: ({
|
|
21420
21425
|
type: "text";
|
|
21421
21426
|
text: string;
|
|
21422
21427
|
textSignature?: string;
|
|
@@ -21426,9 +21431,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21426
21431
|
mimeType: string;
|
|
21427
21432
|
})[];
|
|
21428
21433
|
details?: any;
|
|
21429
|
-
isError: false;
|
|
21430
21434
|
};
|
|
21431
|
-
status: "
|
|
21435
|
+
status: "running";
|
|
21432
21436
|
thoughtSignature?: string;
|
|
21433
21437
|
time: {
|
|
21434
21438
|
start: number;
|
|
@@ -21452,9 +21456,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21452
21456
|
mimeType: string;
|
|
21453
21457
|
})[];
|
|
21454
21458
|
details?: any;
|
|
21455
|
-
isError:
|
|
21459
|
+
isError: false;
|
|
21456
21460
|
};
|
|
21457
|
-
status: "
|
|
21461
|
+
status: "completed";
|
|
21458
21462
|
thoughtSignature?: string;
|
|
21459
21463
|
time: {
|
|
21460
21464
|
start: number;
|
|
@@ -21480,7 +21484,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21480
21484
|
details?: any;
|
|
21481
21485
|
isError: true;
|
|
21482
21486
|
};
|
|
21483
|
-
status: "
|
|
21487
|
+
status: "error";
|
|
21484
21488
|
thoughtSignature?: string;
|
|
21485
21489
|
time: {
|
|
21486
21490
|
start: number;
|
|
@@ -21506,26 +21510,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21506
21510
|
details?: any;
|
|
21507
21511
|
isError: true;
|
|
21508
21512
|
};
|
|
21509
|
-
status: "
|
|
21513
|
+
status: "skipped";
|
|
21510
21514
|
thoughtSignature?: string;
|
|
21511
21515
|
time: {
|
|
21512
21516
|
start: number;
|
|
21513
21517
|
end: number;
|
|
21514
21518
|
};
|
|
21515
21519
|
type: "toolCall";
|
|
21516
|
-
} | {
|
|
21517
|
-
type: "thinking";
|
|
21518
|
-
thinking: string;
|
|
21519
|
-
thinkingSignature?: string;
|
|
21520
|
-
redacted?: boolean;
|
|
21521
21520
|
} | {
|
|
21522
21521
|
addedToolNames?: string[];
|
|
21523
21522
|
arguments: Record<string, any>;
|
|
21524
21523
|
callID: string;
|
|
21525
21524
|
name: string;
|
|
21526
21525
|
namespace?: string;
|
|
21527
|
-
|
|
21528
|
-
content
|
|
21526
|
+
result: {
|
|
21527
|
+
content: ({
|
|
21529
21528
|
type: "text";
|
|
21530
21529
|
text: string;
|
|
21531
21530
|
textSignature?: string;
|
|
@@ -21535,8 +21534,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21535
21534
|
mimeType: string;
|
|
21536
21535
|
})[];
|
|
21537
21536
|
details?: any;
|
|
21537
|
+
isError: true;
|
|
21538
21538
|
};
|
|
21539
|
-
status: "
|
|
21539
|
+
status: "aborted";
|
|
21540
21540
|
thoughtSignature?: string;
|
|
21541
21541
|
time: {
|
|
21542
21542
|
start: number;
|
|
@@ -21711,14 +21711,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21711
21711
|
type: "image";
|
|
21712
21712
|
data: string;
|
|
21713
21713
|
mimeType: string;
|
|
21714
|
+
} | {
|
|
21715
|
+
type: "thinking";
|
|
21716
|
+
thinking: string;
|
|
21717
|
+
thinkingSignature?: string;
|
|
21718
|
+
redacted?: boolean;
|
|
21714
21719
|
} | {
|
|
21715
21720
|
addedToolNames?: string[];
|
|
21716
21721
|
arguments: Record<string, any>;
|
|
21717
21722
|
callID: string;
|
|
21718
21723
|
name: string;
|
|
21719
21724
|
namespace?: string;
|
|
21720
|
-
|
|
21721
|
-
content
|
|
21725
|
+
partial?: {
|
|
21726
|
+
content?: ({
|
|
21722
21727
|
type: "text";
|
|
21723
21728
|
text: string;
|
|
21724
21729
|
textSignature?: string;
|
|
@@ -21728,9 +21733,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21728
21733
|
mimeType: string;
|
|
21729
21734
|
})[];
|
|
21730
21735
|
details?: any;
|
|
21731
|
-
isError: false;
|
|
21732
21736
|
};
|
|
21733
|
-
status: "
|
|
21737
|
+
status: "running";
|
|
21734
21738
|
thoughtSignature?: string;
|
|
21735
21739
|
time: {
|
|
21736
21740
|
start: number;
|
|
@@ -21754,9 +21758,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21754
21758
|
mimeType: string;
|
|
21755
21759
|
})[];
|
|
21756
21760
|
details?: any;
|
|
21757
|
-
isError:
|
|
21761
|
+
isError: false;
|
|
21758
21762
|
};
|
|
21759
|
-
status: "
|
|
21763
|
+
status: "completed";
|
|
21760
21764
|
thoughtSignature?: string;
|
|
21761
21765
|
time: {
|
|
21762
21766
|
start: number;
|
|
@@ -21782,7 +21786,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21782
21786
|
details?: any;
|
|
21783
21787
|
isError: true;
|
|
21784
21788
|
};
|
|
21785
|
-
status: "
|
|
21789
|
+
status: "error";
|
|
21786
21790
|
thoughtSignature?: string;
|
|
21787
21791
|
time: {
|
|
21788
21792
|
start: number;
|
|
@@ -21808,26 +21812,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21808
21812
|
details?: any;
|
|
21809
21813
|
isError: true;
|
|
21810
21814
|
};
|
|
21811
|
-
status: "
|
|
21815
|
+
status: "skipped";
|
|
21812
21816
|
thoughtSignature?: string;
|
|
21813
21817
|
time: {
|
|
21814
21818
|
start: number;
|
|
21815
21819
|
end: number;
|
|
21816
21820
|
};
|
|
21817
21821
|
type: "toolCall";
|
|
21818
|
-
} | {
|
|
21819
|
-
type: "thinking";
|
|
21820
|
-
thinking: string;
|
|
21821
|
-
thinkingSignature?: string;
|
|
21822
|
-
redacted?: boolean;
|
|
21823
21822
|
} | {
|
|
21824
21823
|
addedToolNames?: string[];
|
|
21825
21824
|
arguments: Record<string, any>;
|
|
21826
21825
|
callID: string;
|
|
21827
21826
|
name: string;
|
|
21828
21827
|
namespace?: string;
|
|
21829
|
-
|
|
21830
|
-
content
|
|
21828
|
+
result: {
|
|
21829
|
+
content: ({
|
|
21831
21830
|
type: "text";
|
|
21832
21831
|
text: string;
|
|
21833
21832
|
textSignature?: string;
|
|
@@ -21837,8 +21836,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21837
21836
|
mimeType: string;
|
|
21838
21837
|
})[];
|
|
21839
21838
|
details?: any;
|
|
21839
|
+
isError: true;
|
|
21840
21840
|
};
|
|
21841
|
-
status: "
|
|
21841
|
+
status: "aborted";
|
|
21842
21842
|
thoughtSignature?: string;
|
|
21843
21843
|
time: {
|
|
21844
21844
|
start: number;
|
|
@@ -22041,14 +22041,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22041
22041
|
type: "image";
|
|
22042
22042
|
data: string;
|
|
22043
22043
|
mimeType: string;
|
|
22044
|
+
} | {
|
|
22045
|
+
type: "thinking";
|
|
22046
|
+
thinking: string;
|
|
22047
|
+
thinkingSignature?: string;
|
|
22048
|
+
redacted?: boolean;
|
|
22044
22049
|
} | {
|
|
22045
22050
|
addedToolNames?: string[];
|
|
22046
22051
|
arguments: Record<string, any>;
|
|
22047
22052
|
callID: string;
|
|
22048
22053
|
name: string;
|
|
22049
22054
|
namespace?: string;
|
|
22050
|
-
|
|
22051
|
-
content
|
|
22055
|
+
partial?: {
|
|
22056
|
+
content?: ({
|
|
22052
22057
|
type: "text";
|
|
22053
22058
|
text: string;
|
|
22054
22059
|
textSignature?: string;
|
|
@@ -22058,9 +22063,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22058
22063
|
mimeType: string;
|
|
22059
22064
|
})[];
|
|
22060
22065
|
details?: any;
|
|
22061
|
-
isError: false;
|
|
22062
22066
|
};
|
|
22063
|
-
status: "
|
|
22067
|
+
status: "running";
|
|
22064
22068
|
thoughtSignature?: string;
|
|
22065
22069
|
time: {
|
|
22066
22070
|
start: number;
|
|
@@ -22084,9 +22088,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22084
22088
|
mimeType: string;
|
|
22085
22089
|
})[];
|
|
22086
22090
|
details?: any;
|
|
22087
|
-
isError:
|
|
22091
|
+
isError: false;
|
|
22088
22092
|
};
|
|
22089
|
-
status: "
|
|
22093
|
+
status: "completed";
|
|
22090
22094
|
thoughtSignature?: string;
|
|
22091
22095
|
time: {
|
|
22092
22096
|
start: number;
|
|
@@ -22112,7 +22116,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22112
22116
|
details?: any;
|
|
22113
22117
|
isError: true;
|
|
22114
22118
|
};
|
|
22115
|
-
status: "
|
|
22119
|
+
status: "error";
|
|
22116
22120
|
thoughtSignature?: string;
|
|
22117
22121
|
time: {
|
|
22118
22122
|
start: number;
|
|
@@ -22138,26 +22142,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22138
22142
|
details?: any;
|
|
22139
22143
|
isError: true;
|
|
22140
22144
|
};
|
|
22141
|
-
status: "
|
|
22145
|
+
status: "skipped";
|
|
22142
22146
|
thoughtSignature?: string;
|
|
22143
22147
|
time: {
|
|
22144
22148
|
start: number;
|
|
22145
22149
|
end: number;
|
|
22146
22150
|
};
|
|
22147
22151
|
type: "toolCall";
|
|
22148
|
-
} | {
|
|
22149
|
-
type: "thinking";
|
|
22150
|
-
thinking: string;
|
|
22151
|
-
thinkingSignature?: string;
|
|
22152
|
-
redacted?: boolean;
|
|
22153
22152
|
} | {
|
|
22154
22153
|
addedToolNames?: string[];
|
|
22155
22154
|
arguments: Record<string, any>;
|
|
22156
22155
|
callID: string;
|
|
22157
22156
|
name: string;
|
|
22158
22157
|
namespace?: string;
|
|
22159
|
-
|
|
22160
|
-
content
|
|
22158
|
+
result: {
|
|
22159
|
+
content: ({
|
|
22161
22160
|
type: "text";
|
|
22162
22161
|
text: string;
|
|
22163
22162
|
textSignature?: string;
|
|
@@ -22167,8 +22166,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22167
22166
|
mimeType: string;
|
|
22168
22167
|
})[];
|
|
22169
22168
|
details?: any;
|
|
22169
|
+
isError: true;
|
|
22170
22170
|
};
|
|
22171
|
-
status: "
|
|
22171
|
+
status: "aborted";
|
|
22172
22172
|
thoughtSignature?: string;
|
|
22173
22173
|
time: {
|
|
22174
22174
|
start: number;
|
|
@@ -22343,14 +22343,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22343
22343
|
type: "image";
|
|
22344
22344
|
data: string;
|
|
22345
22345
|
mimeType: string;
|
|
22346
|
+
} | {
|
|
22347
|
+
type: "thinking";
|
|
22348
|
+
thinking: string;
|
|
22349
|
+
thinkingSignature?: string;
|
|
22350
|
+
redacted?: boolean;
|
|
22346
22351
|
} | {
|
|
22347
22352
|
addedToolNames?: string[];
|
|
22348
22353
|
arguments: Record<string, any>;
|
|
22349
22354
|
callID: string;
|
|
22350
22355
|
name: string;
|
|
22351
22356
|
namespace?: string;
|
|
22352
|
-
|
|
22353
|
-
content
|
|
22357
|
+
partial?: {
|
|
22358
|
+
content?: ({
|
|
22354
22359
|
type: "text";
|
|
22355
22360
|
text: string;
|
|
22356
22361
|
textSignature?: string;
|
|
@@ -22360,9 +22365,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22360
22365
|
mimeType: string;
|
|
22361
22366
|
})[];
|
|
22362
22367
|
details?: any;
|
|
22363
|
-
isError: false;
|
|
22364
22368
|
};
|
|
22365
|
-
status: "
|
|
22369
|
+
status: "running";
|
|
22366
22370
|
thoughtSignature?: string;
|
|
22367
22371
|
time: {
|
|
22368
22372
|
start: number;
|
|
@@ -22386,9 +22390,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22386
22390
|
mimeType: string;
|
|
22387
22391
|
})[];
|
|
22388
22392
|
details?: any;
|
|
22389
|
-
isError:
|
|
22393
|
+
isError: false;
|
|
22390
22394
|
};
|
|
22391
|
-
status: "
|
|
22395
|
+
status: "completed";
|
|
22392
22396
|
thoughtSignature?: string;
|
|
22393
22397
|
time: {
|
|
22394
22398
|
start: number;
|
|
@@ -22414,7 +22418,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22414
22418
|
details?: any;
|
|
22415
22419
|
isError: true;
|
|
22416
22420
|
};
|
|
22417
|
-
status: "
|
|
22421
|
+
status: "error";
|
|
22418
22422
|
thoughtSignature?: string;
|
|
22419
22423
|
time: {
|
|
22420
22424
|
start: number;
|
|
@@ -22440,26 +22444,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22440
22444
|
details?: any;
|
|
22441
22445
|
isError: true;
|
|
22442
22446
|
};
|
|
22443
|
-
status: "
|
|
22447
|
+
status: "skipped";
|
|
22444
22448
|
thoughtSignature?: string;
|
|
22445
22449
|
time: {
|
|
22446
22450
|
start: number;
|
|
22447
22451
|
end: number;
|
|
22448
22452
|
};
|
|
22449
22453
|
type: "toolCall";
|
|
22450
|
-
} | {
|
|
22451
|
-
type: "thinking";
|
|
22452
|
-
thinking: string;
|
|
22453
|
-
thinkingSignature?: string;
|
|
22454
|
-
redacted?: boolean;
|
|
22455
22454
|
} | {
|
|
22456
22455
|
addedToolNames?: string[];
|
|
22457
22456
|
arguments: Record<string, any>;
|
|
22458
22457
|
callID: string;
|
|
22459
22458
|
name: string;
|
|
22460
22459
|
namespace?: string;
|
|
22461
|
-
|
|
22462
|
-
content
|
|
22460
|
+
result: {
|
|
22461
|
+
content: ({
|
|
22463
22462
|
type: "text";
|
|
22464
22463
|
text: string;
|
|
22465
22464
|
textSignature?: string;
|
|
@@ -22469,8 +22468,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22469
22468
|
mimeType: string;
|
|
22470
22469
|
})[];
|
|
22471
22470
|
details?: any;
|
|
22471
|
+
isError: true;
|
|
22472
22472
|
};
|
|
22473
|
-
status: "
|
|
22473
|
+
status: "aborted";
|
|
22474
22474
|
thoughtSignature?: string;
|
|
22475
22475
|
time: {
|
|
22476
22476
|
start: number;
|
|
@@ -22664,14 +22664,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22664
22664
|
type: "image";
|
|
22665
22665
|
data: string;
|
|
22666
22666
|
mimeType: string;
|
|
22667
|
+
} | {
|
|
22668
|
+
type: "thinking";
|
|
22669
|
+
thinking: string;
|
|
22670
|
+
thinkingSignature?: string;
|
|
22671
|
+
redacted?: boolean;
|
|
22667
22672
|
} | {
|
|
22668
22673
|
addedToolNames?: string[];
|
|
22669
22674
|
arguments: Record<string, any>;
|
|
22670
22675
|
callID: string;
|
|
22671
22676
|
name: string;
|
|
22672
22677
|
namespace?: string;
|
|
22673
|
-
|
|
22674
|
-
content
|
|
22678
|
+
partial?: {
|
|
22679
|
+
content?: ({
|
|
22675
22680
|
type: "text";
|
|
22676
22681
|
text: string;
|
|
22677
22682
|
textSignature?: string;
|
|
@@ -22681,9 +22686,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22681
22686
|
mimeType: string;
|
|
22682
22687
|
})[];
|
|
22683
22688
|
details?: any;
|
|
22684
|
-
isError: false;
|
|
22685
22689
|
};
|
|
22686
|
-
status: "
|
|
22690
|
+
status: "running";
|
|
22687
22691
|
thoughtSignature?: string;
|
|
22688
22692
|
time: {
|
|
22689
22693
|
start: number;
|
|
@@ -22707,9 +22711,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22707
22711
|
mimeType: string;
|
|
22708
22712
|
})[];
|
|
22709
22713
|
details?: any;
|
|
22710
|
-
isError:
|
|
22714
|
+
isError: false;
|
|
22711
22715
|
};
|
|
22712
|
-
status: "
|
|
22716
|
+
status: "completed";
|
|
22713
22717
|
thoughtSignature?: string;
|
|
22714
22718
|
time: {
|
|
22715
22719
|
start: number;
|
|
@@ -22735,7 +22739,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22735
22739
|
details?: any;
|
|
22736
22740
|
isError: true;
|
|
22737
22741
|
};
|
|
22738
|
-
status: "
|
|
22742
|
+
status: "error";
|
|
22739
22743
|
thoughtSignature?: string;
|
|
22740
22744
|
time: {
|
|
22741
22745
|
start: number;
|
|
@@ -22761,26 +22765,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22761
22765
|
details?: any;
|
|
22762
22766
|
isError: true;
|
|
22763
22767
|
};
|
|
22764
|
-
status: "
|
|
22768
|
+
status: "skipped";
|
|
22765
22769
|
thoughtSignature?: string;
|
|
22766
22770
|
time: {
|
|
22767
22771
|
start: number;
|
|
22768
22772
|
end: number;
|
|
22769
22773
|
};
|
|
22770
22774
|
type: "toolCall";
|
|
22771
|
-
} | {
|
|
22772
|
-
type: "thinking";
|
|
22773
|
-
thinking: string;
|
|
22774
|
-
thinkingSignature?: string;
|
|
22775
|
-
redacted?: boolean;
|
|
22776
22775
|
} | {
|
|
22777
22776
|
addedToolNames?: string[];
|
|
22778
22777
|
arguments: Record<string, any>;
|
|
22779
22778
|
callID: string;
|
|
22780
22779
|
name: string;
|
|
22781
22780
|
namespace?: string;
|
|
22782
|
-
|
|
22783
|
-
content
|
|
22781
|
+
result: {
|
|
22782
|
+
content: ({
|
|
22784
22783
|
type: "text";
|
|
22785
22784
|
text: string;
|
|
22786
22785
|
textSignature?: string;
|
|
@@ -22790,8 +22789,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22790
22789
|
mimeType: string;
|
|
22791
22790
|
})[];
|
|
22792
22791
|
details?: any;
|
|
22792
|
+
isError: true;
|
|
22793
22793
|
};
|
|
22794
|
-
status: "
|
|
22794
|
+
status: "aborted";
|
|
22795
22795
|
thoughtSignature?: string;
|
|
22796
22796
|
time: {
|
|
22797
22797
|
start: number;
|
|
@@ -22966,14 +22966,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22966
22966
|
type: "image";
|
|
22967
22967
|
data: string;
|
|
22968
22968
|
mimeType: string;
|
|
22969
|
+
} | {
|
|
22970
|
+
type: "thinking";
|
|
22971
|
+
thinking: string;
|
|
22972
|
+
thinkingSignature?: string;
|
|
22973
|
+
redacted?: boolean;
|
|
22969
22974
|
} | {
|
|
22970
22975
|
addedToolNames?: string[];
|
|
22971
22976
|
arguments: Record<string, any>;
|
|
22972
22977
|
callID: string;
|
|
22973
22978
|
name: string;
|
|
22974
22979
|
namespace?: string;
|
|
22975
|
-
|
|
22976
|
-
content
|
|
22980
|
+
partial?: {
|
|
22981
|
+
content?: ({
|
|
22977
22982
|
type: "text";
|
|
22978
22983
|
text: string;
|
|
22979
22984
|
textSignature?: string;
|
|
@@ -22983,9 +22988,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22983
22988
|
mimeType: string;
|
|
22984
22989
|
})[];
|
|
22985
22990
|
details?: any;
|
|
22986
|
-
isError: false;
|
|
22987
22991
|
};
|
|
22988
|
-
status: "
|
|
22992
|
+
status: "running";
|
|
22989
22993
|
thoughtSignature?: string;
|
|
22990
22994
|
time: {
|
|
22991
22995
|
start: number;
|
|
@@ -23009,9 +23013,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23009
23013
|
mimeType: string;
|
|
23010
23014
|
})[];
|
|
23011
23015
|
details?: any;
|
|
23012
|
-
isError:
|
|
23016
|
+
isError: false;
|
|
23013
23017
|
};
|
|
23014
|
-
status: "
|
|
23018
|
+
status: "completed";
|
|
23015
23019
|
thoughtSignature?: string;
|
|
23016
23020
|
time: {
|
|
23017
23021
|
start: number;
|
|
@@ -23037,7 +23041,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23037
23041
|
details?: any;
|
|
23038
23042
|
isError: true;
|
|
23039
23043
|
};
|
|
23040
|
-
status: "
|
|
23044
|
+
status: "error";
|
|
23041
23045
|
thoughtSignature?: string;
|
|
23042
23046
|
time: {
|
|
23043
23047
|
start: number;
|
|
@@ -23063,26 +23067,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23063
23067
|
details?: any;
|
|
23064
23068
|
isError: true;
|
|
23065
23069
|
};
|
|
23066
|
-
status: "
|
|
23070
|
+
status: "skipped";
|
|
23067
23071
|
thoughtSignature?: string;
|
|
23068
23072
|
time: {
|
|
23069
23073
|
start: number;
|
|
23070
23074
|
end: number;
|
|
23071
23075
|
};
|
|
23072
23076
|
type: "toolCall";
|
|
23073
|
-
} | {
|
|
23074
|
-
type: "thinking";
|
|
23075
|
-
thinking: string;
|
|
23076
|
-
thinkingSignature?: string;
|
|
23077
|
-
redacted?: boolean;
|
|
23078
23077
|
} | {
|
|
23079
23078
|
addedToolNames?: string[];
|
|
23080
23079
|
arguments: Record<string, any>;
|
|
23081
23080
|
callID: string;
|
|
23082
23081
|
name: string;
|
|
23083
23082
|
namespace?: string;
|
|
23084
|
-
|
|
23085
|
-
content
|
|
23083
|
+
result: {
|
|
23084
|
+
content: ({
|
|
23086
23085
|
type: "text";
|
|
23087
23086
|
text: string;
|
|
23088
23087
|
textSignature?: string;
|
|
@@ -23092,8 +23091,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23092
23091
|
mimeType: string;
|
|
23093
23092
|
})[];
|
|
23094
23093
|
details?: any;
|
|
23094
|
+
isError: true;
|
|
23095
23095
|
};
|
|
23096
|
-
status: "
|
|
23096
|
+
status: "aborted";
|
|
23097
23097
|
thoughtSignature?: string;
|
|
23098
23098
|
time: {
|
|
23099
23099
|
start: number;
|
|
@@ -23296,14 +23296,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23296
23296
|
type: "image";
|
|
23297
23297
|
data: string;
|
|
23298
23298
|
mimeType: string;
|
|
23299
|
+
} | {
|
|
23300
|
+
type: "thinking";
|
|
23301
|
+
thinking: string;
|
|
23302
|
+
thinkingSignature?: string;
|
|
23303
|
+
redacted?: boolean;
|
|
23299
23304
|
} | {
|
|
23300
23305
|
addedToolNames?: string[];
|
|
23301
23306
|
arguments: Record<string, any>;
|
|
23302
23307
|
callID: string;
|
|
23303
23308
|
name: string;
|
|
23304
23309
|
namespace?: string;
|
|
23305
|
-
|
|
23306
|
-
content
|
|
23310
|
+
partial?: {
|
|
23311
|
+
content?: ({
|
|
23307
23312
|
type: "text";
|
|
23308
23313
|
text: string;
|
|
23309
23314
|
textSignature?: string;
|
|
@@ -23313,9 +23318,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23313
23318
|
mimeType: string;
|
|
23314
23319
|
})[];
|
|
23315
23320
|
details?: any;
|
|
23316
|
-
isError: false;
|
|
23317
23321
|
};
|
|
23318
|
-
status: "
|
|
23322
|
+
status: "running";
|
|
23319
23323
|
thoughtSignature?: string;
|
|
23320
23324
|
time: {
|
|
23321
23325
|
start: number;
|
|
@@ -23339,9 +23343,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23339
23343
|
mimeType: string;
|
|
23340
23344
|
})[];
|
|
23341
23345
|
details?: any;
|
|
23342
|
-
isError:
|
|
23346
|
+
isError: false;
|
|
23343
23347
|
};
|
|
23344
|
-
status: "
|
|
23348
|
+
status: "completed";
|
|
23345
23349
|
thoughtSignature?: string;
|
|
23346
23350
|
time: {
|
|
23347
23351
|
start: number;
|
|
@@ -23367,7 +23371,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23367
23371
|
details?: any;
|
|
23368
23372
|
isError: true;
|
|
23369
23373
|
};
|
|
23370
|
-
status: "
|
|
23374
|
+
status: "error";
|
|
23371
23375
|
thoughtSignature?: string;
|
|
23372
23376
|
time: {
|
|
23373
23377
|
start: number;
|
|
@@ -23393,26 +23397,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23393
23397
|
details?: any;
|
|
23394
23398
|
isError: true;
|
|
23395
23399
|
};
|
|
23396
|
-
status: "
|
|
23400
|
+
status: "skipped";
|
|
23397
23401
|
thoughtSignature?: string;
|
|
23398
23402
|
time: {
|
|
23399
23403
|
start: number;
|
|
23400
23404
|
end: number;
|
|
23401
23405
|
};
|
|
23402
23406
|
type: "toolCall";
|
|
23403
|
-
} | {
|
|
23404
|
-
type: "thinking";
|
|
23405
|
-
thinking: string;
|
|
23406
|
-
thinkingSignature?: string;
|
|
23407
|
-
redacted?: boolean;
|
|
23408
23407
|
} | {
|
|
23409
23408
|
addedToolNames?: string[];
|
|
23410
23409
|
arguments: Record<string, any>;
|
|
23411
23410
|
callID: string;
|
|
23412
23411
|
name: string;
|
|
23413
23412
|
namespace?: string;
|
|
23414
|
-
|
|
23415
|
-
content
|
|
23413
|
+
result: {
|
|
23414
|
+
content: ({
|
|
23416
23415
|
type: "text";
|
|
23417
23416
|
text: string;
|
|
23418
23417
|
textSignature?: string;
|
|
@@ -23422,8 +23421,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23422
23421
|
mimeType: string;
|
|
23423
23422
|
})[];
|
|
23424
23423
|
details?: any;
|
|
23424
|
+
isError: true;
|
|
23425
23425
|
};
|
|
23426
|
-
status: "
|
|
23426
|
+
status: "aborted";
|
|
23427
23427
|
thoughtSignature?: string;
|
|
23428
23428
|
time: {
|
|
23429
23429
|
start: number;
|
|
@@ -23598,14 +23598,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23598
23598
|
type: "image";
|
|
23599
23599
|
data: string;
|
|
23600
23600
|
mimeType: string;
|
|
23601
|
+
} | {
|
|
23602
|
+
type: "thinking";
|
|
23603
|
+
thinking: string;
|
|
23604
|
+
thinkingSignature?: string;
|
|
23605
|
+
redacted?: boolean;
|
|
23601
23606
|
} | {
|
|
23602
23607
|
addedToolNames?: string[];
|
|
23603
23608
|
arguments: Record<string, any>;
|
|
23604
23609
|
callID: string;
|
|
23605
23610
|
name: string;
|
|
23606
23611
|
namespace?: string;
|
|
23607
|
-
|
|
23608
|
-
content
|
|
23612
|
+
partial?: {
|
|
23613
|
+
content?: ({
|
|
23609
23614
|
type: "text";
|
|
23610
23615
|
text: string;
|
|
23611
23616
|
textSignature?: string;
|
|
@@ -23615,9 +23620,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23615
23620
|
mimeType: string;
|
|
23616
23621
|
})[];
|
|
23617
23622
|
details?: any;
|
|
23618
|
-
isError: false;
|
|
23619
23623
|
};
|
|
23620
|
-
status: "
|
|
23624
|
+
status: "running";
|
|
23621
23625
|
thoughtSignature?: string;
|
|
23622
23626
|
time: {
|
|
23623
23627
|
start: number;
|
|
@@ -23641,9 +23645,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23641
23645
|
mimeType: string;
|
|
23642
23646
|
})[];
|
|
23643
23647
|
details?: any;
|
|
23644
|
-
isError:
|
|
23648
|
+
isError: false;
|
|
23645
23649
|
};
|
|
23646
|
-
status: "
|
|
23650
|
+
status: "completed";
|
|
23647
23651
|
thoughtSignature?: string;
|
|
23648
23652
|
time: {
|
|
23649
23653
|
start: number;
|
|
@@ -23669,7 +23673,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23669
23673
|
details?: any;
|
|
23670
23674
|
isError: true;
|
|
23671
23675
|
};
|
|
23672
|
-
status: "
|
|
23676
|
+
status: "error";
|
|
23673
23677
|
thoughtSignature?: string;
|
|
23674
23678
|
time: {
|
|
23675
23679
|
start: number;
|
|
@@ -23695,26 +23699,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23695
23699
|
details?: any;
|
|
23696
23700
|
isError: true;
|
|
23697
23701
|
};
|
|
23698
|
-
status: "
|
|
23702
|
+
status: "skipped";
|
|
23699
23703
|
thoughtSignature?: string;
|
|
23700
23704
|
time: {
|
|
23701
23705
|
start: number;
|
|
23702
23706
|
end: number;
|
|
23703
23707
|
};
|
|
23704
23708
|
type: "toolCall";
|
|
23705
|
-
} | {
|
|
23706
|
-
type: "thinking";
|
|
23707
|
-
thinking: string;
|
|
23708
|
-
thinkingSignature?: string;
|
|
23709
|
-
redacted?: boolean;
|
|
23710
23709
|
} | {
|
|
23711
23710
|
addedToolNames?: string[];
|
|
23712
23711
|
arguments: Record<string, any>;
|
|
23713
23712
|
callID: string;
|
|
23714
23713
|
name: string;
|
|
23715
23714
|
namespace?: string;
|
|
23716
|
-
|
|
23717
|
-
content
|
|
23715
|
+
result: {
|
|
23716
|
+
content: ({
|
|
23718
23717
|
type: "text";
|
|
23719
23718
|
text: string;
|
|
23720
23719
|
textSignature?: string;
|
|
@@ -23724,8 +23723,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23724
23723
|
mimeType: string;
|
|
23725
23724
|
})[];
|
|
23726
23725
|
details?: any;
|
|
23726
|
+
isError: true;
|
|
23727
23727
|
};
|
|
23728
|
-
status: "
|
|
23728
|
+
status: "aborted";
|
|
23729
23729
|
thoughtSignature?: string;
|
|
23730
23730
|
time: {
|
|
23731
23731
|
start: number;
|
|
@@ -23919,14 +23919,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23919
23919
|
type: "image";
|
|
23920
23920
|
data: string;
|
|
23921
23921
|
mimeType: string;
|
|
23922
|
+
} | {
|
|
23923
|
+
type: "thinking";
|
|
23924
|
+
thinking: string;
|
|
23925
|
+
thinkingSignature?: string;
|
|
23926
|
+
redacted?: boolean;
|
|
23922
23927
|
} | {
|
|
23923
23928
|
addedToolNames?: string[];
|
|
23924
23929
|
arguments: Record<string, any>;
|
|
23925
23930
|
callID: string;
|
|
23926
23931
|
name: string;
|
|
23927
23932
|
namespace?: string;
|
|
23928
|
-
|
|
23929
|
-
content
|
|
23933
|
+
partial?: {
|
|
23934
|
+
content?: ({
|
|
23930
23935
|
type: "text";
|
|
23931
23936
|
text: string;
|
|
23932
23937
|
textSignature?: string;
|
|
@@ -23936,9 +23941,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23936
23941
|
mimeType: string;
|
|
23937
23942
|
})[];
|
|
23938
23943
|
details?: any;
|
|
23939
|
-
isError: false;
|
|
23940
23944
|
};
|
|
23941
|
-
status: "
|
|
23945
|
+
status: "running";
|
|
23942
23946
|
thoughtSignature?: string;
|
|
23943
23947
|
time: {
|
|
23944
23948
|
start: number;
|
|
@@ -23962,9 +23966,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23962
23966
|
mimeType: string;
|
|
23963
23967
|
})[];
|
|
23964
23968
|
details?: any;
|
|
23965
|
-
isError:
|
|
23969
|
+
isError: false;
|
|
23966
23970
|
};
|
|
23967
|
-
status: "
|
|
23971
|
+
status: "completed";
|
|
23968
23972
|
thoughtSignature?: string;
|
|
23969
23973
|
time: {
|
|
23970
23974
|
start: number;
|
|
@@ -23990,7 +23994,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23990
23994
|
details?: any;
|
|
23991
23995
|
isError: true;
|
|
23992
23996
|
};
|
|
23993
|
-
status: "
|
|
23997
|
+
status: "error";
|
|
23994
23998
|
thoughtSignature?: string;
|
|
23995
23999
|
time: {
|
|
23996
24000
|
start: number;
|
|
@@ -24016,26 +24020,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24016
24020
|
details?: any;
|
|
24017
24021
|
isError: true;
|
|
24018
24022
|
};
|
|
24019
|
-
status: "
|
|
24023
|
+
status: "skipped";
|
|
24020
24024
|
thoughtSignature?: string;
|
|
24021
24025
|
time: {
|
|
24022
24026
|
start: number;
|
|
24023
24027
|
end: number;
|
|
24024
24028
|
};
|
|
24025
24029
|
type: "toolCall";
|
|
24026
|
-
} | {
|
|
24027
|
-
type: "thinking";
|
|
24028
|
-
thinking: string;
|
|
24029
|
-
thinkingSignature?: string;
|
|
24030
|
-
redacted?: boolean;
|
|
24031
24030
|
} | {
|
|
24032
24031
|
addedToolNames?: string[];
|
|
24033
24032
|
arguments: Record<string, any>;
|
|
24034
24033
|
callID: string;
|
|
24035
24034
|
name: string;
|
|
24036
24035
|
namespace?: string;
|
|
24037
|
-
|
|
24038
|
-
content
|
|
24036
|
+
result: {
|
|
24037
|
+
content: ({
|
|
24039
24038
|
type: "text";
|
|
24040
24039
|
text: string;
|
|
24041
24040
|
textSignature?: string;
|
|
@@ -24045,8 +24044,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24045
24044
|
mimeType: string;
|
|
24046
24045
|
})[];
|
|
24047
24046
|
details?: any;
|
|
24047
|
+
isError: true;
|
|
24048
24048
|
};
|
|
24049
|
-
status: "
|
|
24049
|
+
status: "aborted";
|
|
24050
24050
|
thoughtSignature?: string;
|
|
24051
24051
|
time: {
|
|
24052
24052
|
start: number;
|
|
@@ -24221,14 +24221,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24221
24221
|
type: "image";
|
|
24222
24222
|
data: string;
|
|
24223
24223
|
mimeType: string;
|
|
24224
|
+
} | {
|
|
24225
|
+
type: "thinking";
|
|
24226
|
+
thinking: string;
|
|
24227
|
+
thinkingSignature?: string;
|
|
24228
|
+
redacted?: boolean;
|
|
24224
24229
|
} | {
|
|
24225
24230
|
addedToolNames?: string[];
|
|
24226
24231
|
arguments: Record<string, any>;
|
|
24227
24232
|
callID: string;
|
|
24228
24233
|
name: string;
|
|
24229
24234
|
namespace?: string;
|
|
24230
|
-
|
|
24231
|
-
content
|
|
24235
|
+
partial?: {
|
|
24236
|
+
content?: ({
|
|
24232
24237
|
type: "text";
|
|
24233
24238
|
text: string;
|
|
24234
24239
|
textSignature?: string;
|
|
@@ -24238,9 +24243,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24238
24243
|
mimeType: string;
|
|
24239
24244
|
})[];
|
|
24240
24245
|
details?: any;
|
|
24241
|
-
isError: false;
|
|
24242
24246
|
};
|
|
24243
|
-
status: "
|
|
24247
|
+
status: "running";
|
|
24244
24248
|
thoughtSignature?: string;
|
|
24245
24249
|
time: {
|
|
24246
24250
|
start: number;
|
|
@@ -24264,9 +24268,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24264
24268
|
mimeType: string;
|
|
24265
24269
|
})[];
|
|
24266
24270
|
details?: any;
|
|
24267
|
-
isError:
|
|
24271
|
+
isError: false;
|
|
24268
24272
|
};
|
|
24269
|
-
status: "
|
|
24273
|
+
status: "completed";
|
|
24270
24274
|
thoughtSignature?: string;
|
|
24271
24275
|
time: {
|
|
24272
24276
|
start: number;
|
|
@@ -24292,7 +24296,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24292
24296
|
details?: any;
|
|
24293
24297
|
isError: true;
|
|
24294
24298
|
};
|
|
24295
|
-
status: "
|
|
24299
|
+
status: "error";
|
|
24296
24300
|
thoughtSignature?: string;
|
|
24297
24301
|
time: {
|
|
24298
24302
|
start: number;
|
|
@@ -24318,26 +24322,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24318
24322
|
details?: any;
|
|
24319
24323
|
isError: true;
|
|
24320
24324
|
};
|
|
24321
|
-
status: "
|
|
24325
|
+
status: "skipped";
|
|
24322
24326
|
thoughtSignature?: string;
|
|
24323
24327
|
time: {
|
|
24324
24328
|
start: number;
|
|
24325
24329
|
end: number;
|
|
24326
24330
|
};
|
|
24327
24331
|
type: "toolCall";
|
|
24328
|
-
} | {
|
|
24329
|
-
type: "thinking";
|
|
24330
|
-
thinking: string;
|
|
24331
|
-
thinkingSignature?: string;
|
|
24332
|
-
redacted?: boolean;
|
|
24333
24332
|
} | {
|
|
24334
24333
|
addedToolNames?: string[];
|
|
24335
24334
|
arguments: Record<string, any>;
|
|
24336
24335
|
callID: string;
|
|
24337
24336
|
name: string;
|
|
24338
24337
|
namespace?: string;
|
|
24339
|
-
|
|
24340
|
-
content
|
|
24338
|
+
result: {
|
|
24339
|
+
content: ({
|
|
24341
24340
|
type: "text";
|
|
24342
24341
|
text: string;
|
|
24343
24342
|
textSignature?: string;
|
|
@@ -24347,8 +24346,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24347
24346
|
mimeType: string;
|
|
24348
24347
|
})[];
|
|
24349
24348
|
details?: any;
|
|
24349
|
+
isError: true;
|
|
24350
24350
|
};
|
|
24351
|
-
status: "
|
|
24351
|
+
status: "aborted";
|
|
24352
24352
|
thoughtSignature?: string;
|
|
24353
24353
|
time: {
|
|
24354
24354
|
start: number;
|