@codeworksh/harness 0.5.0-canary.55.1.g9147d546 → 0.5.0
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 +800 -800
- package/package.json +3 -3
package/effect.d.mts
CHANGED
|
@@ -2930,14 +2930,19 @@ declare const encodeMessage: (message: {
|
|
|
2930
2930
|
type: "image";
|
|
2931
2931
|
data: string;
|
|
2932
2932
|
mimeType: string;
|
|
2933
|
+
} | {
|
|
2934
|
+
type: "thinking";
|
|
2935
|
+
thinking: string;
|
|
2936
|
+
thinkingSignature?: string;
|
|
2937
|
+
redacted?: boolean;
|
|
2933
2938
|
} | {
|
|
2934
2939
|
addedToolNames?: string[];
|
|
2935
2940
|
arguments: Record<string, any>;
|
|
2936
2941
|
callID: string;
|
|
2937
2942
|
name: string;
|
|
2938
2943
|
namespace?: string;
|
|
2939
|
-
|
|
2940
|
-
content
|
|
2944
|
+
partial?: {
|
|
2945
|
+
content?: ({
|
|
2941
2946
|
type: "text";
|
|
2942
2947
|
text: string;
|
|
2943
2948
|
textSignature?: string;
|
|
@@ -2947,9 +2952,8 @@ declare const encodeMessage: (message: {
|
|
|
2947
2952
|
mimeType: string;
|
|
2948
2953
|
})[];
|
|
2949
2954
|
details?: any;
|
|
2950
|
-
isError: false;
|
|
2951
2955
|
};
|
|
2952
|
-
status: "
|
|
2956
|
+
status: "running";
|
|
2953
2957
|
thoughtSignature?: string;
|
|
2954
2958
|
time: {
|
|
2955
2959
|
start: number;
|
|
@@ -2973,9 +2977,9 @@ declare const encodeMessage: (message: {
|
|
|
2973
2977
|
mimeType: string;
|
|
2974
2978
|
})[];
|
|
2975
2979
|
details?: any;
|
|
2976
|
-
isError:
|
|
2980
|
+
isError: false;
|
|
2977
2981
|
};
|
|
2978
|
-
status: "
|
|
2982
|
+
status: "completed";
|
|
2979
2983
|
thoughtSignature?: string;
|
|
2980
2984
|
time: {
|
|
2981
2985
|
start: number;
|
|
@@ -3001,7 +3005,7 @@ declare const encodeMessage: (message: {
|
|
|
3001
3005
|
details?: any;
|
|
3002
3006
|
isError: true;
|
|
3003
3007
|
};
|
|
3004
|
-
status: "
|
|
3008
|
+
status: "error";
|
|
3005
3009
|
thoughtSignature?: string;
|
|
3006
3010
|
time: {
|
|
3007
3011
|
start: number;
|
|
@@ -3027,26 +3031,21 @@ declare const encodeMessage: (message: {
|
|
|
3027
3031
|
details?: any;
|
|
3028
3032
|
isError: true;
|
|
3029
3033
|
};
|
|
3030
|
-
status: "
|
|
3034
|
+
status: "skipped";
|
|
3031
3035
|
thoughtSignature?: string;
|
|
3032
3036
|
time: {
|
|
3033
3037
|
start: number;
|
|
3034
3038
|
end: number;
|
|
3035
3039
|
};
|
|
3036
3040
|
type: "toolCall";
|
|
3037
|
-
} | {
|
|
3038
|
-
type: "thinking";
|
|
3039
|
-
thinking: string;
|
|
3040
|
-
thinkingSignature?: string;
|
|
3041
|
-
redacted?: boolean;
|
|
3042
3041
|
} | {
|
|
3043
3042
|
addedToolNames?: string[];
|
|
3044
3043
|
arguments: Record<string, any>;
|
|
3045
3044
|
callID: string;
|
|
3046
3045
|
name: string;
|
|
3047
3046
|
namespace?: string;
|
|
3048
|
-
|
|
3049
|
-
content
|
|
3047
|
+
result: {
|
|
3048
|
+
content: ({
|
|
3050
3049
|
type: "text";
|
|
3051
3050
|
text: string;
|
|
3052
3051
|
textSignature?: string;
|
|
@@ -3056,8 +3055,9 @@ declare const encodeMessage: (message: {
|
|
|
3056
3055
|
mimeType: string;
|
|
3057
3056
|
})[];
|
|
3058
3057
|
details?: any;
|
|
3058
|
+
isError: true;
|
|
3059
3059
|
};
|
|
3060
|
-
status: "
|
|
3060
|
+
status: "aborted";
|
|
3061
3061
|
thoughtSignature?: string;
|
|
3062
3062
|
time: {
|
|
3063
3063
|
start: number;
|
|
@@ -3264,14 +3264,19 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3264
3264
|
type: "image";
|
|
3265
3265
|
data: string;
|
|
3266
3266
|
mimeType: string;
|
|
3267
|
+
} | {
|
|
3268
|
+
type: "thinking";
|
|
3269
|
+
thinking: string;
|
|
3270
|
+
thinkingSignature?: string;
|
|
3271
|
+
redacted?: boolean;
|
|
3267
3272
|
} | {
|
|
3268
3273
|
addedToolNames?: string[];
|
|
3269
3274
|
arguments: Record<string, any>;
|
|
3270
3275
|
callID: string;
|
|
3271
3276
|
name: string;
|
|
3272
3277
|
namespace?: string;
|
|
3273
|
-
|
|
3274
|
-
content
|
|
3278
|
+
partial?: {
|
|
3279
|
+
content?: ({
|
|
3275
3280
|
type: "text";
|
|
3276
3281
|
text: string;
|
|
3277
3282
|
textSignature?: string;
|
|
@@ -3281,9 +3286,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3281
3286
|
mimeType: string;
|
|
3282
3287
|
})[];
|
|
3283
3288
|
details?: any;
|
|
3284
|
-
isError: false;
|
|
3285
3289
|
};
|
|
3286
|
-
status: "
|
|
3290
|
+
status: "running";
|
|
3287
3291
|
thoughtSignature?: string;
|
|
3288
3292
|
time: {
|
|
3289
3293
|
start: number;
|
|
@@ -3307,9 +3311,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3307
3311
|
mimeType: string;
|
|
3308
3312
|
})[];
|
|
3309
3313
|
details?: any;
|
|
3310
|
-
isError:
|
|
3314
|
+
isError: false;
|
|
3311
3315
|
};
|
|
3312
|
-
status: "
|
|
3316
|
+
status: "completed";
|
|
3313
3317
|
thoughtSignature?: string;
|
|
3314
3318
|
time: {
|
|
3315
3319
|
start: number;
|
|
@@ -3335,7 +3339,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3335
3339
|
details?: any;
|
|
3336
3340
|
isError: true;
|
|
3337
3341
|
};
|
|
3338
|
-
status: "
|
|
3342
|
+
status: "error";
|
|
3339
3343
|
thoughtSignature?: string;
|
|
3340
3344
|
time: {
|
|
3341
3345
|
start: number;
|
|
@@ -3361,26 +3365,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3361
3365
|
details?: any;
|
|
3362
3366
|
isError: true;
|
|
3363
3367
|
};
|
|
3364
|
-
status: "
|
|
3368
|
+
status: "skipped";
|
|
3365
3369
|
thoughtSignature?: string;
|
|
3366
3370
|
time: {
|
|
3367
3371
|
start: number;
|
|
3368
3372
|
end: number;
|
|
3369
3373
|
};
|
|
3370
3374
|
type: "toolCall";
|
|
3371
|
-
} | {
|
|
3372
|
-
type: "thinking";
|
|
3373
|
-
thinking: string;
|
|
3374
|
-
thinkingSignature?: string;
|
|
3375
|
-
redacted?: boolean;
|
|
3376
3375
|
} | {
|
|
3377
3376
|
addedToolNames?: string[];
|
|
3378
3377
|
arguments: Record<string, any>;
|
|
3379
3378
|
callID: string;
|
|
3380
3379
|
name: string;
|
|
3381
3380
|
namespace?: string;
|
|
3382
|
-
|
|
3383
|
-
content
|
|
3381
|
+
result: {
|
|
3382
|
+
content: ({
|
|
3384
3383
|
type: "text";
|
|
3385
3384
|
text: string;
|
|
3386
3385
|
textSignature?: string;
|
|
@@ -3390,8 +3389,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3390
3389
|
mimeType: string;
|
|
3391
3390
|
})[];
|
|
3392
3391
|
details?: any;
|
|
3392
|
+
isError: true;
|
|
3393
3393
|
};
|
|
3394
|
-
status: "
|
|
3394
|
+
status: "aborted";
|
|
3395
3395
|
thoughtSignature?: string;
|
|
3396
3396
|
time: {
|
|
3397
3397
|
start: number;
|
|
@@ -5293,14 +5293,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5293
5293
|
type: "image";
|
|
5294
5294
|
data: string;
|
|
5295
5295
|
mimeType: string;
|
|
5296
|
+
} | {
|
|
5297
|
+
type: "thinking";
|
|
5298
|
+
thinking: string;
|
|
5299
|
+
thinkingSignature?: string;
|
|
5300
|
+
redacted?: boolean;
|
|
5296
5301
|
} | {
|
|
5297
5302
|
addedToolNames?: string[];
|
|
5298
5303
|
arguments: Record<string, any>;
|
|
5299
5304
|
callID: string;
|
|
5300
5305
|
name: string;
|
|
5301
5306
|
namespace?: string;
|
|
5302
|
-
|
|
5303
|
-
content
|
|
5307
|
+
partial?: {
|
|
5308
|
+
content?: ({
|
|
5304
5309
|
type: "text";
|
|
5305
5310
|
text: string;
|
|
5306
5311
|
textSignature?: string;
|
|
@@ -5310,9 +5315,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5310
5315
|
mimeType: string;
|
|
5311
5316
|
})[];
|
|
5312
5317
|
details?: any;
|
|
5313
|
-
isError: false;
|
|
5314
5318
|
};
|
|
5315
|
-
status: "
|
|
5319
|
+
status: "running";
|
|
5316
5320
|
thoughtSignature?: string;
|
|
5317
5321
|
time: {
|
|
5318
5322
|
start: number;
|
|
@@ -5336,9 +5340,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5336
5340
|
mimeType: string;
|
|
5337
5341
|
})[];
|
|
5338
5342
|
details?: any;
|
|
5339
|
-
isError:
|
|
5343
|
+
isError: false;
|
|
5340
5344
|
};
|
|
5341
|
-
status: "
|
|
5345
|
+
status: "completed";
|
|
5342
5346
|
thoughtSignature?: string;
|
|
5343
5347
|
time: {
|
|
5344
5348
|
start: number;
|
|
@@ -5364,7 +5368,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5364
5368
|
details?: any;
|
|
5365
5369
|
isError: true;
|
|
5366
5370
|
};
|
|
5367
|
-
status: "
|
|
5371
|
+
status: "error";
|
|
5368
5372
|
thoughtSignature?: string;
|
|
5369
5373
|
time: {
|
|
5370
5374
|
start: number;
|
|
@@ -5390,26 +5394,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5390
5394
|
details?: any;
|
|
5391
5395
|
isError: true;
|
|
5392
5396
|
};
|
|
5393
|
-
status: "
|
|
5397
|
+
status: "skipped";
|
|
5394
5398
|
thoughtSignature?: string;
|
|
5395
5399
|
time: {
|
|
5396
5400
|
start: number;
|
|
5397
5401
|
end: number;
|
|
5398
5402
|
};
|
|
5399
5403
|
type: "toolCall";
|
|
5400
|
-
} | {
|
|
5401
|
-
type: "thinking";
|
|
5402
|
-
thinking: string;
|
|
5403
|
-
thinkingSignature?: string;
|
|
5404
|
-
redacted?: boolean;
|
|
5405
5404
|
} | {
|
|
5406
5405
|
addedToolNames?: string[];
|
|
5407
5406
|
arguments: Record<string, any>;
|
|
5408
5407
|
callID: string;
|
|
5409
5408
|
name: string;
|
|
5410
5409
|
namespace?: string;
|
|
5411
|
-
|
|
5412
|
-
content
|
|
5410
|
+
result: {
|
|
5411
|
+
content: ({
|
|
5413
5412
|
type: "text";
|
|
5414
5413
|
text: string;
|
|
5415
5414
|
textSignature?: string;
|
|
@@ -5419,8 +5418,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5419
5418
|
mimeType: string;
|
|
5420
5419
|
})[];
|
|
5421
5420
|
details?: any;
|
|
5421
|
+
isError: true;
|
|
5422
5422
|
};
|
|
5423
|
-
status: "
|
|
5423
|
+
status: "aborted";
|
|
5424
5424
|
thoughtSignature?: string;
|
|
5425
5425
|
time: {
|
|
5426
5426
|
start: number;
|
|
@@ -5595,14 +5595,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5595
5595
|
type: "image";
|
|
5596
5596
|
data: string;
|
|
5597
5597
|
mimeType: string;
|
|
5598
|
+
} | {
|
|
5599
|
+
type: "thinking";
|
|
5600
|
+
thinking: string;
|
|
5601
|
+
thinkingSignature?: string;
|
|
5602
|
+
redacted?: boolean;
|
|
5598
5603
|
} | {
|
|
5599
5604
|
addedToolNames?: string[];
|
|
5600
5605
|
arguments: Record<string, any>;
|
|
5601
5606
|
callID: string;
|
|
5602
5607
|
name: string;
|
|
5603
5608
|
namespace?: string;
|
|
5604
|
-
|
|
5605
|
-
content
|
|
5609
|
+
partial?: {
|
|
5610
|
+
content?: ({
|
|
5606
5611
|
type: "text";
|
|
5607
5612
|
text: string;
|
|
5608
5613
|
textSignature?: string;
|
|
@@ -5612,9 +5617,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5612
5617
|
mimeType: string;
|
|
5613
5618
|
})[];
|
|
5614
5619
|
details?: any;
|
|
5615
|
-
isError: false;
|
|
5616
5620
|
};
|
|
5617
|
-
status: "
|
|
5621
|
+
status: "running";
|
|
5618
5622
|
thoughtSignature?: string;
|
|
5619
5623
|
time: {
|
|
5620
5624
|
start: number;
|
|
@@ -5638,9 +5642,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5638
5642
|
mimeType: string;
|
|
5639
5643
|
})[];
|
|
5640
5644
|
details?: any;
|
|
5641
|
-
isError:
|
|
5645
|
+
isError: false;
|
|
5642
5646
|
};
|
|
5643
|
-
status: "
|
|
5647
|
+
status: "completed";
|
|
5644
5648
|
thoughtSignature?: string;
|
|
5645
5649
|
time: {
|
|
5646
5650
|
start: number;
|
|
@@ -5666,7 +5670,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5666
5670
|
details?: any;
|
|
5667
5671
|
isError: true;
|
|
5668
5672
|
};
|
|
5669
|
-
status: "
|
|
5673
|
+
status: "error";
|
|
5670
5674
|
thoughtSignature?: string;
|
|
5671
5675
|
time: {
|
|
5672
5676
|
start: number;
|
|
@@ -5692,26 +5696,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5692
5696
|
details?: any;
|
|
5693
5697
|
isError: true;
|
|
5694
5698
|
};
|
|
5695
|
-
status: "
|
|
5699
|
+
status: "skipped";
|
|
5696
5700
|
thoughtSignature?: string;
|
|
5697
5701
|
time: {
|
|
5698
5702
|
start: number;
|
|
5699
5703
|
end: number;
|
|
5700
5704
|
};
|
|
5701
5705
|
type: "toolCall";
|
|
5702
|
-
} | {
|
|
5703
|
-
type: "thinking";
|
|
5704
|
-
thinking: string;
|
|
5705
|
-
thinkingSignature?: string;
|
|
5706
|
-
redacted?: boolean;
|
|
5707
5706
|
} | {
|
|
5708
5707
|
addedToolNames?: string[];
|
|
5709
5708
|
arguments: Record<string, any>;
|
|
5710
5709
|
callID: string;
|
|
5711
5710
|
name: string;
|
|
5712
5711
|
namespace?: string;
|
|
5713
|
-
|
|
5714
|
-
content
|
|
5712
|
+
result: {
|
|
5713
|
+
content: ({
|
|
5715
5714
|
type: "text";
|
|
5716
5715
|
text: string;
|
|
5717
5716
|
textSignature?: string;
|
|
@@ -5721,8 +5720,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5721
5720
|
mimeType: string;
|
|
5722
5721
|
})[];
|
|
5723
5722
|
details?: any;
|
|
5723
|
+
isError: true;
|
|
5724
5724
|
};
|
|
5725
|
-
status: "
|
|
5725
|
+
status: "aborted";
|
|
5726
5726
|
thoughtSignature?: string;
|
|
5727
5727
|
time: {
|
|
5728
5728
|
start: number;
|
|
@@ -5915,14 +5915,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5915
5915
|
type: "image";
|
|
5916
5916
|
data: string;
|
|
5917
5917
|
mimeType: string;
|
|
5918
|
+
} | {
|
|
5919
|
+
type: "thinking";
|
|
5920
|
+
thinking: string;
|
|
5921
|
+
thinkingSignature?: string;
|
|
5922
|
+
redacted?: boolean;
|
|
5918
5923
|
} | {
|
|
5919
5924
|
addedToolNames?: string[];
|
|
5920
5925
|
arguments: Record<string, any>;
|
|
5921
5926
|
callID: string;
|
|
5922
5927
|
name: string;
|
|
5923
5928
|
namespace?: string;
|
|
5924
|
-
|
|
5925
|
-
content
|
|
5929
|
+
partial?: {
|
|
5930
|
+
content?: ({
|
|
5926
5931
|
type: "text";
|
|
5927
5932
|
text: string;
|
|
5928
5933
|
textSignature?: string;
|
|
@@ -5932,9 +5937,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5932
5937
|
mimeType: string;
|
|
5933
5938
|
})[];
|
|
5934
5939
|
details?: any;
|
|
5935
|
-
isError: false;
|
|
5936
5940
|
};
|
|
5937
|
-
status: "
|
|
5941
|
+
status: "running";
|
|
5938
5942
|
thoughtSignature?: string;
|
|
5939
5943
|
time: {
|
|
5940
5944
|
start: number;
|
|
@@ -5958,9 +5962,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5958
5962
|
mimeType: string;
|
|
5959
5963
|
})[];
|
|
5960
5964
|
details?: any;
|
|
5961
|
-
isError:
|
|
5965
|
+
isError: false;
|
|
5962
5966
|
};
|
|
5963
|
-
status: "
|
|
5967
|
+
status: "completed";
|
|
5964
5968
|
thoughtSignature?: string;
|
|
5965
5969
|
time: {
|
|
5966
5970
|
start: number;
|
|
@@ -5986,7 +5990,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5986
5990
|
details?: any;
|
|
5987
5991
|
isError: true;
|
|
5988
5992
|
};
|
|
5989
|
-
status: "
|
|
5993
|
+
status: "error";
|
|
5990
5994
|
thoughtSignature?: string;
|
|
5991
5995
|
time: {
|
|
5992
5996
|
start: number;
|
|
@@ -6012,26 +6016,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6012
6016
|
details?: any;
|
|
6013
6017
|
isError: true;
|
|
6014
6018
|
};
|
|
6015
|
-
status: "
|
|
6019
|
+
status: "skipped";
|
|
6016
6020
|
thoughtSignature?: string;
|
|
6017
6021
|
time: {
|
|
6018
6022
|
start: number;
|
|
6019
6023
|
end: number;
|
|
6020
6024
|
};
|
|
6021
6025
|
type: "toolCall";
|
|
6022
|
-
} | {
|
|
6023
|
-
type: "thinking";
|
|
6024
|
-
thinking: string;
|
|
6025
|
-
thinkingSignature?: string;
|
|
6026
|
-
redacted?: boolean;
|
|
6027
6026
|
} | {
|
|
6028
6027
|
addedToolNames?: string[];
|
|
6029
6028
|
arguments: Record<string, any>;
|
|
6030
6029
|
callID: string;
|
|
6031
6030
|
name: string;
|
|
6032
6031
|
namespace?: string;
|
|
6033
|
-
|
|
6034
|
-
content
|
|
6032
|
+
result: {
|
|
6033
|
+
content: ({
|
|
6035
6034
|
type: "text";
|
|
6036
6035
|
text: string;
|
|
6037
6036
|
textSignature?: string;
|
|
@@ -6041,8 +6040,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6041
6040
|
mimeType: string;
|
|
6042
6041
|
})[];
|
|
6043
6042
|
details?: any;
|
|
6043
|
+
isError: true;
|
|
6044
6044
|
};
|
|
6045
|
-
status: "
|
|
6045
|
+
status: "aborted";
|
|
6046
6046
|
thoughtSignature?: string;
|
|
6047
6047
|
time: {
|
|
6048
6048
|
start: number;
|
|
@@ -6217,14 +6217,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6217
6217
|
type: "image";
|
|
6218
6218
|
data: string;
|
|
6219
6219
|
mimeType: string;
|
|
6220
|
+
} | {
|
|
6221
|
+
type: "thinking";
|
|
6222
|
+
thinking: string;
|
|
6223
|
+
thinkingSignature?: string;
|
|
6224
|
+
redacted?: boolean;
|
|
6220
6225
|
} | {
|
|
6221
6226
|
addedToolNames?: string[];
|
|
6222
6227
|
arguments: Record<string, any>;
|
|
6223
6228
|
callID: string;
|
|
6224
6229
|
name: string;
|
|
6225
6230
|
namespace?: string;
|
|
6226
|
-
|
|
6227
|
-
content
|
|
6231
|
+
partial?: {
|
|
6232
|
+
content?: ({
|
|
6228
6233
|
type: "text";
|
|
6229
6234
|
text: string;
|
|
6230
6235
|
textSignature?: string;
|
|
@@ -6234,9 +6239,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6234
6239
|
mimeType: string;
|
|
6235
6240
|
})[];
|
|
6236
6241
|
details?: any;
|
|
6237
|
-
isError: false;
|
|
6238
6242
|
};
|
|
6239
|
-
status: "
|
|
6243
|
+
status: "running";
|
|
6240
6244
|
thoughtSignature?: string;
|
|
6241
6245
|
time: {
|
|
6242
6246
|
start: number;
|
|
@@ -6260,9 +6264,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6260
6264
|
mimeType: string;
|
|
6261
6265
|
})[];
|
|
6262
6266
|
details?: any;
|
|
6263
|
-
isError:
|
|
6267
|
+
isError: false;
|
|
6264
6268
|
};
|
|
6265
|
-
status: "
|
|
6269
|
+
status: "completed";
|
|
6266
6270
|
thoughtSignature?: string;
|
|
6267
6271
|
time: {
|
|
6268
6272
|
start: number;
|
|
@@ -6288,7 +6292,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6288
6292
|
details?: any;
|
|
6289
6293
|
isError: true;
|
|
6290
6294
|
};
|
|
6291
|
-
status: "
|
|
6295
|
+
status: "error";
|
|
6292
6296
|
thoughtSignature?: string;
|
|
6293
6297
|
time: {
|
|
6294
6298
|
start: number;
|
|
@@ -6314,26 +6318,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6314
6318
|
details?: any;
|
|
6315
6319
|
isError: true;
|
|
6316
6320
|
};
|
|
6317
|
-
status: "
|
|
6321
|
+
status: "skipped";
|
|
6318
6322
|
thoughtSignature?: string;
|
|
6319
6323
|
time: {
|
|
6320
6324
|
start: number;
|
|
6321
6325
|
end: number;
|
|
6322
6326
|
};
|
|
6323
6327
|
type: "toolCall";
|
|
6324
|
-
} | {
|
|
6325
|
-
type: "thinking";
|
|
6326
|
-
thinking: string;
|
|
6327
|
-
thinkingSignature?: string;
|
|
6328
|
-
redacted?: boolean;
|
|
6329
6328
|
} | {
|
|
6330
6329
|
addedToolNames?: string[];
|
|
6331
6330
|
arguments: Record<string, any>;
|
|
6332
6331
|
callID: string;
|
|
6333
6332
|
name: string;
|
|
6334
6333
|
namespace?: string;
|
|
6335
|
-
|
|
6336
|
-
content
|
|
6334
|
+
result: {
|
|
6335
|
+
content: ({
|
|
6337
6336
|
type: "text";
|
|
6338
6337
|
text: string;
|
|
6339
6338
|
textSignature?: string;
|
|
@@ -6343,8 +6342,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
6343
6342
|
mimeType: string;
|
|
6344
6343
|
})[];
|
|
6345
6344
|
details?: any;
|
|
6345
|
+
isError: true;
|
|
6346
6346
|
};
|
|
6347
|
-
status: "
|
|
6347
|
+
status: "aborted";
|
|
6348
6348
|
thoughtSignature?: string;
|
|
6349
6349
|
time: {
|
|
6350
6350
|
start: number;
|
|
@@ -6840,14 +6840,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6840
6840
|
type: "image";
|
|
6841
6841
|
data: string;
|
|
6842
6842
|
mimeType: string;
|
|
6843
|
+
} | {
|
|
6844
|
+
type: "thinking";
|
|
6845
|
+
thinking: string;
|
|
6846
|
+
thinkingSignature?: string;
|
|
6847
|
+
redacted?: boolean;
|
|
6843
6848
|
} | {
|
|
6844
6849
|
addedToolNames?: string[];
|
|
6845
6850
|
arguments: Record<string, any>;
|
|
6846
6851
|
callID: string;
|
|
6847
6852
|
name: string;
|
|
6848
6853
|
namespace?: string;
|
|
6849
|
-
|
|
6850
|
-
content
|
|
6854
|
+
partial?: {
|
|
6855
|
+
content?: ({
|
|
6851
6856
|
type: "text";
|
|
6852
6857
|
text: string;
|
|
6853
6858
|
textSignature?: string;
|
|
@@ -6857,9 +6862,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6857
6862
|
mimeType: string;
|
|
6858
6863
|
})[];
|
|
6859
6864
|
details?: any;
|
|
6860
|
-
isError: false;
|
|
6861
6865
|
};
|
|
6862
|
-
status: "
|
|
6866
|
+
status: "running";
|
|
6863
6867
|
thoughtSignature?: string;
|
|
6864
6868
|
time: {
|
|
6865
6869
|
start: number;
|
|
@@ -6883,9 +6887,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6883
6887
|
mimeType: string;
|
|
6884
6888
|
})[];
|
|
6885
6889
|
details?: any;
|
|
6886
|
-
isError:
|
|
6890
|
+
isError: false;
|
|
6887
6891
|
};
|
|
6888
|
-
status: "
|
|
6892
|
+
status: "completed";
|
|
6889
6893
|
thoughtSignature?: string;
|
|
6890
6894
|
time: {
|
|
6891
6895
|
start: number;
|
|
@@ -6911,7 +6915,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6911
6915
|
details?: any;
|
|
6912
6916
|
isError: true;
|
|
6913
6917
|
};
|
|
6914
|
-
status: "
|
|
6918
|
+
status: "error";
|
|
6915
6919
|
thoughtSignature?: string;
|
|
6916
6920
|
time: {
|
|
6917
6921
|
start: number;
|
|
@@ -6937,26 +6941,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6937
6941
|
details?: any;
|
|
6938
6942
|
isError: true;
|
|
6939
6943
|
};
|
|
6940
|
-
status: "
|
|
6944
|
+
status: "skipped";
|
|
6941
6945
|
thoughtSignature?: string;
|
|
6942
6946
|
time: {
|
|
6943
6947
|
start: number;
|
|
6944
6948
|
end: number;
|
|
6945
6949
|
};
|
|
6946
6950
|
type: "toolCall";
|
|
6947
|
-
} | {
|
|
6948
|
-
type: "thinking";
|
|
6949
|
-
thinking: string;
|
|
6950
|
-
thinkingSignature?: string;
|
|
6951
|
-
redacted?: boolean;
|
|
6952
6951
|
} | {
|
|
6953
6952
|
addedToolNames?: string[];
|
|
6954
6953
|
arguments: Record<string, any>;
|
|
6955
6954
|
callID: string;
|
|
6956
6955
|
name: string;
|
|
6957
6956
|
namespace?: string;
|
|
6958
|
-
|
|
6959
|
-
content
|
|
6957
|
+
result: {
|
|
6958
|
+
content: ({
|
|
6960
6959
|
type: "text";
|
|
6961
6960
|
text: string;
|
|
6962
6961
|
textSignature?: string;
|
|
@@ -6966,8 +6965,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6966
6965
|
mimeType: string;
|
|
6967
6966
|
})[];
|
|
6968
6967
|
details?: any;
|
|
6968
|
+
isError: true;
|
|
6969
6969
|
};
|
|
6970
|
-
status: "
|
|
6970
|
+
status: "aborted";
|
|
6971
6971
|
thoughtSignature?: string;
|
|
6972
6972
|
time: {
|
|
6973
6973
|
start: number;
|
|
@@ -7142,14 +7142,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7142
7142
|
type: "image";
|
|
7143
7143
|
data: string;
|
|
7144
7144
|
mimeType: string;
|
|
7145
|
+
} | {
|
|
7146
|
+
type: "thinking";
|
|
7147
|
+
thinking: string;
|
|
7148
|
+
thinkingSignature?: string;
|
|
7149
|
+
redacted?: boolean;
|
|
7145
7150
|
} | {
|
|
7146
7151
|
addedToolNames?: string[];
|
|
7147
7152
|
arguments: Record<string, any>;
|
|
7148
7153
|
callID: string;
|
|
7149
7154
|
name: string;
|
|
7150
7155
|
namespace?: string;
|
|
7151
|
-
|
|
7152
|
-
content
|
|
7156
|
+
partial?: {
|
|
7157
|
+
content?: ({
|
|
7153
7158
|
type: "text";
|
|
7154
7159
|
text: string;
|
|
7155
7160
|
textSignature?: string;
|
|
@@ -7159,9 +7164,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7159
7164
|
mimeType: string;
|
|
7160
7165
|
})[];
|
|
7161
7166
|
details?: any;
|
|
7162
|
-
isError: false;
|
|
7163
7167
|
};
|
|
7164
|
-
status: "
|
|
7168
|
+
status: "running";
|
|
7165
7169
|
thoughtSignature?: string;
|
|
7166
7170
|
time: {
|
|
7167
7171
|
start: number;
|
|
@@ -7185,9 +7189,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7185
7189
|
mimeType: string;
|
|
7186
7190
|
})[];
|
|
7187
7191
|
details?: any;
|
|
7188
|
-
isError:
|
|
7192
|
+
isError: false;
|
|
7189
7193
|
};
|
|
7190
|
-
status: "
|
|
7194
|
+
status: "completed";
|
|
7191
7195
|
thoughtSignature?: string;
|
|
7192
7196
|
time: {
|
|
7193
7197
|
start: number;
|
|
@@ -7213,7 +7217,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7213
7217
|
details?: any;
|
|
7214
7218
|
isError: true;
|
|
7215
7219
|
};
|
|
7216
|
-
status: "
|
|
7220
|
+
status: "error";
|
|
7217
7221
|
thoughtSignature?: string;
|
|
7218
7222
|
time: {
|
|
7219
7223
|
start: number;
|
|
@@ -7239,26 +7243,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7239
7243
|
details?: any;
|
|
7240
7244
|
isError: true;
|
|
7241
7245
|
};
|
|
7242
|
-
status: "
|
|
7246
|
+
status: "skipped";
|
|
7243
7247
|
thoughtSignature?: string;
|
|
7244
7248
|
time: {
|
|
7245
7249
|
start: number;
|
|
7246
7250
|
end: number;
|
|
7247
7251
|
};
|
|
7248
7252
|
type: "toolCall";
|
|
7249
|
-
} | {
|
|
7250
|
-
type: "thinking";
|
|
7251
|
-
thinking: string;
|
|
7252
|
-
thinkingSignature?: string;
|
|
7253
|
-
redacted?: boolean;
|
|
7254
7253
|
} | {
|
|
7255
7254
|
addedToolNames?: string[];
|
|
7256
7255
|
arguments: Record<string, any>;
|
|
7257
7256
|
callID: string;
|
|
7258
7257
|
name: string;
|
|
7259
7258
|
namespace?: string;
|
|
7260
|
-
|
|
7261
|
-
content
|
|
7259
|
+
result: {
|
|
7260
|
+
content: ({
|
|
7262
7261
|
type: "text";
|
|
7263
7262
|
text: string;
|
|
7264
7263
|
textSignature?: string;
|
|
@@ -7268,8 +7267,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7268
7267
|
mimeType: string;
|
|
7269
7268
|
})[];
|
|
7270
7269
|
details?: any;
|
|
7270
|
+
isError: true;
|
|
7271
7271
|
};
|
|
7272
|
-
status: "
|
|
7272
|
+
status: "aborted";
|
|
7273
7273
|
thoughtSignature?: string;
|
|
7274
7274
|
time: {
|
|
7275
7275
|
start: number;
|
|
@@ -7463,14 +7463,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7463
7463
|
type: "image";
|
|
7464
7464
|
data: string;
|
|
7465
7465
|
mimeType: string;
|
|
7466
|
+
} | {
|
|
7467
|
+
type: "thinking";
|
|
7468
|
+
thinking: string;
|
|
7469
|
+
thinkingSignature?: string;
|
|
7470
|
+
redacted?: boolean;
|
|
7466
7471
|
} | {
|
|
7467
7472
|
addedToolNames?: string[];
|
|
7468
7473
|
arguments: Record<string, any>;
|
|
7469
7474
|
callID: string;
|
|
7470
7475
|
name: string;
|
|
7471
7476
|
namespace?: string;
|
|
7472
|
-
|
|
7473
|
-
content
|
|
7477
|
+
partial?: {
|
|
7478
|
+
content?: ({
|
|
7474
7479
|
type: "text";
|
|
7475
7480
|
text: string;
|
|
7476
7481
|
textSignature?: string;
|
|
@@ -7480,9 +7485,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7480
7485
|
mimeType: string;
|
|
7481
7486
|
})[];
|
|
7482
7487
|
details?: any;
|
|
7483
|
-
isError: false;
|
|
7484
7488
|
};
|
|
7485
|
-
status: "
|
|
7489
|
+
status: "running";
|
|
7486
7490
|
thoughtSignature?: string;
|
|
7487
7491
|
time: {
|
|
7488
7492
|
start: number;
|
|
@@ -7506,9 +7510,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7506
7510
|
mimeType: string;
|
|
7507
7511
|
})[];
|
|
7508
7512
|
details?: any;
|
|
7509
|
-
isError:
|
|
7513
|
+
isError: false;
|
|
7510
7514
|
};
|
|
7511
|
-
status: "
|
|
7515
|
+
status: "completed";
|
|
7512
7516
|
thoughtSignature?: string;
|
|
7513
7517
|
time: {
|
|
7514
7518
|
start: number;
|
|
@@ -7534,7 +7538,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7534
7538
|
details?: any;
|
|
7535
7539
|
isError: true;
|
|
7536
7540
|
};
|
|
7537
|
-
status: "
|
|
7541
|
+
status: "error";
|
|
7538
7542
|
thoughtSignature?: string;
|
|
7539
7543
|
time: {
|
|
7540
7544
|
start: number;
|
|
@@ -7560,26 +7564,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7560
7564
|
details?: any;
|
|
7561
7565
|
isError: true;
|
|
7562
7566
|
};
|
|
7563
|
-
status: "
|
|
7567
|
+
status: "skipped";
|
|
7564
7568
|
thoughtSignature?: string;
|
|
7565
7569
|
time: {
|
|
7566
7570
|
start: number;
|
|
7567
7571
|
end: number;
|
|
7568
7572
|
};
|
|
7569
7573
|
type: "toolCall";
|
|
7570
|
-
} | {
|
|
7571
|
-
type: "thinking";
|
|
7572
|
-
thinking: string;
|
|
7573
|
-
thinkingSignature?: string;
|
|
7574
|
-
redacted?: boolean;
|
|
7575
7574
|
} | {
|
|
7576
7575
|
addedToolNames?: string[];
|
|
7577
7576
|
arguments: Record<string, any>;
|
|
7578
7577
|
callID: string;
|
|
7579
7578
|
name: string;
|
|
7580
7579
|
namespace?: string;
|
|
7581
|
-
|
|
7582
|
-
content
|
|
7580
|
+
result: {
|
|
7581
|
+
content: ({
|
|
7583
7582
|
type: "text";
|
|
7584
7583
|
text: string;
|
|
7585
7584
|
textSignature?: string;
|
|
@@ -7589,8 +7588,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7589
7588
|
mimeType: string;
|
|
7590
7589
|
})[];
|
|
7591
7590
|
details?: any;
|
|
7591
|
+
isError: true;
|
|
7592
7592
|
};
|
|
7593
|
-
status: "
|
|
7593
|
+
status: "aborted";
|
|
7594
7594
|
thoughtSignature?: string;
|
|
7595
7595
|
time: {
|
|
7596
7596
|
start: number;
|
|
@@ -7765,14 +7765,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7765
7765
|
type: "image";
|
|
7766
7766
|
data: string;
|
|
7767
7767
|
mimeType: string;
|
|
7768
|
+
} | {
|
|
7769
|
+
type: "thinking";
|
|
7770
|
+
thinking: string;
|
|
7771
|
+
thinkingSignature?: string;
|
|
7772
|
+
redacted?: boolean;
|
|
7768
7773
|
} | {
|
|
7769
7774
|
addedToolNames?: string[];
|
|
7770
7775
|
arguments: Record<string, any>;
|
|
7771
7776
|
callID: string;
|
|
7772
7777
|
name: string;
|
|
7773
7778
|
namespace?: string;
|
|
7774
|
-
|
|
7775
|
-
content
|
|
7779
|
+
partial?: {
|
|
7780
|
+
content?: ({
|
|
7776
7781
|
type: "text";
|
|
7777
7782
|
text: string;
|
|
7778
7783
|
textSignature?: string;
|
|
@@ -7782,9 +7787,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7782
7787
|
mimeType: string;
|
|
7783
7788
|
})[];
|
|
7784
7789
|
details?: any;
|
|
7785
|
-
isError: false;
|
|
7786
7790
|
};
|
|
7787
|
-
status: "
|
|
7791
|
+
status: "running";
|
|
7788
7792
|
thoughtSignature?: string;
|
|
7789
7793
|
time: {
|
|
7790
7794
|
start: number;
|
|
@@ -7808,9 +7812,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7808
7812
|
mimeType: string;
|
|
7809
7813
|
})[];
|
|
7810
7814
|
details?: any;
|
|
7811
|
-
isError:
|
|
7815
|
+
isError: false;
|
|
7812
7816
|
};
|
|
7813
|
-
status: "
|
|
7817
|
+
status: "completed";
|
|
7814
7818
|
thoughtSignature?: string;
|
|
7815
7819
|
time: {
|
|
7816
7820
|
start: number;
|
|
@@ -7836,7 +7840,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7836
7840
|
details?: any;
|
|
7837
7841
|
isError: true;
|
|
7838
7842
|
};
|
|
7839
|
-
status: "
|
|
7843
|
+
status: "error";
|
|
7840
7844
|
thoughtSignature?: string;
|
|
7841
7845
|
time: {
|
|
7842
7846
|
start: number;
|
|
@@ -7862,26 +7866,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7862
7866
|
details?: any;
|
|
7863
7867
|
isError: true;
|
|
7864
7868
|
};
|
|
7865
|
-
status: "
|
|
7869
|
+
status: "skipped";
|
|
7866
7870
|
thoughtSignature?: string;
|
|
7867
7871
|
time: {
|
|
7868
7872
|
start: number;
|
|
7869
7873
|
end: number;
|
|
7870
7874
|
};
|
|
7871
7875
|
type: "toolCall";
|
|
7872
|
-
} | {
|
|
7873
|
-
type: "thinking";
|
|
7874
|
-
thinking: string;
|
|
7875
|
-
thinkingSignature?: string;
|
|
7876
|
-
redacted?: boolean;
|
|
7877
7876
|
} | {
|
|
7878
7877
|
addedToolNames?: string[];
|
|
7879
7878
|
arguments: Record<string, any>;
|
|
7880
7879
|
callID: string;
|
|
7881
7880
|
name: string;
|
|
7882
7881
|
namespace?: string;
|
|
7883
|
-
|
|
7884
|
-
content
|
|
7882
|
+
result: {
|
|
7883
|
+
content: ({
|
|
7885
7884
|
type: "text";
|
|
7886
7885
|
text: string;
|
|
7887
7886
|
textSignature?: string;
|
|
@@ -7891,8 +7890,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7891
7890
|
mimeType: string;
|
|
7892
7891
|
})[];
|
|
7893
7892
|
details?: any;
|
|
7893
|
+
isError: true;
|
|
7894
7894
|
};
|
|
7895
|
-
status: "
|
|
7895
|
+
status: "aborted";
|
|
7896
7896
|
thoughtSignature?: string;
|
|
7897
7897
|
time: {
|
|
7898
7898
|
start: number;
|
|
@@ -8098,14 +8098,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8098
8098
|
type: "image";
|
|
8099
8099
|
data: string;
|
|
8100
8100
|
mimeType: string;
|
|
8101
|
+
} | {
|
|
8102
|
+
type: "thinking";
|
|
8103
|
+
thinking: string;
|
|
8104
|
+
thinkingSignature?: string;
|
|
8105
|
+
redacted?: boolean;
|
|
8101
8106
|
} | {
|
|
8102
8107
|
addedToolNames?: string[];
|
|
8103
8108
|
arguments: Record<string, any>;
|
|
8104
8109
|
callID: string;
|
|
8105
8110
|
name: string;
|
|
8106
8111
|
namespace?: string;
|
|
8107
|
-
|
|
8108
|
-
content
|
|
8112
|
+
partial?: {
|
|
8113
|
+
content?: ({
|
|
8109
8114
|
type: "text";
|
|
8110
8115
|
text: string;
|
|
8111
8116
|
textSignature?: string;
|
|
@@ -8115,9 +8120,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8115
8120
|
mimeType: string;
|
|
8116
8121
|
})[];
|
|
8117
8122
|
details?: any;
|
|
8118
|
-
isError: false;
|
|
8119
8123
|
};
|
|
8120
|
-
status: "
|
|
8124
|
+
status: "running";
|
|
8121
8125
|
thoughtSignature?: string;
|
|
8122
8126
|
time: {
|
|
8123
8127
|
start: number;
|
|
@@ -8141,9 +8145,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8141
8145
|
mimeType: string;
|
|
8142
8146
|
})[];
|
|
8143
8147
|
details?: any;
|
|
8144
|
-
isError:
|
|
8148
|
+
isError: false;
|
|
8145
8149
|
};
|
|
8146
|
-
status: "
|
|
8150
|
+
status: "completed";
|
|
8147
8151
|
thoughtSignature?: string;
|
|
8148
8152
|
time: {
|
|
8149
8153
|
start: number;
|
|
@@ -8169,7 +8173,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8169
8173
|
details?: any;
|
|
8170
8174
|
isError: true;
|
|
8171
8175
|
};
|
|
8172
|
-
status: "
|
|
8176
|
+
status: "error";
|
|
8173
8177
|
thoughtSignature?: string;
|
|
8174
8178
|
time: {
|
|
8175
8179
|
start: number;
|
|
@@ -8195,26 +8199,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8195
8199
|
details?: any;
|
|
8196
8200
|
isError: true;
|
|
8197
8201
|
};
|
|
8198
|
-
status: "
|
|
8202
|
+
status: "skipped";
|
|
8199
8203
|
thoughtSignature?: string;
|
|
8200
8204
|
time: {
|
|
8201
8205
|
start: number;
|
|
8202
8206
|
end: number;
|
|
8203
8207
|
};
|
|
8204
8208
|
type: "toolCall";
|
|
8205
|
-
} | {
|
|
8206
|
-
type: "thinking";
|
|
8207
|
-
thinking: string;
|
|
8208
|
-
thinkingSignature?: string;
|
|
8209
|
-
redacted?: boolean;
|
|
8210
8209
|
} | {
|
|
8211
8210
|
addedToolNames?: string[];
|
|
8212
8211
|
arguments: Record<string, any>;
|
|
8213
8212
|
callID: string;
|
|
8214
8213
|
name: string;
|
|
8215
8214
|
namespace?: string;
|
|
8216
|
-
|
|
8217
|
-
content
|
|
8215
|
+
result: {
|
|
8216
|
+
content: ({
|
|
8218
8217
|
type: "text";
|
|
8219
8218
|
text: string;
|
|
8220
8219
|
textSignature?: string;
|
|
@@ -8224,8 +8223,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8224
8223
|
mimeType: string;
|
|
8225
8224
|
})[];
|
|
8226
8225
|
details?: any;
|
|
8226
|
+
isError: true;
|
|
8227
8227
|
};
|
|
8228
|
-
status: "
|
|
8228
|
+
status: "aborted";
|
|
8229
8229
|
thoughtSignature?: string;
|
|
8230
8230
|
time: {
|
|
8231
8231
|
start: number;
|
|
@@ -8400,14 +8400,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8400
8400
|
type: "image";
|
|
8401
8401
|
data: string;
|
|
8402
8402
|
mimeType: string;
|
|
8403
|
+
} | {
|
|
8404
|
+
type: "thinking";
|
|
8405
|
+
thinking: string;
|
|
8406
|
+
thinkingSignature?: string;
|
|
8407
|
+
redacted?: boolean;
|
|
8403
8408
|
} | {
|
|
8404
8409
|
addedToolNames?: string[];
|
|
8405
8410
|
arguments: Record<string, any>;
|
|
8406
8411
|
callID: string;
|
|
8407
8412
|
name: string;
|
|
8408
8413
|
namespace?: string;
|
|
8409
|
-
|
|
8410
|
-
content
|
|
8414
|
+
partial?: {
|
|
8415
|
+
content?: ({
|
|
8411
8416
|
type: "text";
|
|
8412
8417
|
text: string;
|
|
8413
8418
|
textSignature?: string;
|
|
@@ -8417,9 +8422,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8417
8422
|
mimeType: string;
|
|
8418
8423
|
})[];
|
|
8419
8424
|
details?: any;
|
|
8420
|
-
isError: false;
|
|
8421
8425
|
};
|
|
8422
|
-
status: "
|
|
8426
|
+
status: "running";
|
|
8423
8427
|
thoughtSignature?: string;
|
|
8424
8428
|
time: {
|
|
8425
8429
|
start: number;
|
|
@@ -8443,9 +8447,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8443
8447
|
mimeType: string;
|
|
8444
8448
|
})[];
|
|
8445
8449
|
details?: any;
|
|
8446
|
-
isError:
|
|
8450
|
+
isError: false;
|
|
8447
8451
|
};
|
|
8448
|
-
status: "
|
|
8452
|
+
status: "completed";
|
|
8449
8453
|
thoughtSignature?: string;
|
|
8450
8454
|
time: {
|
|
8451
8455
|
start: number;
|
|
@@ -8471,7 +8475,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8471
8475
|
details?: any;
|
|
8472
8476
|
isError: true;
|
|
8473
8477
|
};
|
|
8474
|
-
status: "
|
|
8478
|
+
status: "error";
|
|
8475
8479
|
thoughtSignature?: string;
|
|
8476
8480
|
time: {
|
|
8477
8481
|
start: number;
|
|
@@ -8497,26 +8501,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8497
8501
|
details?: any;
|
|
8498
8502
|
isError: true;
|
|
8499
8503
|
};
|
|
8500
|
-
status: "
|
|
8504
|
+
status: "skipped";
|
|
8501
8505
|
thoughtSignature?: string;
|
|
8502
8506
|
time: {
|
|
8503
8507
|
start: number;
|
|
8504
8508
|
end: number;
|
|
8505
8509
|
};
|
|
8506
8510
|
type: "toolCall";
|
|
8507
|
-
} | {
|
|
8508
|
-
type: "thinking";
|
|
8509
|
-
thinking: string;
|
|
8510
|
-
thinkingSignature?: string;
|
|
8511
|
-
redacted?: boolean;
|
|
8512
8511
|
} | {
|
|
8513
8512
|
addedToolNames?: string[];
|
|
8514
8513
|
arguments: Record<string, any>;
|
|
8515
8514
|
callID: string;
|
|
8516
8515
|
name: string;
|
|
8517
8516
|
namespace?: string;
|
|
8518
|
-
|
|
8519
|
-
content
|
|
8517
|
+
result: {
|
|
8518
|
+
content: ({
|
|
8520
8519
|
type: "text";
|
|
8521
8520
|
text: string;
|
|
8522
8521
|
textSignature?: string;
|
|
@@ -8526,8 +8525,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8526
8525
|
mimeType: string;
|
|
8527
8526
|
})[];
|
|
8528
8527
|
details?: any;
|
|
8528
|
+
isError: true;
|
|
8529
8529
|
};
|
|
8530
|
-
status: "
|
|
8530
|
+
status: "aborted";
|
|
8531
8531
|
thoughtSignature?: string;
|
|
8532
8532
|
time: {
|
|
8533
8533
|
start: number;
|
|
@@ -8721,14 +8721,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8721
8721
|
type: "image";
|
|
8722
8722
|
data: string;
|
|
8723
8723
|
mimeType: string;
|
|
8724
|
+
} | {
|
|
8725
|
+
type: "thinking";
|
|
8726
|
+
thinking: string;
|
|
8727
|
+
thinkingSignature?: string;
|
|
8728
|
+
redacted?: boolean;
|
|
8724
8729
|
} | {
|
|
8725
8730
|
addedToolNames?: string[];
|
|
8726
8731
|
arguments: Record<string, any>;
|
|
8727
8732
|
callID: string;
|
|
8728
8733
|
name: string;
|
|
8729
8734
|
namespace?: string;
|
|
8730
|
-
|
|
8731
|
-
content
|
|
8735
|
+
partial?: {
|
|
8736
|
+
content?: ({
|
|
8732
8737
|
type: "text";
|
|
8733
8738
|
text: string;
|
|
8734
8739
|
textSignature?: string;
|
|
@@ -8738,9 +8743,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8738
8743
|
mimeType: string;
|
|
8739
8744
|
})[];
|
|
8740
8745
|
details?: any;
|
|
8741
|
-
isError: false;
|
|
8742
8746
|
};
|
|
8743
|
-
status: "
|
|
8747
|
+
status: "running";
|
|
8744
8748
|
thoughtSignature?: string;
|
|
8745
8749
|
time: {
|
|
8746
8750
|
start: number;
|
|
@@ -8764,9 +8768,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8764
8768
|
mimeType: string;
|
|
8765
8769
|
})[];
|
|
8766
8770
|
details?: any;
|
|
8767
|
-
isError:
|
|
8771
|
+
isError: false;
|
|
8768
8772
|
};
|
|
8769
|
-
status: "
|
|
8773
|
+
status: "completed";
|
|
8770
8774
|
thoughtSignature?: string;
|
|
8771
8775
|
time: {
|
|
8772
8776
|
start: number;
|
|
@@ -8792,7 +8796,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8792
8796
|
details?: any;
|
|
8793
8797
|
isError: true;
|
|
8794
8798
|
};
|
|
8795
|
-
status: "
|
|
8799
|
+
status: "error";
|
|
8796
8800
|
thoughtSignature?: string;
|
|
8797
8801
|
time: {
|
|
8798
8802
|
start: number;
|
|
@@ -8818,26 +8822,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8818
8822
|
details?: any;
|
|
8819
8823
|
isError: true;
|
|
8820
8824
|
};
|
|
8821
|
-
status: "
|
|
8825
|
+
status: "skipped";
|
|
8822
8826
|
thoughtSignature?: string;
|
|
8823
8827
|
time: {
|
|
8824
8828
|
start: number;
|
|
8825
8829
|
end: number;
|
|
8826
8830
|
};
|
|
8827
8831
|
type: "toolCall";
|
|
8828
|
-
} | {
|
|
8829
|
-
type: "thinking";
|
|
8830
|
-
thinking: string;
|
|
8831
|
-
thinkingSignature?: string;
|
|
8832
|
-
redacted?: boolean;
|
|
8833
8832
|
} | {
|
|
8834
8833
|
addedToolNames?: string[];
|
|
8835
8834
|
arguments: Record<string, any>;
|
|
8836
8835
|
callID: string;
|
|
8837
8836
|
name: string;
|
|
8838
8837
|
namespace?: string;
|
|
8839
|
-
|
|
8840
|
-
content
|
|
8838
|
+
result: {
|
|
8839
|
+
content: ({
|
|
8841
8840
|
type: "text";
|
|
8842
8841
|
text: string;
|
|
8843
8842
|
textSignature?: string;
|
|
@@ -8847,8 +8846,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8847
8846
|
mimeType: string;
|
|
8848
8847
|
})[];
|
|
8849
8848
|
details?: any;
|
|
8849
|
+
isError: true;
|
|
8850
8850
|
};
|
|
8851
|
-
status: "
|
|
8851
|
+
status: "aborted";
|
|
8852
8852
|
thoughtSignature?: string;
|
|
8853
8853
|
time: {
|
|
8854
8854
|
start: number;
|
|
@@ -9023,14 +9023,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
9023
9023
|
type: "image";
|
|
9024
9024
|
data: string;
|
|
9025
9025
|
mimeType: string;
|
|
9026
|
+
} | {
|
|
9027
|
+
type: "thinking";
|
|
9028
|
+
thinking: string;
|
|
9029
|
+
thinkingSignature?: string;
|
|
9030
|
+
redacted?: boolean;
|
|
9026
9031
|
} | {
|
|
9027
9032
|
addedToolNames?: string[];
|
|
9028
9033
|
arguments: Record<string, any>;
|
|
9029
9034
|
callID: string;
|
|
9030
9035
|
name: string;
|
|
9031
9036
|
namespace?: string;
|
|
9032
|
-
|
|
9033
|
-
content
|
|
9037
|
+
partial?: {
|
|
9038
|
+
content?: ({
|
|
9034
9039
|
type: "text";
|
|
9035
9040
|
text: string;
|
|
9036
9041
|
textSignature?: string;
|
|
@@ -9040,9 +9045,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
9040
9045
|
mimeType: string;
|
|
9041
9046
|
})[];
|
|
9042
9047
|
details?: any;
|
|
9043
|
-
isError: false;
|
|
9044
9048
|
};
|
|
9045
|
-
status: "
|
|
9049
|
+
status: "running";
|
|
9046
9050
|
thoughtSignature?: string;
|
|
9047
9051
|
time: {
|
|
9048
9052
|
start: number;
|
|
@@ -9066,9 +9070,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
9066
9070
|
mimeType: string;
|
|
9067
9071
|
})[];
|
|
9068
9072
|
details?: any;
|
|
9069
|
-
isError:
|
|
9073
|
+
isError: false;
|
|
9070
9074
|
};
|
|
9071
|
-
status: "
|
|
9075
|
+
status: "completed";
|
|
9072
9076
|
thoughtSignature?: string;
|
|
9073
9077
|
time: {
|
|
9074
9078
|
start: number;
|
|
@@ -9094,7 +9098,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
9094
9098
|
details?: any;
|
|
9095
9099
|
isError: true;
|
|
9096
9100
|
};
|
|
9097
|
-
status: "
|
|
9101
|
+
status: "error";
|
|
9098
9102
|
thoughtSignature?: string;
|
|
9099
9103
|
time: {
|
|
9100
9104
|
start: number;
|
|
@@ -9120,26 +9124,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
9120
9124
|
details?: any;
|
|
9121
9125
|
isError: true;
|
|
9122
9126
|
};
|
|
9123
|
-
status: "
|
|
9127
|
+
status: "skipped";
|
|
9124
9128
|
thoughtSignature?: string;
|
|
9125
9129
|
time: {
|
|
9126
9130
|
start: number;
|
|
9127
9131
|
end: number;
|
|
9128
9132
|
};
|
|
9129
9133
|
type: "toolCall";
|
|
9130
|
-
} | {
|
|
9131
|
-
type: "thinking";
|
|
9132
|
-
thinking: string;
|
|
9133
|
-
thinkingSignature?: string;
|
|
9134
|
-
redacted?: boolean;
|
|
9135
9134
|
} | {
|
|
9136
9135
|
addedToolNames?: string[];
|
|
9137
9136
|
arguments: Record<string, any>;
|
|
9138
9137
|
callID: string;
|
|
9139
9138
|
name: string;
|
|
9140
9139
|
namespace?: string;
|
|
9141
|
-
|
|
9142
|
-
content
|
|
9140
|
+
result: {
|
|
9141
|
+
content: ({
|
|
9143
9142
|
type: "text";
|
|
9144
9143
|
text: string;
|
|
9145
9144
|
textSignature?: string;
|
|
@@ -9149,8 +9148,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
9149
9148
|
mimeType: string;
|
|
9150
9149
|
})[];
|
|
9151
9150
|
details?: any;
|
|
9151
|
+
isError: true;
|
|
9152
9152
|
};
|
|
9153
|
-
status: "
|
|
9153
|
+
status: "aborted";
|
|
9154
9154
|
thoughtSignature?: string;
|
|
9155
9155
|
time: {
|
|
9156
9156
|
start: number;
|
|
@@ -11112,14 +11112,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11112
11112
|
type: "image";
|
|
11113
11113
|
data: string;
|
|
11114
11114
|
mimeType: string;
|
|
11115
|
+
} | {
|
|
11116
|
+
type: "thinking";
|
|
11117
|
+
thinking: string;
|
|
11118
|
+
thinkingSignature?: string;
|
|
11119
|
+
redacted?: boolean;
|
|
11115
11120
|
} | {
|
|
11116
11121
|
addedToolNames?: string[];
|
|
11117
11122
|
arguments: Record<string, any>;
|
|
11118
11123
|
callID: string;
|
|
11119
11124
|
name: string;
|
|
11120
11125
|
namespace?: string;
|
|
11121
|
-
|
|
11122
|
-
content
|
|
11126
|
+
partial?: {
|
|
11127
|
+
content?: ({
|
|
11123
11128
|
type: "text";
|
|
11124
11129
|
text: string;
|
|
11125
11130
|
textSignature?: string;
|
|
@@ -11129,9 +11134,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11129
11134
|
mimeType: string;
|
|
11130
11135
|
})[];
|
|
11131
11136
|
details?: any;
|
|
11132
|
-
isError: false;
|
|
11133
11137
|
};
|
|
11134
|
-
status: "
|
|
11138
|
+
status: "running";
|
|
11135
11139
|
thoughtSignature?: string;
|
|
11136
11140
|
time: {
|
|
11137
11141
|
start: number;
|
|
@@ -11155,9 +11159,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11155
11159
|
mimeType: string;
|
|
11156
11160
|
})[];
|
|
11157
11161
|
details?: any;
|
|
11158
|
-
isError:
|
|
11162
|
+
isError: false;
|
|
11159
11163
|
};
|
|
11160
|
-
status: "
|
|
11164
|
+
status: "completed";
|
|
11161
11165
|
thoughtSignature?: string;
|
|
11162
11166
|
time: {
|
|
11163
11167
|
start: number;
|
|
@@ -11183,7 +11187,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11183
11187
|
details?: any;
|
|
11184
11188
|
isError: true;
|
|
11185
11189
|
};
|
|
11186
|
-
status: "
|
|
11190
|
+
status: "error";
|
|
11187
11191
|
thoughtSignature?: string;
|
|
11188
11192
|
time: {
|
|
11189
11193
|
start: number;
|
|
@@ -11209,26 +11213,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11209
11213
|
details?: any;
|
|
11210
11214
|
isError: true;
|
|
11211
11215
|
};
|
|
11212
|
-
status: "
|
|
11216
|
+
status: "skipped";
|
|
11213
11217
|
thoughtSignature?: string;
|
|
11214
11218
|
time: {
|
|
11215
11219
|
start: number;
|
|
11216
11220
|
end: number;
|
|
11217
11221
|
};
|
|
11218
11222
|
type: "toolCall";
|
|
11219
|
-
} | {
|
|
11220
|
-
type: "thinking";
|
|
11221
|
-
thinking: string;
|
|
11222
|
-
thinkingSignature?: string;
|
|
11223
|
-
redacted?: boolean;
|
|
11224
11223
|
} | {
|
|
11225
11224
|
addedToolNames?: string[];
|
|
11226
11225
|
arguments: Record<string, any>;
|
|
11227
11226
|
callID: string;
|
|
11228
11227
|
name: string;
|
|
11229
11228
|
namespace?: string;
|
|
11230
|
-
|
|
11231
|
-
content
|
|
11229
|
+
result: {
|
|
11230
|
+
content: ({
|
|
11232
11231
|
type: "text";
|
|
11233
11232
|
text: string;
|
|
11234
11233
|
textSignature?: string;
|
|
@@ -11238,8 +11237,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11238
11237
|
mimeType: string;
|
|
11239
11238
|
})[];
|
|
11240
11239
|
details?: any;
|
|
11240
|
+
isError: true;
|
|
11241
11241
|
};
|
|
11242
|
-
status: "
|
|
11242
|
+
status: "aborted";
|
|
11243
11243
|
thoughtSignature?: string;
|
|
11244
11244
|
time: {
|
|
11245
11245
|
start: number;
|
|
@@ -11414,14 +11414,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11414
11414
|
type: "image";
|
|
11415
11415
|
data: string;
|
|
11416
11416
|
mimeType: string;
|
|
11417
|
+
} | {
|
|
11418
|
+
type: "thinking";
|
|
11419
|
+
thinking: string;
|
|
11420
|
+
thinkingSignature?: string;
|
|
11421
|
+
redacted?: boolean;
|
|
11417
11422
|
} | {
|
|
11418
11423
|
addedToolNames?: string[];
|
|
11419
11424
|
arguments: Record<string, any>;
|
|
11420
11425
|
callID: string;
|
|
11421
11426
|
name: string;
|
|
11422
11427
|
namespace?: string;
|
|
11423
|
-
|
|
11424
|
-
content
|
|
11428
|
+
partial?: {
|
|
11429
|
+
content?: ({
|
|
11425
11430
|
type: "text";
|
|
11426
11431
|
text: string;
|
|
11427
11432
|
textSignature?: string;
|
|
@@ -11431,9 +11436,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11431
11436
|
mimeType: string;
|
|
11432
11437
|
})[];
|
|
11433
11438
|
details?: any;
|
|
11434
|
-
isError: false;
|
|
11435
11439
|
};
|
|
11436
|
-
status: "
|
|
11440
|
+
status: "running";
|
|
11437
11441
|
thoughtSignature?: string;
|
|
11438
11442
|
time: {
|
|
11439
11443
|
start: number;
|
|
@@ -11457,9 +11461,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11457
11461
|
mimeType: string;
|
|
11458
11462
|
})[];
|
|
11459
11463
|
details?: any;
|
|
11460
|
-
isError:
|
|
11464
|
+
isError: false;
|
|
11461
11465
|
};
|
|
11462
|
-
status: "
|
|
11466
|
+
status: "completed";
|
|
11463
11467
|
thoughtSignature?: string;
|
|
11464
11468
|
time: {
|
|
11465
11469
|
start: number;
|
|
@@ -11485,7 +11489,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11485
11489
|
details?: any;
|
|
11486
11490
|
isError: true;
|
|
11487
11491
|
};
|
|
11488
|
-
status: "
|
|
11492
|
+
status: "error";
|
|
11489
11493
|
thoughtSignature?: string;
|
|
11490
11494
|
time: {
|
|
11491
11495
|
start: number;
|
|
@@ -11511,26 +11515,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11511
11515
|
details?: any;
|
|
11512
11516
|
isError: true;
|
|
11513
11517
|
};
|
|
11514
|
-
status: "
|
|
11518
|
+
status: "skipped";
|
|
11515
11519
|
thoughtSignature?: string;
|
|
11516
11520
|
time: {
|
|
11517
11521
|
start: number;
|
|
11518
11522
|
end: number;
|
|
11519
11523
|
};
|
|
11520
11524
|
type: "toolCall";
|
|
11521
|
-
} | {
|
|
11522
|
-
type: "thinking";
|
|
11523
|
-
thinking: string;
|
|
11524
|
-
thinkingSignature?: string;
|
|
11525
|
-
redacted?: boolean;
|
|
11526
11525
|
} | {
|
|
11527
11526
|
addedToolNames?: string[];
|
|
11528
11527
|
arguments: Record<string, any>;
|
|
11529
11528
|
callID: string;
|
|
11530
11529
|
name: string;
|
|
11531
11530
|
namespace?: string;
|
|
11532
|
-
|
|
11533
|
-
content
|
|
11531
|
+
result: {
|
|
11532
|
+
content: ({
|
|
11534
11533
|
type: "text";
|
|
11535
11534
|
text: string;
|
|
11536
11535
|
textSignature?: string;
|
|
@@ -11540,8 +11539,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11540
11539
|
mimeType: string;
|
|
11541
11540
|
})[];
|
|
11542
11541
|
details?: any;
|
|
11542
|
+
isError: true;
|
|
11543
11543
|
};
|
|
11544
|
-
status: "
|
|
11544
|
+
status: "aborted";
|
|
11545
11545
|
thoughtSignature?: string;
|
|
11546
11546
|
time: {
|
|
11547
11547
|
start: number;
|
|
@@ -11734,14 +11734,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11734
11734
|
type: "image";
|
|
11735
11735
|
data: string;
|
|
11736
11736
|
mimeType: string;
|
|
11737
|
+
} | {
|
|
11738
|
+
type: "thinking";
|
|
11739
|
+
thinking: string;
|
|
11740
|
+
thinkingSignature?: string;
|
|
11741
|
+
redacted?: boolean;
|
|
11737
11742
|
} | {
|
|
11738
11743
|
addedToolNames?: string[];
|
|
11739
11744
|
arguments: Record<string, any>;
|
|
11740
11745
|
callID: string;
|
|
11741
11746
|
name: string;
|
|
11742
11747
|
namespace?: string;
|
|
11743
|
-
|
|
11744
|
-
content
|
|
11748
|
+
partial?: {
|
|
11749
|
+
content?: ({
|
|
11745
11750
|
type: "text";
|
|
11746
11751
|
text: string;
|
|
11747
11752
|
textSignature?: string;
|
|
@@ -11751,9 +11756,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11751
11756
|
mimeType: string;
|
|
11752
11757
|
})[];
|
|
11753
11758
|
details?: any;
|
|
11754
|
-
isError: false;
|
|
11755
11759
|
};
|
|
11756
|
-
status: "
|
|
11760
|
+
status: "running";
|
|
11757
11761
|
thoughtSignature?: string;
|
|
11758
11762
|
time: {
|
|
11759
11763
|
start: number;
|
|
@@ -11777,9 +11781,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11777
11781
|
mimeType: string;
|
|
11778
11782
|
})[];
|
|
11779
11783
|
details?: any;
|
|
11780
|
-
isError:
|
|
11784
|
+
isError: false;
|
|
11781
11785
|
};
|
|
11782
|
-
status: "
|
|
11786
|
+
status: "completed";
|
|
11783
11787
|
thoughtSignature?: string;
|
|
11784
11788
|
time: {
|
|
11785
11789
|
start: number;
|
|
@@ -11805,7 +11809,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11805
11809
|
details?: any;
|
|
11806
11810
|
isError: true;
|
|
11807
11811
|
};
|
|
11808
|
-
status: "
|
|
11812
|
+
status: "error";
|
|
11809
11813
|
thoughtSignature?: string;
|
|
11810
11814
|
time: {
|
|
11811
11815
|
start: number;
|
|
@@ -11831,26 +11835,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11831
11835
|
details?: any;
|
|
11832
11836
|
isError: true;
|
|
11833
11837
|
};
|
|
11834
|
-
status: "
|
|
11838
|
+
status: "skipped";
|
|
11835
11839
|
thoughtSignature?: string;
|
|
11836
11840
|
time: {
|
|
11837
11841
|
start: number;
|
|
11838
11842
|
end: number;
|
|
11839
11843
|
};
|
|
11840
11844
|
type: "toolCall";
|
|
11841
|
-
} | {
|
|
11842
|
-
type: "thinking";
|
|
11843
|
-
thinking: string;
|
|
11844
|
-
thinkingSignature?: string;
|
|
11845
|
-
redacted?: boolean;
|
|
11846
11845
|
} | {
|
|
11847
11846
|
addedToolNames?: string[];
|
|
11848
11847
|
arguments: Record<string, any>;
|
|
11849
11848
|
callID: string;
|
|
11850
11849
|
name: string;
|
|
11851
11850
|
namespace?: string;
|
|
11852
|
-
|
|
11853
|
-
content
|
|
11851
|
+
result: {
|
|
11852
|
+
content: ({
|
|
11854
11853
|
type: "text";
|
|
11855
11854
|
text: string;
|
|
11856
11855
|
textSignature?: string;
|
|
@@ -11860,8 +11859,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11860
11859
|
mimeType: string;
|
|
11861
11860
|
})[];
|
|
11862
11861
|
details?: any;
|
|
11862
|
+
isError: true;
|
|
11863
11863
|
};
|
|
11864
|
-
status: "
|
|
11864
|
+
status: "aborted";
|
|
11865
11865
|
thoughtSignature?: string;
|
|
11866
11866
|
time: {
|
|
11867
11867
|
start: number;
|
|
@@ -12036,14 +12036,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12036
12036
|
type: "image";
|
|
12037
12037
|
data: string;
|
|
12038
12038
|
mimeType: string;
|
|
12039
|
+
} | {
|
|
12040
|
+
type: "thinking";
|
|
12041
|
+
thinking: string;
|
|
12042
|
+
thinkingSignature?: string;
|
|
12043
|
+
redacted?: boolean;
|
|
12039
12044
|
} | {
|
|
12040
12045
|
addedToolNames?: string[];
|
|
12041
12046
|
arguments: Record<string, any>;
|
|
12042
12047
|
callID: string;
|
|
12043
12048
|
name: string;
|
|
12044
12049
|
namespace?: string;
|
|
12045
|
-
|
|
12046
|
-
content
|
|
12050
|
+
partial?: {
|
|
12051
|
+
content?: ({
|
|
12047
12052
|
type: "text";
|
|
12048
12053
|
text: string;
|
|
12049
12054
|
textSignature?: string;
|
|
@@ -12053,9 +12058,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12053
12058
|
mimeType: string;
|
|
12054
12059
|
})[];
|
|
12055
12060
|
details?: any;
|
|
12056
|
-
isError: false;
|
|
12057
12061
|
};
|
|
12058
|
-
status: "
|
|
12062
|
+
status: "running";
|
|
12059
12063
|
thoughtSignature?: string;
|
|
12060
12064
|
time: {
|
|
12061
12065
|
start: number;
|
|
@@ -12079,9 +12083,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12079
12083
|
mimeType: string;
|
|
12080
12084
|
})[];
|
|
12081
12085
|
details?: any;
|
|
12082
|
-
isError:
|
|
12086
|
+
isError: false;
|
|
12083
12087
|
};
|
|
12084
|
-
status: "
|
|
12088
|
+
status: "completed";
|
|
12085
12089
|
thoughtSignature?: string;
|
|
12086
12090
|
time: {
|
|
12087
12091
|
start: number;
|
|
@@ -12107,7 +12111,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12107
12111
|
details?: any;
|
|
12108
12112
|
isError: true;
|
|
12109
12113
|
};
|
|
12110
|
-
status: "
|
|
12114
|
+
status: "error";
|
|
12111
12115
|
thoughtSignature?: string;
|
|
12112
12116
|
time: {
|
|
12113
12117
|
start: number;
|
|
@@ -12133,26 +12137,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12133
12137
|
details?: any;
|
|
12134
12138
|
isError: true;
|
|
12135
12139
|
};
|
|
12136
|
-
status: "
|
|
12140
|
+
status: "skipped";
|
|
12137
12141
|
thoughtSignature?: string;
|
|
12138
12142
|
time: {
|
|
12139
12143
|
start: number;
|
|
12140
12144
|
end: number;
|
|
12141
12145
|
};
|
|
12142
12146
|
type: "toolCall";
|
|
12143
|
-
} | {
|
|
12144
|
-
type: "thinking";
|
|
12145
|
-
thinking: string;
|
|
12146
|
-
thinkingSignature?: string;
|
|
12147
|
-
redacted?: boolean;
|
|
12148
12147
|
} | {
|
|
12149
12148
|
addedToolNames?: string[];
|
|
12150
12149
|
arguments: Record<string, any>;
|
|
12151
12150
|
callID: string;
|
|
12152
12151
|
name: string;
|
|
12153
12152
|
namespace?: string;
|
|
12154
|
-
|
|
12155
|
-
content
|
|
12153
|
+
result: {
|
|
12154
|
+
content: ({
|
|
12156
12155
|
type: "text";
|
|
12157
12156
|
text: string;
|
|
12158
12157
|
textSignature?: string;
|
|
@@ -12162,8 +12161,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12162
12161
|
mimeType: string;
|
|
12163
12162
|
})[];
|
|
12164
12163
|
details?: any;
|
|
12164
|
+
isError: true;
|
|
12165
12165
|
};
|
|
12166
|
-
status: "
|
|
12166
|
+
status: "aborted";
|
|
12167
12167
|
thoughtSignature?: string;
|
|
12168
12168
|
time: {
|
|
12169
12169
|
start: number;
|
|
@@ -12644,14 +12644,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12644
12644
|
type: "image";
|
|
12645
12645
|
data: string;
|
|
12646
12646
|
mimeType: string;
|
|
12647
|
+
} | {
|
|
12648
|
+
type: "thinking";
|
|
12649
|
+
thinking: string;
|
|
12650
|
+
thinkingSignature?: string;
|
|
12651
|
+
redacted?: boolean;
|
|
12647
12652
|
} | {
|
|
12648
12653
|
addedToolNames?: string[];
|
|
12649
12654
|
arguments: Record<string, any>;
|
|
12650
12655
|
callID: string;
|
|
12651
12656
|
name: string;
|
|
12652
12657
|
namespace?: string;
|
|
12653
|
-
|
|
12654
|
-
content
|
|
12658
|
+
partial?: {
|
|
12659
|
+
content?: ({
|
|
12655
12660
|
type: "text";
|
|
12656
12661
|
text: string;
|
|
12657
12662
|
textSignature?: string;
|
|
@@ -12661,9 +12666,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12661
12666
|
mimeType: string;
|
|
12662
12667
|
})[];
|
|
12663
12668
|
details?: any;
|
|
12664
|
-
isError: false;
|
|
12665
12669
|
};
|
|
12666
|
-
status: "
|
|
12670
|
+
status: "running";
|
|
12667
12671
|
thoughtSignature?: string;
|
|
12668
12672
|
time: {
|
|
12669
12673
|
start: number;
|
|
@@ -12687,9 +12691,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12687
12691
|
mimeType: string;
|
|
12688
12692
|
})[];
|
|
12689
12693
|
details?: any;
|
|
12690
|
-
isError:
|
|
12694
|
+
isError: false;
|
|
12691
12695
|
};
|
|
12692
|
-
status: "
|
|
12696
|
+
status: "completed";
|
|
12693
12697
|
thoughtSignature?: string;
|
|
12694
12698
|
time: {
|
|
12695
12699
|
start: number;
|
|
@@ -12715,7 +12719,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12715
12719
|
details?: any;
|
|
12716
12720
|
isError: true;
|
|
12717
12721
|
};
|
|
12718
|
-
status: "
|
|
12722
|
+
status: "error";
|
|
12719
12723
|
thoughtSignature?: string;
|
|
12720
12724
|
time: {
|
|
12721
12725
|
start: number;
|
|
@@ -12741,26 +12745,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12741
12745
|
details?: any;
|
|
12742
12746
|
isError: true;
|
|
12743
12747
|
};
|
|
12744
|
-
status: "
|
|
12748
|
+
status: "skipped";
|
|
12745
12749
|
thoughtSignature?: string;
|
|
12746
12750
|
time: {
|
|
12747
12751
|
start: number;
|
|
12748
12752
|
end: number;
|
|
12749
12753
|
};
|
|
12750
12754
|
type: "toolCall";
|
|
12751
|
-
} | {
|
|
12752
|
-
type: "thinking";
|
|
12753
|
-
thinking: string;
|
|
12754
|
-
thinkingSignature?: string;
|
|
12755
|
-
redacted?: boolean;
|
|
12756
12755
|
} | {
|
|
12757
12756
|
addedToolNames?: string[];
|
|
12758
12757
|
arguments: Record<string, any>;
|
|
12759
12758
|
callID: string;
|
|
12760
12759
|
name: string;
|
|
12761
12760
|
namespace?: string;
|
|
12762
|
-
|
|
12763
|
-
content
|
|
12761
|
+
result: {
|
|
12762
|
+
content: ({
|
|
12764
12763
|
type: "text";
|
|
12765
12764
|
text: string;
|
|
12766
12765
|
textSignature?: string;
|
|
@@ -12770,8 +12769,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12770
12769
|
mimeType: string;
|
|
12771
12770
|
})[];
|
|
12772
12771
|
details?: any;
|
|
12772
|
+
isError: true;
|
|
12773
12773
|
};
|
|
12774
|
-
status: "
|
|
12774
|
+
status: "aborted";
|
|
12775
12775
|
thoughtSignature?: string;
|
|
12776
12776
|
time: {
|
|
12777
12777
|
start: number;
|
|
@@ -12946,14 +12946,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12946
12946
|
type: "image";
|
|
12947
12947
|
data: string;
|
|
12948
12948
|
mimeType: string;
|
|
12949
|
+
} | {
|
|
12950
|
+
type: "thinking";
|
|
12951
|
+
thinking: string;
|
|
12952
|
+
thinkingSignature?: string;
|
|
12953
|
+
redacted?: boolean;
|
|
12949
12954
|
} | {
|
|
12950
12955
|
addedToolNames?: string[];
|
|
12951
12956
|
arguments: Record<string, any>;
|
|
12952
12957
|
callID: string;
|
|
12953
12958
|
name: string;
|
|
12954
12959
|
namespace?: string;
|
|
12955
|
-
|
|
12956
|
-
content
|
|
12960
|
+
partial?: {
|
|
12961
|
+
content?: ({
|
|
12957
12962
|
type: "text";
|
|
12958
12963
|
text: string;
|
|
12959
12964
|
textSignature?: string;
|
|
@@ -12963,9 +12968,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12963
12968
|
mimeType: string;
|
|
12964
12969
|
})[];
|
|
12965
12970
|
details?: any;
|
|
12966
|
-
isError: false;
|
|
12967
12971
|
};
|
|
12968
|
-
status: "
|
|
12972
|
+
status: "running";
|
|
12969
12973
|
thoughtSignature?: string;
|
|
12970
12974
|
time: {
|
|
12971
12975
|
start: number;
|
|
@@ -12989,9 +12993,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12989
12993
|
mimeType: string;
|
|
12990
12994
|
})[];
|
|
12991
12995
|
details?: any;
|
|
12992
|
-
isError:
|
|
12996
|
+
isError: false;
|
|
12993
12997
|
};
|
|
12994
|
-
status: "
|
|
12998
|
+
status: "completed";
|
|
12995
12999
|
thoughtSignature?: string;
|
|
12996
13000
|
time: {
|
|
12997
13001
|
start: number;
|
|
@@ -13017,7 +13021,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13017
13021
|
details?: any;
|
|
13018
13022
|
isError: true;
|
|
13019
13023
|
};
|
|
13020
|
-
status: "
|
|
13024
|
+
status: "error";
|
|
13021
13025
|
thoughtSignature?: string;
|
|
13022
13026
|
time: {
|
|
13023
13027
|
start: number;
|
|
@@ -13043,26 +13047,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13043
13047
|
details?: any;
|
|
13044
13048
|
isError: true;
|
|
13045
13049
|
};
|
|
13046
|
-
status: "
|
|
13050
|
+
status: "skipped";
|
|
13047
13051
|
thoughtSignature?: string;
|
|
13048
13052
|
time: {
|
|
13049
13053
|
start: number;
|
|
13050
13054
|
end: number;
|
|
13051
13055
|
};
|
|
13052
13056
|
type: "toolCall";
|
|
13053
|
-
} | {
|
|
13054
|
-
type: "thinking";
|
|
13055
|
-
thinking: string;
|
|
13056
|
-
thinkingSignature?: string;
|
|
13057
|
-
redacted?: boolean;
|
|
13058
13057
|
} | {
|
|
13059
13058
|
addedToolNames?: string[];
|
|
13060
13059
|
arguments: Record<string, any>;
|
|
13061
13060
|
callID: string;
|
|
13062
13061
|
name: string;
|
|
13063
13062
|
namespace?: string;
|
|
13064
|
-
|
|
13065
|
-
content
|
|
13063
|
+
result: {
|
|
13064
|
+
content: ({
|
|
13066
13065
|
type: "text";
|
|
13067
13066
|
text: string;
|
|
13068
13067
|
textSignature?: string;
|
|
@@ -13072,8 +13071,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13072
13071
|
mimeType: string;
|
|
13073
13072
|
})[];
|
|
13074
13073
|
details?: any;
|
|
13074
|
+
isError: true;
|
|
13075
13075
|
};
|
|
13076
|
-
status: "
|
|
13076
|
+
status: "aborted";
|
|
13077
13077
|
thoughtSignature?: string;
|
|
13078
13078
|
time: {
|
|
13079
13079
|
start: number;
|
|
@@ -13267,14 +13267,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13267
13267
|
type: "image";
|
|
13268
13268
|
data: string;
|
|
13269
13269
|
mimeType: string;
|
|
13270
|
+
} | {
|
|
13271
|
+
type: "thinking";
|
|
13272
|
+
thinking: string;
|
|
13273
|
+
thinkingSignature?: string;
|
|
13274
|
+
redacted?: boolean;
|
|
13270
13275
|
} | {
|
|
13271
13276
|
addedToolNames?: string[];
|
|
13272
13277
|
arguments: Record<string, any>;
|
|
13273
13278
|
callID: string;
|
|
13274
13279
|
name: string;
|
|
13275
13280
|
namespace?: string;
|
|
13276
|
-
|
|
13277
|
-
content
|
|
13281
|
+
partial?: {
|
|
13282
|
+
content?: ({
|
|
13278
13283
|
type: "text";
|
|
13279
13284
|
text: string;
|
|
13280
13285
|
textSignature?: string;
|
|
@@ -13284,9 +13289,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13284
13289
|
mimeType: string;
|
|
13285
13290
|
})[];
|
|
13286
13291
|
details?: any;
|
|
13287
|
-
isError: false;
|
|
13288
13292
|
};
|
|
13289
|
-
status: "
|
|
13293
|
+
status: "running";
|
|
13290
13294
|
thoughtSignature?: string;
|
|
13291
13295
|
time: {
|
|
13292
13296
|
start: number;
|
|
@@ -13310,9 +13314,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13310
13314
|
mimeType: string;
|
|
13311
13315
|
})[];
|
|
13312
13316
|
details?: any;
|
|
13313
|
-
isError:
|
|
13317
|
+
isError: false;
|
|
13314
13318
|
};
|
|
13315
|
-
status: "
|
|
13319
|
+
status: "completed";
|
|
13316
13320
|
thoughtSignature?: string;
|
|
13317
13321
|
time: {
|
|
13318
13322
|
start: number;
|
|
@@ -13338,7 +13342,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13338
13342
|
details?: any;
|
|
13339
13343
|
isError: true;
|
|
13340
13344
|
};
|
|
13341
|
-
status: "
|
|
13345
|
+
status: "error";
|
|
13342
13346
|
thoughtSignature?: string;
|
|
13343
13347
|
time: {
|
|
13344
13348
|
start: number;
|
|
@@ -13364,26 +13368,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13364
13368
|
details?: any;
|
|
13365
13369
|
isError: true;
|
|
13366
13370
|
};
|
|
13367
|
-
status: "
|
|
13371
|
+
status: "skipped";
|
|
13368
13372
|
thoughtSignature?: string;
|
|
13369
13373
|
time: {
|
|
13370
13374
|
start: number;
|
|
13371
13375
|
end: number;
|
|
13372
13376
|
};
|
|
13373
13377
|
type: "toolCall";
|
|
13374
|
-
} | {
|
|
13375
|
-
type: "thinking";
|
|
13376
|
-
thinking: string;
|
|
13377
|
-
thinkingSignature?: string;
|
|
13378
|
-
redacted?: boolean;
|
|
13379
13378
|
} | {
|
|
13380
13379
|
addedToolNames?: string[];
|
|
13381
13380
|
arguments: Record<string, any>;
|
|
13382
13381
|
callID: string;
|
|
13383
13382
|
name: string;
|
|
13384
13383
|
namespace?: string;
|
|
13385
|
-
|
|
13386
|
-
content
|
|
13384
|
+
result: {
|
|
13385
|
+
content: ({
|
|
13387
13386
|
type: "text";
|
|
13388
13387
|
text: string;
|
|
13389
13388
|
textSignature?: string;
|
|
@@ -13393,8 +13392,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13393
13392
|
mimeType: string;
|
|
13394
13393
|
})[];
|
|
13395
13394
|
details?: any;
|
|
13395
|
+
isError: true;
|
|
13396
13396
|
};
|
|
13397
|
-
status: "
|
|
13397
|
+
status: "aborted";
|
|
13398
13398
|
thoughtSignature?: string;
|
|
13399
13399
|
time: {
|
|
13400
13400
|
start: number;
|
|
@@ -13569,14 +13569,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13569
13569
|
type: "image";
|
|
13570
13570
|
data: string;
|
|
13571
13571
|
mimeType: string;
|
|
13572
|
+
} | {
|
|
13573
|
+
type: "thinking";
|
|
13574
|
+
thinking: string;
|
|
13575
|
+
thinkingSignature?: string;
|
|
13576
|
+
redacted?: boolean;
|
|
13572
13577
|
} | {
|
|
13573
13578
|
addedToolNames?: string[];
|
|
13574
13579
|
arguments: Record<string, any>;
|
|
13575
13580
|
callID: string;
|
|
13576
13581
|
name: string;
|
|
13577
13582
|
namespace?: string;
|
|
13578
|
-
|
|
13579
|
-
content
|
|
13583
|
+
partial?: {
|
|
13584
|
+
content?: ({
|
|
13580
13585
|
type: "text";
|
|
13581
13586
|
text: string;
|
|
13582
13587
|
textSignature?: string;
|
|
@@ -13586,9 +13591,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13586
13591
|
mimeType: string;
|
|
13587
13592
|
})[];
|
|
13588
13593
|
details?: any;
|
|
13589
|
-
isError: false;
|
|
13590
13594
|
};
|
|
13591
|
-
status: "
|
|
13595
|
+
status: "running";
|
|
13592
13596
|
thoughtSignature?: string;
|
|
13593
13597
|
time: {
|
|
13594
13598
|
start: number;
|
|
@@ -13612,9 +13616,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13612
13616
|
mimeType: string;
|
|
13613
13617
|
})[];
|
|
13614
13618
|
details?: any;
|
|
13615
|
-
isError:
|
|
13619
|
+
isError: false;
|
|
13616
13620
|
};
|
|
13617
|
-
status: "
|
|
13621
|
+
status: "completed";
|
|
13618
13622
|
thoughtSignature?: string;
|
|
13619
13623
|
time: {
|
|
13620
13624
|
start: number;
|
|
@@ -13640,7 +13644,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13640
13644
|
details?: any;
|
|
13641
13645
|
isError: true;
|
|
13642
13646
|
};
|
|
13643
|
-
status: "
|
|
13647
|
+
status: "error";
|
|
13644
13648
|
thoughtSignature?: string;
|
|
13645
13649
|
time: {
|
|
13646
13650
|
start: number;
|
|
@@ -13666,26 +13670,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13666
13670
|
details?: any;
|
|
13667
13671
|
isError: true;
|
|
13668
13672
|
};
|
|
13669
|
-
status: "
|
|
13673
|
+
status: "skipped";
|
|
13670
13674
|
thoughtSignature?: string;
|
|
13671
13675
|
time: {
|
|
13672
13676
|
start: number;
|
|
13673
13677
|
end: number;
|
|
13674
13678
|
};
|
|
13675
13679
|
type: "toolCall";
|
|
13676
|
-
} | {
|
|
13677
|
-
type: "thinking";
|
|
13678
|
-
thinking: string;
|
|
13679
|
-
thinkingSignature?: string;
|
|
13680
|
-
redacted?: boolean;
|
|
13681
13680
|
} | {
|
|
13682
13681
|
addedToolNames?: string[];
|
|
13683
13682
|
arguments: Record<string, any>;
|
|
13684
13683
|
callID: string;
|
|
13685
13684
|
name: string;
|
|
13686
13685
|
namespace?: string;
|
|
13687
|
-
|
|
13688
|
-
content
|
|
13686
|
+
result: {
|
|
13687
|
+
content: ({
|
|
13689
13688
|
type: "text";
|
|
13690
13689
|
text: string;
|
|
13691
13690
|
textSignature?: string;
|
|
@@ -13695,8 +13694,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13695
13694
|
mimeType: string;
|
|
13696
13695
|
})[];
|
|
13697
13696
|
details?: any;
|
|
13697
|
+
isError: true;
|
|
13698
13698
|
};
|
|
13699
|
-
status: "
|
|
13699
|
+
status: "aborted";
|
|
13700
13700
|
thoughtSignature?: string;
|
|
13701
13701
|
time: {
|
|
13702
13702
|
start: number;
|
|
@@ -13899,14 +13899,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13899
13899
|
type: "image";
|
|
13900
13900
|
data: string;
|
|
13901
13901
|
mimeType: string;
|
|
13902
|
+
} | {
|
|
13903
|
+
type: "thinking";
|
|
13904
|
+
thinking: string;
|
|
13905
|
+
thinkingSignature?: string;
|
|
13906
|
+
redacted?: boolean;
|
|
13902
13907
|
} | {
|
|
13903
13908
|
addedToolNames?: string[];
|
|
13904
13909
|
arguments: Record<string, any>;
|
|
13905
13910
|
callID: string;
|
|
13906
13911
|
name: string;
|
|
13907
13912
|
namespace?: string;
|
|
13908
|
-
|
|
13909
|
-
content
|
|
13913
|
+
partial?: {
|
|
13914
|
+
content?: ({
|
|
13910
13915
|
type: "text";
|
|
13911
13916
|
text: string;
|
|
13912
13917
|
textSignature?: string;
|
|
@@ -13916,9 +13921,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13916
13921
|
mimeType: string;
|
|
13917
13922
|
})[];
|
|
13918
13923
|
details?: any;
|
|
13919
|
-
isError: false;
|
|
13920
13924
|
};
|
|
13921
|
-
status: "
|
|
13925
|
+
status: "running";
|
|
13922
13926
|
thoughtSignature?: string;
|
|
13923
13927
|
time: {
|
|
13924
13928
|
start: number;
|
|
@@ -13942,9 +13946,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13942
13946
|
mimeType: string;
|
|
13943
13947
|
})[];
|
|
13944
13948
|
details?: any;
|
|
13945
|
-
isError:
|
|
13949
|
+
isError: false;
|
|
13946
13950
|
};
|
|
13947
|
-
status: "
|
|
13951
|
+
status: "completed";
|
|
13948
13952
|
thoughtSignature?: string;
|
|
13949
13953
|
time: {
|
|
13950
13954
|
start: number;
|
|
@@ -13970,7 +13974,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13970
13974
|
details?: any;
|
|
13971
13975
|
isError: true;
|
|
13972
13976
|
};
|
|
13973
|
-
status: "
|
|
13977
|
+
status: "error";
|
|
13974
13978
|
thoughtSignature?: string;
|
|
13975
13979
|
time: {
|
|
13976
13980
|
start: number;
|
|
@@ -13996,26 +14000,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13996
14000
|
details?: any;
|
|
13997
14001
|
isError: true;
|
|
13998
14002
|
};
|
|
13999
|
-
status: "
|
|
14003
|
+
status: "skipped";
|
|
14000
14004
|
thoughtSignature?: string;
|
|
14001
14005
|
time: {
|
|
14002
14006
|
start: number;
|
|
14003
14007
|
end: number;
|
|
14004
14008
|
};
|
|
14005
14009
|
type: "toolCall";
|
|
14006
|
-
} | {
|
|
14007
|
-
type: "thinking";
|
|
14008
|
-
thinking: string;
|
|
14009
|
-
thinkingSignature?: string;
|
|
14010
|
-
redacted?: boolean;
|
|
14011
14010
|
} | {
|
|
14012
14011
|
addedToolNames?: string[];
|
|
14013
14012
|
arguments: Record<string, any>;
|
|
14014
14013
|
callID: string;
|
|
14015
14014
|
name: string;
|
|
14016
14015
|
namespace?: string;
|
|
14017
|
-
|
|
14018
|
-
content
|
|
14016
|
+
result: {
|
|
14017
|
+
content: ({
|
|
14019
14018
|
type: "text";
|
|
14020
14019
|
text: string;
|
|
14021
14020
|
textSignature?: string;
|
|
@@ -14025,8 +14024,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14025
14024
|
mimeType: string;
|
|
14026
14025
|
})[];
|
|
14027
14026
|
details?: any;
|
|
14027
|
+
isError: true;
|
|
14028
14028
|
};
|
|
14029
|
-
status: "
|
|
14029
|
+
status: "aborted";
|
|
14030
14030
|
thoughtSignature?: string;
|
|
14031
14031
|
time: {
|
|
14032
14032
|
start: number;
|
|
@@ -14201,14 +14201,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14201
14201
|
type: "image";
|
|
14202
14202
|
data: string;
|
|
14203
14203
|
mimeType: string;
|
|
14204
|
+
} | {
|
|
14205
|
+
type: "thinking";
|
|
14206
|
+
thinking: string;
|
|
14207
|
+
thinkingSignature?: string;
|
|
14208
|
+
redacted?: boolean;
|
|
14204
14209
|
} | {
|
|
14205
14210
|
addedToolNames?: string[];
|
|
14206
14211
|
arguments: Record<string, any>;
|
|
14207
14212
|
callID: string;
|
|
14208
14213
|
name: string;
|
|
14209
14214
|
namespace?: string;
|
|
14210
|
-
|
|
14211
|
-
content
|
|
14215
|
+
partial?: {
|
|
14216
|
+
content?: ({
|
|
14212
14217
|
type: "text";
|
|
14213
14218
|
text: string;
|
|
14214
14219
|
textSignature?: string;
|
|
@@ -14218,9 +14223,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14218
14223
|
mimeType: string;
|
|
14219
14224
|
})[];
|
|
14220
14225
|
details?: any;
|
|
14221
|
-
isError: false;
|
|
14222
14226
|
};
|
|
14223
|
-
status: "
|
|
14227
|
+
status: "running";
|
|
14224
14228
|
thoughtSignature?: string;
|
|
14225
14229
|
time: {
|
|
14226
14230
|
start: number;
|
|
@@ -14244,9 +14248,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14244
14248
|
mimeType: string;
|
|
14245
14249
|
})[];
|
|
14246
14250
|
details?: any;
|
|
14247
|
-
isError:
|
|
14251
|
+
isError: false;
|
|
14248
14252
|
};
|
|
14249
|
-
status: "
|
|
14253
|
+
status: "completed";
|
|
14250
14254
|
thoughtSignature?: string;
|
|
14251
14255
|
time: {
|
|
14252
14256
|
start: number;
|
|
@@ -14272,7 +14276,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14272
14276
|
details?: any;
|
|
14273
14277
|
isError: true;
|
|
14274
14278
|
};
|
|
14275
|
-
status: "
|
|
14279
|
+
status: "error";
|
|
14276
14280
|
thoughtSignature?: string;
|
|
14277
14281
|
time: {
|
|
14278
14282
|
start: number;
|
|
@@ -14298,26 +14302,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14298
14302
|
details?: any;
|
|
14299
14303
|
isError: true;
|
|
14300
14304
|
};
|
|
14301
|
-
status: "
|
|
14305
|
+
status: "skipped";
|
|
14302
14306
|
thoughtSignature?: string;
|
|
14303
14307
|
time: {
|
|
14304
14308
|
start: number;
|
|
14305
14309
|
end: number;
|
|
14306
14310
|
};
|
|
14307
14311
|
type: "toolCall";
|
|
14308
|
-
} | {
|
|
14309
|
-
type: "thinking";
|
|
14310
|
-
thinking: string;
|
|
14311
|
-
thinkingSignature?: string;
|
|
14312
|
-
redacted?: boolean;
|
|
14313
14312
|
} | {
|
|
14314
14313
|
addedToolNames?: string[];
|
|
14315
14314
|
arguments: Record<string, any>;
|
|
14316
14315
|
callID: string;
|
|
14317
14316
|
name: string;
|
|
14318
14317
|
namespace?: string;
|
|
14319
|
-
|
|
14320
|
-
content
|
|
14318
|
+
result: {
|
|
14319
|
+
content: ({
|
|
14321
14320
|
type: "text";
|
|
14322
14321
|
text: string;
|
|
14323
14322
|
textSignature?: string;
|
|
@@ -14327,8 +14326,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14327
14326
|
mimeType: string;
|
|
14328
14327
|
})[];
|
|
14329
14328
|
details?: any;
|
|
14329
|
+
isError: true;
|
|
14330
14330
|
};
|
|
14331
|
-
status: "
|
|
14331
|
+
status: "aborted";
|
|
14332
14332
|
thoughtSignature?: string;
|
|
14333
14333
|
time: {
|
|
14334
14334
|
start: number;
|
|
@@ -14522,14 +14522,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14522
14522
|
type: "image";
|
|
14523
14523
|
data: string;
|
|
14524
14524
|
mimeType: string;
|
|
14525
|
+
} | {
|
|
14526
|
+
type: "thinking";
|
|
14527
|
+
thinking: string;
|
|
14528
|
+
thinkingSignature?: string;
|
|
14529
|
+
redacted?: boolean;
|
|
14525
14530
|
} | {
|
|
14526
14531
|
addedToolNames?: string[];
|
|
14527
14532
|
arguments: Record<string, any>;
|
|
14528
14533
|
callID: string;
|
|
14529
14534
|
name: string;
|
|
14530
14535
|
namespace?: string;
|
|
14531
|
-
|
|
14532
|
-
content
|
|
14536
|
+
partial?: {
|
|
14537
|
+
content?: ({
|
|
14533
14538
|
type: "text";
|
|
14534
14539
|
text: string;
|
|
14535
14540
|
textSignature?: string;
|
|
@@ -14539,9 +14544,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14539
14544
|
mimeType: string;
|
|
14540
14545
|
})[];
|
|
14541
14546
|
details?: any;
|
|
14542
|
-
isError: false;
|
|
14543
14547
|
};
|
|
14544
|
-
status: "
|
|
14548
|
+
status: "running";
|
|
14545
14549
|
thoughtSignature?: string;
|
|
14546
14550
|
time: {
|
|
14547
14551
|
start: number;
|
|
@@ -14565,9 +14569,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14565
14569
|
mimeType: string;
|
|
14566
14570
|
})[];
|
|
14567
14571
|
details?: any;
|
|
14568
|
-
isError:
|
|
14572
|
+
isError: false;
|
|
14569
14573
|
};
|
|
14570
|
-
status: "
|
|
14574
|
+
status: "completed";
|
|
14571
14575
|
thoughtSignature?: string;
|
|
14572
14576
|
time: {
|
|
14573
14577
|
start: number;
|
|
@@ -14593,7 +14597,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14593
14597
|
details?: any;
|
|
14594
14598
|
isError: true;
|
|
14595
14599
|
};
|
|
14596
|
-
status: "
|
|
14600
|
+
status: "error";
|
|
14597
14601
|
thoughtSignature?: string;
|
|
14598
14602
|
time: {
|
|
14599
14603
|
start: number;
|
|
@@ -14619,26 +14623,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14619
14623
|
details?: any;
|
|
14620
14624
|
isError: true;
|
|
14621
14625
|
};
|
|
14622
|
-
status: "
|
|
14626
|
+
status: "skipped";
|
|
14623
14627
|
thoughtSignature?: string;
|
|
14624
14628
|
time: {
|
|
14625
14629
|
start: number;
|
|
14626
14630
|
end: number;
|
|
14627
14631
|
};
|
|
14628
14632
|
type: "toolCall";
|
|
14629
|
-
} | {
|
|
14630
|
-
type: "thinking";
|
|
14631
|
-
thinking: string;
|
|
14632
|
-
thinkingSignature?: string;
|
|
14633
|
-
redacted?: boolean;
|
|
14634
14633
|
} | {
|
|
14635
14634
|
addedToolNames?: string[];
|
|
14636
14635
|
arguments: Record<string, any>;
|
|
14637
14636
|
callID: string;
|
|
14638
14637
|
name: string;
|
|
14639
14638
|
namespace?: string;
|
|
14640
|
-
|
|
14641
|
-
content
|
|
14639
|
+
result: {
|
|
14640
|
+
content: ({
|
|
14642
14641
|
type: "text";
|
|
14643
14642
|
text: string;
|
|
14644
14643
|
textSignature?: string;
|
|
@@ -14648,8 +14647,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14648
14647
|
mimeType: string;
|
|
14649
14648
|
})[];
|
|
14650
14649
|
details?: any;
|
|
14650
|
+
isError: true;
|
|
14651
14651
|
};
|
|
14652
|
-
status: "
|
|
14652
|
+
status: "aborted";
|
|
14653
14653
|
thoughtSignature?: string;
|
|
14654
14654
|
time: {
|
|
14655
14655
|
start: number;
|
|
@@ -14824,14 +14824,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14824
14824
|
type: "image";
|
|
14825
14825
|
data: string;
|
|
14826
14826
|
mimeType: string;
|
|
14827
|
+
} | {
|
|
14828
|
+
type: "thinking";
|
|
14829
|
+
thinking: string;
|
|
14830
|
+
thinkingSignature?: string;
|
|
14831
|
+
redacted?: boolean;
|
|
14827
14832
|
} | {
|
|
14828
14833
|
addedToolNames?: string[];
|
|
14829
14834
|
arguments: Record<string, any>;
|
|
14830
14835
|
callID: string;
|
|
14831
14836
|
name: string;
|
|
14832
14837
|
namespace?: string;
|
|
14833
|
-
|
|
14834
|
-
content
|
|
14838
|
+
partial?: {
|
|
14839
|
+
content?: ({
|
|
14835
14840
|
type: "text";
|
|
14836
14841
|
text: string;
|
|
14837
14842
|
textSignature?: string;
|
|
@@ -14841,9 +14846,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14841
14846
|
mimeType: string;
|
|
14842
14847
|
})[];
|
|
14843
14848
|
details?: any;
|
|
14844
|
-
isError: false;
|
|
14845
14849
|
};
|
|
14846
|
-
status: "
|
|
14850
|
+
status: "running";
|
|
14847
14851
|
thoughtSignature?: string;
|
|
14848
14852
|
time: {
|
|
14849
14853
|
start: number;
|
|
@@ -14867,9 +14871,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14867
14871
|
mimeType: string;
|
|
14868
14872
|
})[];
|
|
14869
14873
|
details?: any;
|
|
14870
|
-
isError:
|
|
14874
|
+
isError: false;
|
|
14871
14875
|
};
|
|
14872
|
-
status: "
|
|
14876
|
+
status: "completed";
|
|
14873
14877
|
thoughtSignature?: string;
|
|
14874
14878
|
time: {
|
|
14875
14879
|
start: number;
|
|
@@ -14895,7 +14899,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14895
14899
|
details?: any;
|
|
14896
14900
|
isError: true;
|
|
14897
14901
|
};
|
|
14898
|
-
status: "
|
|
14902
|
+
status: "error";
|
|
14899
14903
|
thoughtSignature?: string;
|
|
14900
14904
|
time: {
|
|
14901
14905
|
start: number;
|
|
@@ -14921,26 +14925,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14921
14925
|
details?: any;
|
|
14922
14926
|
isError: true;
|
|
14923
14927
|
};
|
|
14924
|
-
status: "
|
|
14928
|
+
status: "skipped";
|
|
14925
14929
|
thoughtSignature?: string;
|
|
14926
14930
|
time: {
|
|
14927
14931
|
start: number;
|
|
14928
14932
|
end: number;
|
|
14929
14933
|
};
|
|
14930
14934
|
type: "toolCall";
|
|
14931
|
-
} | {
|
|
14932
|
-
type: "thinking";
|
|
14933
|
-
thinking: string;
|
|
14934
|
-
thinkingSignature?: string;
|
|
14935
|
-
redacted?: boolean;
|
|
14936
14935
|
} | {
|
|
14937
14936
|
addedToolNames?: string[];
|
|
14938
14937
|
arguments: Record<string, any>;
|
|
14939
14938
|
callID: string;
|
|
14940
14939
|
name: string;
|
|
14941
14940
|
namespace?: string;
|
|
14942
|
-
|
|
14943
|
-
content
|
|
14941
|
+
result: {
|
|
14942
|
+
content: ({
|
|
14944
14943
|
type: "text";
|
|
14945
14944
|
text: string;
|
|
14946
14945
|
textSignature?: string;
|
|
@@ -14950,8 +14949,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14950
14949
|
mimeType: string;
|
|
14951
14950
|
})[];
|
|
14952
14951
|
details?: any;
|
|
14952
|
+
isError: true;
|
|
14953
14953
|
};
|
|
14954
|
-
status: "
|
|
14954
|
+
status: "aborted";
|
|
14955
14955
|
thoughtSignature?: string;
|
|
14956
14956
|
time: {
|
|
14957
14957
|
start: number;
|
|
@@ -16674,14 +16674,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16674
16674
|
type: "image";
|
|
16675
16675
|
data: string;
|
|
16676
16676
|
mimeType: string;
|
|
16677
|
+
} | {
|
|
16678
|
+
type: "thinking";
|
|
16679
|
+
thinking: string;
|
|
16680
|
+
thinkingSignature?: string;
|
|
16681
|
+
redacted?: boolean;
|
|
16677
16682
|
} | {
|
|
16678
16683
|
addedToolNames?: string[];
|
|
16679
16684
|
arguments: Record<string, any>;
|
|
16680
16685
|
callID: string;
|
|
16681
16686
|
name: string;
|
|
16682
16687
|
namespace?: string;
|
|
16683
|
-
|
|
16684
|
-
content
|
|
16688
|
+
partial?: {
|
|
16689
|
+
content?: ({
|
|
16685
16690
|
type: "text";
|
|
16686
16691
|
text: string;
|
|
16687
16692
|
textSignature?: string;
|
|
@@ -16691,9 +16696,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16691
16696
|
mimeType: string;
|
|
16692
16697
|
})[];
|
|
16693
16698
|
details?: any;
|
|
16694
|
-
isError: false;
|
|
16695
16699
|
};
|
|
16696
|
-
status: "
|
|
16700
|
+
status: "running";
|
|
16697
16701
|
thoughtSignature?: string;
|
|
16698
16702
|
time: {
|
|
16699
16703
|
start: number;
|
|
@@ -16717,9 +16721,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16717
16721
|
mimeType: string;
|
|
16718
16722
|
})[];
|
|
16719
16723
|
details?: any;
|
|
16720
|
-
isError:
|
|
16724
|
+
isError: false;
|
|
16721
16725
|
};
|
|
16722
|
-
status: "
|
|
16726
|
+
status: "completed";
|
|
16723
16727
|
thoughtSignature?: string;
|
|
16724
16728
|
time: {
|
|
16725
16729
|
start: number;
|
|
@@ -16745,7 +16749,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16745
16749
|
details?: any;
|
|
16746
16750
|
isError: true;
|
|
16747
16751
|
};
|
|
16748
|
-
status: "
|
|
16752
|
+
status: "error";
|
|
16749
16753
|
thoughtSignature?: string;
|
|
16750
16754
|
time: {
|
|
16751
16755
|
start: number;
|
|
@@ -16771,26 +16775,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16771
16775
|
details?: any;
|
|
16772
16776
|
isError: true;
|
|
16773
16777
|
};
|
|
16774
|
-
status: "
|
|
16778
|
+
status: "skipped";
|
|
16775
16779
|
thoughtSignature?: string;
|
|
16776
16780
|
time: {
|
|
16777
16781
|
start: number;
|
|
16778
16782
|
end: number;
|
|
16779
16783
|
};
|
|
16780
16784
|
type: "toolCall";
|
|
16781
|
-
} | {
|
|
16782
|
-
type: "thinking";
|
|
16783
|
-
thinking: string;
|
|
16784
|
-
thinkingSignature?: string;
|
|
16785
|
-
redacted?: boolean;
|
|
16786
16785
|
} | {
|
|
16787
16786
|
addedToolNames?: string[];
|
|
16788
16787
|
arguments: Record<string, any>;
|
|
16789
16788
|
callID: string;
|
|
16790
16789
|
name: string;
|
|
16791
16790
|
namespace?: string;
|
|
16792
|
-
|
|
16793
|
-
content
|
|
16791
|
+
result: {
|
|
16792
|
+
content: ({
|
|
16794
16793
|
type: "text";
|
|
16795
16794
|
text: string;
|
|
16796
16795
|
textSignature?: string;
|
|
@@ -16800,8 +16799,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16800
16799
|
mimeType: string;
|
|
16801
16800
|
})[];
|
|
16802
16801
|
details?: any;
|
|
16802
|
+
isError: true;
|
|
16803
16803
|
};
|
|
16804
|
-
status: "
|
|
16804
|
+
status: "aborted";
|
|
16805
16805
|
thoughtSignature?: string;
|
|
16806
16806
|
time: {
|
|
16807
16807
|
start: number;
|
|
@@ -16976,14 +16976,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16976
16976
|
type: "image";
|
|
16977
16977
|
data: string;
|
|
16978
16978
|
mimeType: string;
|
|
16979
|
+
} | {
|
|
16980
|
+
type: "thinking";
|
|
16981
|
+
thinking: string;
|
|
16982
|
+
thinkingSignature?: string;
|
|
16983
|
+
redacted?: boolean;
|
|
16979
16984
|
} | {
|
|
16980
16985
|
addedToolNames?: string[];
|
|
16981
16986
|
arguments: Record<string, any>;
|
|
16982
16987
|
callID: string;
|
|
16983
16988
|
name: string;
|
|
16984
16989
|
namespace?: string;
|
|
16985
|
-
|
|
16986
|
-
content
|
|
16990
|
+
partial?: {
|
|
16991
|
+
content?: ({
|
|
16987
16992
|
type: "text";
|
|
16988
16993
|
text: string;
|
|
16989
16994
|
textSignature?: string;
|
|
@@ -16993,9 +16998,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16993
16998
|
mimeType: string;
|
|
16994
16999
|
})[];
|
|
16995
17000
|
details?: any;
|
|
16996
|
-
isError: false;
|
|
16997
17001
|
};
|
|
16998
|
-
status: "
|
|
17002
|
+
status: "running";
|
|
16999
17003
|
thoughtSignature?: string;
|
|
17000
17004
|
time: {
|
|
17001
17005
|
start: number;
|
|
@@ -17019,9 +17023,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17019
17023
|
mimeType: string;
|
|
17020
17024
|
})[];
|
|
17021
17025
|
details?: any;
|
|
17022
|
-
isError:
|
|
17026
|
+
isError: false;
|
|
17023
17027
|
};
|
|
17024
|
-
status: "
|
|
17028
|
+
status: "completed";
|
|
17025
17029
|
thoughtSignature?: string;
|
|
17026
17030
|
time: {
|
|
17027
17031
|
start: number;
|
|
@@ -17047,7 +17051,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17047
17051
|
details?: any;
|
|
17048
17052
|
isError: true;
|
|
17049
17053
|
};
|
|
17050
|
-
status: "
|
|
17054
|
+
status: "error";
|
|
17051
17055
|
thoughtSignature?: string;
|
|
17052
17056
|
time: {
|
|
17053
17057
|
start: number;
|
|
@@ -17073,26 +17077,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17073
17077
|
details?: any;
|
|
17074
17078
|
isError: true;
|
|
17075
17079
|
};
|
|
17076
|
-
status: "
|
|
17080
|
+
status: "skipped";
|
|
17077
17081
|
thoughtSignature?: string;
|
|
17078
17082
|
time: {
|
|
17079
17083
|
start: number;
|
|
17080
17084
|
end: number;
|
|
17081
17085
|
};
|
|
17082
17086
|
type: "toolCall";
|
|
17083
|
-
} | {
|
|
17084
|
-
type: "thinking";
|
|
17085
|
-
thinking: string;
|
|
17086
|
-
thinkingSignature?: string;
|
|
17087
|
-
redacted?: boolean;
|
|
17088
17087
|
} | {
|
|
17089
17088
|
addedToolNames?: string[];
|
|
17090
17089
|
arguments: Record<string, any>;
|
|
17091
17090
|
callID: string;
|
|
17092
17091
|
name: string;
|
|
17093
17092
|
namespace?: string;
|
|
17094
|
-
|
|
17095
|
-
content
|
|
17093
|
+
result: {
|
|
17094
|
+
content: ({
|
|
17096
17095
|
type: "text";
|
|
17097
17096
|
text: string;
|
|
17098
17097
|
textSignature?: string;
|
|
@@ -17102,8 +17101,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17102
17101
|
mimeType: string;
|
|
17103
17102
|
})[];
|
|
17104
17103
|
details?: any;
|
|
17104
|
+
isError: true;
|
|
17105
17105
|
};
|
|
17106
|
-
status: "
|
|
17106
|
+
status: "aborted";
|
|
17107
17107
|
thoughtSignature?: string;
|
|
17108
17108
|
time: {
|
|
17109
17109
|
start: number;
|
|
@@ -17296,14 +17296,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17296
17296
|
type: "image";
|
|
17297
17297
|
data: string;
|
|
17298
17298
|
mimeType: string;
|
|
17299
|
+
} | {
|
|
17300
|
+
type: "thinking";
|
|
17301
|
+
thinking: string;
|
|
17302
|
+
thinkingSignature?: string;
|
|
17303
|
+
redacted?: boolean;
|
|
17299
17304
|
} | {
|
|
17300
17305
|
addedToolNames?: string[];
|
|
17301
17306
|
arguments: Record<string, any>;
|
|
17302
17307
|
callID: string;
|
|
17303
17308
|
name: string;
|
|
17304
17309
|
namespace?: string;
|
|
17305
|
-
|
|
17306
|
-
content
|
|
17310
|
+
partial?: {
|
|
17311
|
+
content?: ({
|
|
17307
17312
|
type: "text";
|
|
17308
17313
|
text: string;
|
|
17309
17314
|
textSignature?: string;
|
|
@@ -17313,9 +17318,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17313
17318
|
mimeType: string;
|
|
17314
17319
|
})[];
|
|
17315
17320
|
details?: any;
|
|
17316
|
-
isError: false;
|
|
17317
17321
|
};
|
|
17318
|
-
status: "
|
|
17322
|
+
status: "running";
|
|
17319
17323
|
thoughtSignature?: string;
|
|
17320
17324
|
time: {
|
|
17321
17325
|
start: number;
|
|
@@ -17339,9 +17343,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17339
17343
|
mimeType: string;
|
|
17340
17344
|
})[];
|
|
17341
17345
|
details?: any;
|
|
17342
|
-
isError:
|
|
17346
|
+
isError: false;
|
|
17343
17347
|
};
|
|
17344
|
-
status: "
|
|
17348
|
+
status: "completed";
|
|
17345
17349
|
thoughtSignature?: string;
|
|
17346
17350
|
time: {
|
|
17347
17351
|
start: number;
|
|
@@ -17367,7 +17371,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17367
17371
|
details?: any;
|
|
17368
17372
|
isError: true;
|
|
17369
17373
|
};
|
|
17370
|
-
status: "
|
|
17374
|
+
status: "error";
|
|
17371
17375
|
thoughtSignature?: string;
|
|
17372
17376
|
time: {
|
|
17373
17377
|
start: number;
|
|
@@ -17393,26 +17397,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17393
17397
|
details?: any;
|
|
17394
17398
|
isError: true;
|
|
17395
17399
|
};
|
|
17396
|
-
status: "
|
|
17400
|
+
status: "skipped";
|
|
17397
17401
|
thoughtSignature?: string;
|
|
17398
17402
|
time: {
|
|
17399
17403
|
start: number;
|
|
17400
17404
|
end: number;
|
|
17401
17405
|
};
|
|
17402
17406
|
type: "toolCall";
|
|
17403
|
-
} | {
|
|
17404
|
-
type: "thinking";
|
|
17405
|
-
thinking: string;
|
|
17406
|
-
thinkingSignature?: string;
|
|
17407
|
-
redacted?: boolean;
|
|
17408
17407
|
} | {
|
|
17409
17408
|
addedToolNames?: string[];
|
|
17410
17409
|
arguments: Record<string, any>;
|
|
17411
17410
|
callID: string;
|
|
17412
17411
|
name: string;
|
|
17413
17412
|
namespace?: string;
|
|
17414
|
-
|
|
17415
|
-
content
|
|
17413
|
+
result: {
|
|
17414
|
+
content: ({
|
|
17416
17415
|
type: "text";
|
|
17417
17416
|
text: string;
|
|
17418
17417
|
textSignature?: string;
|
|
@@ -17422,8 +17421,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17422
17421
|
mimeType: string;
|
|
17423
17422
|
})[];
|
|
17424
17423
|
details?: any;
|
|
17424
|
+
isError: true;
|
|
17425
17425
|
};
|
|
17426
|
-
status: "
|
|
17426
|
+
status: "aborted";
|
|
17427
17427
|
thoughtSignature?: string;
|
|
17428
17428
|
time: {
|
|
17429
17429
|
start: number;
|
|
@@ -17598,14 +17598,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17598
17598
|
type: "image";
|
|
17599
17599
|
data: string;
|
|
17600
17600
|
mimeType: string;
|
|
17601
|
+
} | {
|
|
17602
|
+
type: "thinking";
|
|
17603
|
+
thinking: string;
|
|
17604
|
+
thinkingSignature?: string;
|
|
17605
|
+
redacted?: boolean;
|
|
17601
17606
|
} | {
|
|
17602
17607
|
addedToolNames?: string[];
|
|
17603
17608
|
arguments: Record<string, any>;
|
|
17604
17609
|
callID: string;
|
|
17605
17610
|
name: string;
|
|
17606
17611
|
namespace?: string;
|
|
17607
|
-
|
|
17608
|
-
content
|
|
17612
|
+
partial?: {
|
|
17613
|
+
content?: ({
|
|
17609
17614
|
type: "text";
|
|
17610
17615
|
text: string;
|
|
17611
17616
|
textSignature?: string;
|
|
@@ -17615,9 +17620,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17615
17620
|
mimeType: string;
|
|
17616
17621
|
})[];
|
|
17617
17622
|
details?: any;
|
|
17618
|
-
isError: false;
|
|
17619
17623
|
};
|
|
17620
|
-
status: "
|
|
17624
|
+
status: "running";
|
|
17621
17625
|
thoughtSignature?: string;
|
|
17622
17626
|
time: {
|
|
17623
17627
|
start: number;
|
|
@@ -17641,9 +17645,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17641
17645
|
mimeType: string;
|
|
17642
17646
|
})[];
|
|
17643
17647
|
details?: any;
|
|
17644
|
-
isError:
|
|
17648
|
+
isError: false;
|
|
17645
17649
|
};
|
|
17646
|
-
status: "
|
|
17650
|
+
status: "completed";
|
|
17647
17651
|
thoughtSignature?: string;
|
|
17648
17652
|
time: {
|
|
17649
17653
|
start: number;
|
|
@@ -17669,7 +17673,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17669
17673
|
details?: any;
|
|
17670
17674
|
isError: true;
|
|
17671
17675
|
};
|
|
17672
|
-
status: "
|
|
17676
|
+
status: "error";
|
|
17673
17677
|
thoughtSignature?: string;
|
|
17674
17678
|
time: {
|
|
17675
17679
|
start: number;
|
|
@@ -17695,26 +17699,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17695
17699
|
details?: any;
|
|
17696
17700
|
isError: true;
|
|
17697
17701
|
};
|
|
17698
|
-
status: "
|
|
17702
|
+
status: "skipped";
|
|
17699
17703
|
thoughtSignature?: string;
|
|
17700
17704
|
time: {
|
|
17701
17705
|
start: number;
|
|
17702
17706
|
end: number;
|
|
17703
17707
|
};
|
|
17704
17708
|
type: "toolCall";
|
|
17705
|
-
} | {
|
|
17706
|
-
type: "thinking";
|
|
17707
|
-
thinking: string;
|
|
17708
|
-
thinkingSignature?: string;
|
|
17709
|
-
redacted?: boolean;
|
|
17710
17709
|
} | {
|
|
17711
17710
|
addedToolNames?: string[];
|
|
17712
17711
|
arguments: Record<string, any>;
|
|
17713
17712
|
callID: string;
|
|
17714
17713
|
name: string;
|
|
17715
17714
|
namespace?: string;
|
|
17716
|
-
|
|
17717
|
-
content
|
|
17715
|
+
result: {
|
|
17716
|
+
content: ({
|
|
17718
17717
|
type: "text";
|
|
17719
17718
|
text: string;
|
|
17720
17719
|
textSignature?: string;
|
|
@@ -17724,8 +17723,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17724
17723
|
mimeType: string;
|
|
17725
17724
|
})[];
|
|
17726
17725
|
details?: any;
|
|
17726
|
+
isError: true;
|
|
17727
17727
|
};
|
|
17728
|
-
status: "
|
|
17728
|
+
status: "aborted";
|
|
17729
17729
|
thoughtSignature?: string;
|
|
17730
17730
|
time: {
|
|
17731
17731
|
start: number;
|
|
@@ -18206,14 +18206,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18206
18206
|
type: "image";
|
|
18207
18207
|
data: string;
|
|
18208
18208
|
mimeType: string;
|
|
18209
|
+
} | {
|
|
18210
|
+
type: "thinking";
|
|
18211
|
+
thinking: string;
|
|
18212
|
+
thinkingSignature?: string;
|
|
18213
|
+
redacted?: boolean;
|
|
18209
18214
|
} | {
|
|
18210
18215
|
addedToolNames?: string[];
|
|
18211
18216
|
arguments: Record<string, any>;
|
|
18212
18217
|
callID: string;
|
|
18213
18218
|
name: string;
|
|
18214
18219
|
namespace?: string;
|
|
18215
|
-
|
|
18216
|
-
content
|
|
18220
|
+
partial?: {
|
|
18221
|
+
content?: ({
|
|
18217
18222
|
type: "text";
|
|
18218
18223
|
text: string;
|
|
18219
18224
|
textSignature?: string;
|
|
@@ -18223,9 +18228,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18223
18228
|
mimeType: string;
|
|
18224
18229
|
})[];
|
|
18225
18230
|
details?: any;
|
|
18226
|
-
isError: false;
|
|
18227
18231
|
};
|
|
18228
|
-
status: "
|
|
18232
|
+
status: "running";
|
|
18229
18233
|
thoughtSignature?: string;
|
|
18230
18234
|
time: {
|
|
18231
18235
|
start: number;
|
|
@@ -18249,9 +18253,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18249
18253
|
mimeType: string;
|
|
18250
18254
|
})[];
|
|
18251
18255
|
details?: any;
|
|
18252
|
-
isError:
|
|
18256
|
+
isError: false;
|
|
18253
18257
|
};
|
|
18254
|
-
status: "
|
|
18258
|
+
status: "completed";
|
|
18255
18259
|
thoughtSignature?: string;
|
|
18256
18260
|
time: {
|
|
18257
18261
|
start: number;
|
|
@@ -18277,7 +18281,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18277
18281
|
details?: any;
|
|
18278
18282
|
isError: true;
|
|
18279
18283
|
};
|
|
18280
|
-
status: "
|
|
18284
|
+
status: "error";
|
|
18281
18285
|
thoughtSignature?: string;
|
|
18282
18286
|
time: {
|
|
18283
18287
|
start: number;
|
|
@@ -18303,26 +18307,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18303
18307
|
details?: any;
|
|
18304
18308
|
isError: true;
|
|
18305
18309
|
};
|
|
18306
|
-
status: "
|
|
18310
|
+
status: "skipped";
|
|
18307
18311
|
thoughtSignature?: string;
|
|
18308
18312
|
time: {
|
|
18309
18313
|
start: number;
|
|
18310
18314
|
end: number;
|
|
18311
18315
|
};
|
|
18312
18316
|
type: "toolCall";
|
|
18313
|
-
} | {
|
|
18314
|
-
type: "thinking";
|
|
18315
|
-
thinking: string;
|
|
18316
|
-
thinkingSignature?: string;
|
|
18317
|
-
redacted?: boolean;
|
|
18318
18317
|
} | {
|
|
18319
18318
|
addedToolNames?: string[];
|
|
18320
18319
|
arguments: Record<string, any>;
|
|
18321
18320
|
callID: string;
|
|
18322
18321
|
name: string;
|
|
18323
18322
|
namespace?: string;
|
|
18324
|
-
|
|
18325
|
-
content
|
|
18323
|
+
result: {
|
|
18324
|
+
content: ({
|
|
18326
18325
|
type: "text";
|
|
18327
18326
|
text: string;
|
|
18328
18327
|
textSignature?: string;
|
|
@@ -18332,8 +18331,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18332
18331
|
mimeType: string;
|
|
18333
18332
|
})[];
|
|
18334
18333
|
details?: any;
|
|
18334
|
+
isError: true;
|
|
18335
18335
|
};
|
|
18336
|
-
status: "
|
|
18336
|
+
status: "aborted";
|
|
18337
18337
|
thoughtSignature?: string;
|
|
18338
18338
|
time: {
|
|
18339
18339
|
start: number;
|
|
@@ -18508,14 +18508,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18508
18508
|
type: "image";
|
|
18509
18509
|
data: string;
|
|
18510
18510
|
mimeType: string;
|
|
18511
|
+
} | {
|
|
18512
|
+
type: "thinking";
|
|
18513
|
+
thinking: string;
|
|
18514
|
+
thinkingSignature?: string;
|
|
18515
|
+
redacted?: boolean;
|
|
18511
18516
|
} | {
|
|
18512
18517
|
addedToolNames?: string[];
|
|
18513
18518
|
arguments: Record<string, any>;
|
|
18514
18519
|
callID: string;
|
|
18515
18520
|
name: string;
|
|
18516
18521
|
namespace?: string;
|
|
18517
|
-
|
|
18518
|
-
content
|
|
18522
|
+
partial?: {
|
|
18523
|
+
content?: ({
|
|
18519
18524
|
type: "text";
|
|
18520
18525
|
text: string;
|
|
18521
18526
|
textSignature?: string;
|
|
@@ -18525,9 +18530,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18525
18530
|
mimeType: string;
|
|
18526
18531
|
})[];
|
|
18527
18532
|
details?: any;
|
|
18528
|
-
isError: false;
|
|
18529
18533
|
};
|
|
18530
|
-
status: "
|
|
18534
|
+
status: "running";
|
|
18531
18535
|
thoughtSignature?: string;
|
|
18532
18536
|
time: {
|
|
18533
18537
|
start: number;
|
|
@@ -18551,9 +18555,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18551
18555
|
mimeType: string;
|
|
18552
18556
|
})[];
|
|
18553
18557
|
details?: any;
|
|
18554
|
-
isError:
|
|
18558
|
+
isError: false;
|
|
18555
18559
|
};
|
|
18556
|
-
status: "
|
|
18560
|
+
status: "completed";
|
|
18557
18561
|
thoughtSignature?: string;
|
|
18558
18562
|
time: {
|
|
18559
18563
|
start: number;
|
|
@@ -18579,7 +18583,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18579
18583
|
details?: any;
|
|
18580
18584
|
isError: true;
|
|
18581
18585
|
};
|
|
18582
|
-
status: "
|
|
18586
|
+
status: "error";
|
|
18583
18587
|
thoughtSignature?: string;
|
|
18584
18588
|
time: {
|
|
18585
18589
|
start: number;
|
|
@@ -18605,26 +18609,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18605
18609
|
details?: any;
|
|
18606
18610
|
isError: true;
|
|
18607
18611
|
};
|
|
18608
|
-
status: "
|
|
18612
|
+
status: "skipped";
|
|
18609
18613
|
thoughtSignature?: string;
|
|
18610
18614
|
time: {
|
|
18611
18615
|
start: number;
|
|
18612
18616
|
end: number;
|
|
18613
18617
|
};
|
|
18614
18618
|
type: "toolCall";
|
|
18615
|
-
} | {
|
|
18616
|
-
type: "thinking";
|
|
18617
|
-
thinking: string;
|
|
18618
|
-
thinkingSignature?: string;
|
|
18619
|
-
redacted?: boolean;
|
|
18620
18619
|
} | {
|
|
18621
18620
|
addedToolNames?: string[];
|
|
18622
18621
|
arguments: Record<string, any>;
|
|
18623
18622
|
callID: string;
|
|
18624
18623
|
name: string;
|
|
18625
18624
|
namespace?: string;
|
|
18626
|
-
|
|
18627
|
-
content
|
|
18625
|
+
result: {
|
|
18626
|
+
content: ({
|
|
18628
18627
|
type: "text";
|
|
18629
18628
|
text: string;
|
|
18630
18629
|
textSignature?: string;
|
|
@@ -18634,8 +18633,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18634
18633
|
mimeType: string;
|
|
18635
18634
|
})[];
|
|
18636
18635
|
details?: any;
|
|
18636
|
+
isError: true;
|
|
18637
18637
|
};
|
|
18638
|
-
status: "
|
|
18638
|
+
status: "aborted";
|
|
18639
18639
|
thoughtSignature?: string;
|
|
18640
18640
|
time: {
|
|
18641
18641
|
start: number;
|
|
@@ -18829,14 +18829,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18829
18829
|
type: "image";
|
|
18830
18830
|
data: string;
|
|
18831
18831
|
mimeType: string;
|
|
18832
|
+
} | {
|
|
18833
|
+
type: "thinking";
|
|
18834
|
+
thinking: string;
|
|
18835
|
+
thinkingSignature?: string;
|
|
18836
|
+
redacted?: boolean;
|
|
18832
18837
|
} | {
|
|
18833
18838
|
addedToolNames?: string[];
|
|
18834
18839
|
arguments: Record<string, any>;
|
|
18835
18840
|
callID: string;
|
|
18836
18841
|
name: string;
|
|
18837
18842
|
namespace?: string;
|
|
18838
|
-
|
|
18839
|
-
content
|
|
18843
|
+
partial?: {
|
|
18844
|
+
content?: ({
|
|
18840
18845
|
type: "text";
|
|
18841
18846
|
text: string;
|
|
18842
18847
|
textSignature?: string;
|
|
@@ -18846,9 +18851,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18846
18851
|
mimeType: string;
|
|
18847
18852
|
})[];
|
|
18848
18853
|
details?: any;
|
|
18849
|
-
isError: false;
|
|
18850
18854
|
};
|
|
18851
|
-
status: "
|
|
18855
|
+
status: "running";
|
|
18852
18856
|
thoughtSignature?: string;
|
|
18853
18857
|
time: {
|
|
18854
18858
|
start: number;
|
|
@@ -18872,9 +18876,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18872
18876
|
mimeType: string;
|
|
18873
18877
|
})[];
|
|
18874
18878
|
details?: any;
|
|
18875
|
-
isError:
|
|
18879
|
+
isError: false;
|
|
18876
18880
|
};
|
|
18877
|
-
status: "
|
|
18881
|
+
status: "completed";
|
|
18878
18882
|
thoughtSignature?: string;
|
|
18879
18883
|
time: {
|
|
18880
18884
|
start: number;
|
|
@@ -18900,7 +18904,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18900
18904
|
details?: any;
|
|
18901
18905
|
isError: true;
|
|
18902
18906
|
};
|
|
18903
|
-
status: "
|
|
18907
|
+
status: "error";
|
|
18904
18908
|
thoughtSignature?: string;
|
|
18905
18909
|
time: {
|
|
18906
18910
|
start: number;
|
|
@@ -18926,26 +18930,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18926
18930
|
details?: any;
|
|
18927
18931
|
isError: true;
|
|
18928
18932
|
};
|
|
18929
|
-
status: "
|
|
18933
|
+
status: "skipped";
|
|
18930
18934
|
thoughtSignature?: string;
|
|
18931
18935
|
time: {
|
|
18932
18936
|
start: number;
|
|
18933
18937
|
end: number;
|
|
18934
18938
|
};
|
|
18935
18939
|
type: "toolCall";
|
|
18936
|
-
} | {
|
|
18937
|
-
type: "thinking";
|
|
18938
|
-
thinking: string;
|
|
18939
|
-
thinkingSignature?: string;
|
|
18940
|
-
redacted?: boolean;
|
|
18941
18940
|
} | {
|
|
18942
18941
|
addedToolNames?: string[];
|
|
18943
18942
|
arguments: Record<string, any>;
|
|
18944
18943
|
callID: string;
|
|
18945
18944
|
name: string;
|
|
18946
18945
|
namespace?: string;
|
|
18947
|
-
|
|
18948
|
-
content
|
|
18946
|
+
result: {
|
|
18947
|
+
content: ({
|
|
18949
18948
|
type: "text";
|
|
18950
18949
|
text: string;
|
|
18951
18950
|
textSignature?: string;
|
|
@@ -18955,8 +18954,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18955
18954
|
mimeType: string;
|
|
18956
18955
|
})[];
|
|
18957
18956
|
details?: any;
|
|
18957
|
+
isError: true;
|
|
18958
18958
|
};
|
|
18959
|
-
status: "
|
|
18959
|
+
status: "aborted";
|
|
18960
18960
|
thoughtSignature?: string;
|
|
18961
18961
|
time: {
|
|
18962
18962
|
start: number;
|
|
@@ -19131,14 +19131,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19131
19131
|
type: "image";
|
|
19132
19132
|
data: string;
|
|
19133
19133
|
mimeType: string;
|
|
19134
|
+
} | {
|
|
19135
|
+
type: "thinking";
|
|
19136
|
+
thinking: string;
|
|
19137
|
+
thinkingSignature?: string;
|
|
19138
|
+
redacted?: boolean;
|
|
19134
19139
|
} | {
|
|
19135
19140
|
addedToolNames?: string[];
|
|
19136
19141
|
arguments: Record<string, any>;
|
|
19137
19142
|
callID: string;
|
|
19138
19143
|
name: string;
|
|
19139
19144
|
namespace?: string;
|
|
19140
|
-
|
|
19141
|
-
content
|
|
19145
|
+
partial?: {
|
|
19146
|
+
content?: ({
|
|
19142
19147
|
type: "text";
|
|
19143
19148
|
text: string;
|
|
19144
19149
|
textSignature?: string;
|
|
@@ -19148,9 +19153,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19148
19153
|
mimeType: string;
|
|
19149
19154
|
})[];
|
|
19150
19155
|
details?: any;
|
|
19151
|
-
isError: false;
|
|
19152
19156
|
};
|
|
19153
|
-
status: "
|
|
19157
|
+
status: "running";
|
|
19154
19158
|
thoughtSignature?: string;
|
|
19155
19159
|
time: {
|
|
19156
19160
|
start: number;
|
|
@@ -19174,9 +19178,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19174
19178
|
mimeType: string;
|
|
19175
19179
|
})[];
|
|
19176
19180
|
details?: any;
|
|
19177
|
-
isError:
|
|
19181
|
+
isError: false;
|
|
19178
19182
|
};
|
|
19179
|
-
status: "
|
|
19183
|
+
status: "completed";
|
|
19180
19184
|
thoughtSignature?: string;
|
|
19181
19185
|
time: {
|
|
19182
19186
|
start: number;
|
|
@@ -19202,7 +19206,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19202
19206
|
details?: any;
|
|
19203
19207
|
isError: true;
|
|
19204
19208
|
};
|
|
19205
|
-
status: "
|
|
19209
|
+
status: "error";
|
|
19206
19210
|
thoughtSignature?: string;
|
|
19207
19211
|
time: {
|
|
19208
19212
|
start: number;
|
|
@@ -19228,26 +19232,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19228
19232
|
details?: any;
|
|
19229
19233
|
isError: true;
|
|
19230
19234
|
};
|
|
19231
|
-
status: "
|
|
19235
|
+
status: "skipped";
|
|
19232
19236
|
thoughtSignature?: string;
|
|
19233
19237
|
time: {
|
|
19234
19238
|
start: number;
|
|
19235
19239
|
end: number;
|
|
19236
19240
|
};
|
|
19237
19241
|
type: "toolCall";
|
|
19238
|
-
} | {
|
|
19239
|
-
type: "thinking";
|
|
19240
|
-
thinking: string;
|
|
19241
|
-
thinkingSignature?: string;
|
|
19242
|
-
redacted?: boolean;
|
|
19243
19242
|
} | {
|
|
19244
19243
|
addedToolNames?: string[];
|
|
19245
19244
|
arguments: Record<string, any>;
|
|
19246
19245
|
callID: string;
|
|
19247
19246
|
name: string;
|
|
19248
19247
|
namespace?: string;
|
|
19249
|
-
|
|
19250
|
-
content
|
|
19248
|
+
result: {
|
|
19249
|
+
content: ({
|
|
19251
19250
|
type: "text";
|
|
19252
19251
|
text: string;
|
|
19253
19252
|
textSignature?: string;
|
|
@@ -19257,8 +19256,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19257
19256
|
mimeType: string;
|
|
19258
19257
|
})[];
|
|
19259
19258
|
details?: any;
|
|
19259
|
+
isError: true;
|
|
19260
19260
|
};
|
|
19261
|
-
status: "
|
|
19261
|
+
status: "aborted";
|
|
19262
19262
|
thoughtSignature?: string;
|
|
19263
19263
|
time: {
|
|
19264
19264
|
start: number;
|
|
@@ -19461,14 +19461,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19461
19461
|
type: "image";
|
|
19462
19462
|
data: string;
|
|
19463
19463
|
mimeType: string;
|
|
19464
|
+
} | {
|
|
19465
|
+
type: "thinking";
|
|
19466
|
+
thinking: string;
|
|
19467
|
+
thinkingSignature?: string;
|
|
19468
|
+
redacted?: boolean;
|
|
19464
19469
|
} | {
|
|
19465
19470
|
addedToolNames?: string[];
|
|
19466
19471
|
arguments: Record<string, any>;
|
|
19467
19472
|
callID: string;
|
|
19468
19473
|
name: string;
|
|
19469
19474
|
namespace?: string;
|
|
19470
|
-
|
|
19471
|
-
content
|
|
19475
|
+
partial?: {
|
|
19476
|
+
content?: ({
|
|
19472
19477
|
type: "text";
|
|
19473
19478
|
text: string;
|
|
19474
19479
|
textSignature?: string;
|
|
@@ -19478,9 +19483,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19478
19483
|
mimeType: string;
|
|
19479
19484
|
})[];
|
|
19480
19485
|
details?: any;
|
|
19481
|
-
isError: false;
|
|
19482
19486
|
};
|
|
19483
|
-
status: "
|
|
19487
|
+
status: "running";
|
|
19484
19488
|
thoughtSignature?: string;
|
|
19485
19489
|
time: {
|
|
19486
19490
|
start: number;
|
|
@@ -19504,9 +19508,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19504
19508
|
mimeType: string;
|
|
19505
19509
|
})[];
|
|
19506
19510
|
details?: any;
|
|
19507
|
-
isError:
|
|
19511
|
+
isError: false;
|
|
19508
19512
|
};
|
|
19509
|
-
status: "
|
|
19513
|
+
status: "completed";
|
|
19510
19514
|
thoughtSignature?: string;
|
|
19511
19515
|
time: {
|
|
19512
19516
|
start: number;
|
|
@@ -19532,7 +19536,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19532
19536
|
details?: any;
|
|
19533
19537
|
isError: true;
|
|
19534
19538
|
};
|
|
19535
|
-
status: "
|
|
19539
|
+
status: "error";
|
|
19536
19540
|
thoughtSignature?: string;
|
|
19537
19541
|
time: {
|
|
19538
19542
|
start: number;
|
|
@@ -19558,26 +19562,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19558
19562
|
details?: any;
|
|
19559
19563
|
isError: true;
|
|
19560
19564
|
};
|
|
19561
|
-
status: "
|
|
19565
|
+
status: "skipped";
|
|
19562
19566
|
thoughtSignature?: string;
|
|
19563
19567
|
time: {
|
|
19564
19568
|
start: number;
|
|
19565
19569
|
end: number;
|
|
19566
19570
|
};
|
|
19567
19571
|
type: "toolCall";
|
|
19568
|
-
} | {
|
|
19569
|
-
type: "thinking";
|
|
19570
|
-
thinking: string;
|
|
19571
|
-
thinkingSignature?: string;
|
|
19572
|
-
redacted?: boolean;
|
|
19573
19572
|
} | {
|
|
19574
19573
|
addedToolNames?: string[];
|
|
19575
19574
|
arguments: Record<string, any>;
|
|
19576
19575
|
callID: string;
|
|
19577
19576
|
name: string;
|
|
19578
19577
|
namespace?: string;
|
|
19579
|
-
|
|
19580
|
-
content
|
|
19578
|
+
result: {
|
|
19579
|
+
content: ({
|
|
19581
19580
|
type: "text";
|
|
19582
19581
|
text: string;
|
|
19583
19582
|
textSignature?: string;
|
|
@@ -19587,8 +19586,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19587
19586
|
mimeType: string;
|
|
19588
19587
|
})[];
|
|
19589
19588
|
details?: any;
|
|
19589
|
+
isError: true;
|
|
19590
19590
|
};
|
|
19591
|
-
status: "
|
|
19591
|
+
status: "aborted";
|
|
19592
19592
|
thoughtSignature?: string;
|
|
19593
19593
|
time: {
|
|
19594
19594
|
start: number;
|
|
@@ -19763,14 +19763,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19763
19763
|
type: "image";
|
|
19764
19764
|
data: string;
|
|
19765
19765
|
mimeType: string;
|
|
19766
|
+
} | {
|
|
19767
|
+
type: "thinking";
|
|
19768
|
+
thinking: string;
|
|
19769
|
+
thinkingSignature?: string;
|
|
19770
|
+
redacted?: boolean;
|
|
19766
19771
|
} | {
|
|
19767
19772
|
addedToolNames?: string[];
|
|
19768
19773
|
arguments: Record<string, any>;
|
|
19769
19774
|
callID: string;
|
|
19770
19775
|
name: string;
|
|
19771
19776
|
namespace?: string;
|
|
19772
|
-
|
|
19773
|
-
content
|
|
19777
|
+
partial?: {
|
|
19778
|
+
content?: ({
|
|
19774
19779
|
type: "text";
|
|
19775
19780
|
text: string;
|
|
19776
19781
|
textSignature?: string;
|
|
@@ -19780,9 +19785,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19780
19785
|
mimeType: string;
|
|
19781
19786
|
})[];
|
|
19782
19787
|
details?: any;
|
|
19783
|
-
isError: false;
|
|
19784
19788
|
};
|
|
19785
|
-
status: "
|
|
19789
|
+
status: "running";
|
|
19786
19790
|
thoughtSignature?: string;
|
|
19787
19791
|
time: {
|
|
19788
19792
|
start: number;
|
|
@@ -19806,9 +19810,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19806
19810
|
mimeType: string;
|
|
19807
19811
|
})[];
|
|
19808
19812
|
details?: any;
|
|
19809
|
-
isError:
|
|
19813
|
+
isError: false;
|
|
19810
19814
|
};
|
|
19811
|
-
status: "
|
|
19815
|
+
status: "completed";
|
|
19812
19816
|
thoughtSignature?: string;
|
|
19813
19817
|
time: {
|
|
19814
19818
|
start: number;
|
|
@@ -19834,7 +19838,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19834
19838
|
details?: any;
|
|
19835
19839
|
isError: true;
|
|
19836
19840
|
};
|
|
19837
|
-
status: "
|
|
19841
|
+
status: "error";
|
|
19838
19842
|
thoughtSignature?: string;
|
|
19839
19843
|
time: {
|
|
19840
19844
|
start: number;
|
|
@@ -19860,26 +19864,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19860
19864
|
details?: any;
|
|
19861
19865
|
isError: true;
|
|
19862
19866
|
};
|
|
19863
|
-
status: "
|
|
19867
|
+
status: "skipped";
|
|
19864
19868
|
thoughtSignature?: string;
|
|
19865
19869
|
time: {
|
|
19866
19870
|
start: number;
|
|
19867
19871
|
end: number;
|
|
19868
19872
|
};
|
|
19869
19873
|
type: "toolCall";
|
|
19870
|
-
} | {
|
|
19871
|
-
type: "thinking";
|
|
19872
|
-
thinking: string;
|
|
19873
|
-
thinkingSignature?: string;
|
|
19874
|
-
redacted?: boolean;
|
|
19875
19874
|
} | {
|
|
19876
19875
|
addedToolNames?: string[];
|
|
19877
19876
|
arguments: Record<string, any>;
|
|
19878
19877
|
callID: string;
|
|
19879
19878
|
name: string;
|
|
19880
19879
|
namespace?: string;
|
|
19881
|
-
|
|
19882
|
-
content
|
|
19880
|
+
result: {
|
|
19881
|
+
content: ({
|
|
19883
19882
|
type: "text";
|
|
19884
19883
|
text: string;
|
|
19885
19884
|
textSignature?: string;
|
|
@@ -19889,8 +19888,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19889
19888
|
mimeType: string;
|
|
19890
19889
|
})[];
|
|
19891
19890
|
details?: any;
|
|
19891
|
+
isError: true;
|
|
19892
19892
|
};
|
|
19893
|
-
status: "
|
|
19893
|
+
status: "aborted";
|
|
19894
19894
|
thoughtSignature?: string;
|
|
19895
19895
|
time: {
|
|
19896
19896
|
start: number;
|
|
@@ -20084,14 +20084,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20084
20084
|
type: "image";
|
|
20085
20085
|
data: string;
|
|
20086
20086
|
mimeType: string;
|
|
20087
|
+
} | {
|
|
20088
|
+
type: "thinking";
|
|
20089
|
+
thinking: string;
|
|
20090
|
+
thinkingSignature?: string;
|
|
20091
|
+
redacted?: boolean;
|
|
20087
20092
|
} | {
|
|
20088
20093
|
addedToolNames?: string[];
|
|
20089
20094
|
arguments: Record<string, any>;
|
|
20090
20095
|
callID: string;
|
|
20091
20096
|
name: string;
|
|
20092
20097
|
namespace?: string;
|
|
20093
|
-
|
|
20094
|
-
content
|
|
20098
|
+
partial?: {
|
|
20099
|
+
content?: ({
|
|
20095
20100
|
type: "text";
|
|
20096
20101
|
text: string;
|
|
20097
20102
|
textSignature?: string;
|
|
@@ -20101,9 +20106,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20101
20106
|
mimeType: string;
|
|
20102
20107
|
})[];
|
|
20103
20108
|
details?: any;
|
|
20104
|
-
isError: false;
|
|
20105
20109
|
};
|
|
20106
|
-
status: "
|
|
20110
|
+
status: "running";
|
|
20107
20111
|
thoughtSignature?: string;
|
|
20108
20112
|
time: {
|
|
20109
20113
|
start: number;
|
|
@@ -20127,9 +20131,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20127
20131
|
mimeType: string;
|
|
20128
20132
|
})[];
|
|
20129
20133
|
details?: any;
|
|
20130
|
-
isError:
|
|
20134
|
+
isError: false;
|
|
20131
20135
|
};
|
|
20132
|
-
status: "
|
|
20136
|
+
status: "completed";
|
|
20133
20137
|
thoughtSignature?: string;
|
|
20134
20138
|
time: {
|
|
20135
20139
|
start: number;
|
|
@@ -20155,7 +20159,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20155
20159
|
details?: any;
|
|
20156
20160
|
isError: true;
|
|
20157
20161
|
};
|
|
20158
|
-
status: "
|
|
20162
|
+
status: "error";
|
|
20159
20163
|
thoughtSignature?: string;
|
|
20160
20164
|
time: {
|
|
20161
20165
|
start: number;
|
|
@@ -20181,26 +20185,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20181
20185
|
details?: any;
|
|
20182
20186
|
isError: true;
|
|
20183
20187
|
};
|
|
20184
|
-
status: "
|
|
20188
|
+
status: "skipped";
|
|
20185
20189
|
thoughtSignature?: string;
|
|
20186
20190
|
time: {
|
|
20187
20191
|
start: number;
|
|
20188
20192
|
end: number;
|
|
20189
20193
|
};
|
|
20190
20194
|
type: "toolCall";
|
|
20191
|
-
} | {
|
|
20192
|
-
type: "thinking";
|
|
20193
|
-
thinking: string;
|
|
20194
|
-
thinkingSignature?: string;
|
|
20195
|
-
redacted?: boolean;
|
|
20196
20195
|
} | {
|
|
20197
20196
|
addedToolNames?: string[];
|
|
20198
20197
|
arguments: Record<string, any>;
|
|
20199
20198
|
callID: string;
|
|
20200
20199
|
name: string;
|
|
20201
20200
|
namespace?: string;
|
|
20202
|
-
|
|
20203
|
-
content
|
|
20201
|
+
result: {
|
|
20202
|
+
content: ({
|
|
20204
20203
|
type: "text";
|
|
20205
20204
|
text: string;
|
|
20206
20205
|
textSignature?: string;
|
|
@@ -20210,8 +20209,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20210
20209
|
mimeType: string;
|
|
20211
20210
|
})[];
|
|
20212
20211
|
details?: any;
|
|
20212
|
+
isError: true;
|
|
20213
20213
|
};
|
|
20214
|
-
status: "
|
|
20214
|
+
status: "aborted";
|
|
20215
20215
|
thoughtSignature?: string;
|
|
20216
20216
|
time: {
|
|
20217
20217
|
start: number;
|
|
@@ -20386,14 +20386,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20386
20386
|
type: "image";
|
|
20387
20387
|
data: string;
|
|
20388
20388
|
mimeType: string;
|
|
20389
|
+
} | {
|
|
20390
|
+
type: "thinking";
|
|
20391
|
+
thinking: string;
|
|
20392
|
+
thinkingSignature?: string;
|
|
20393
|
+
redacted?: boolean;
|
|
20389
20394
|
} | {
|
|
20390
20395
|
addedToolNames?: string[];
|
|
20391
20396
|
arguments: Record<string, any>;
|
|
20392
20397
|
callID: string;
|
|
20393
20398
|
name: string;
|
|
20394
20399
|
namespace?: string;
|
|
20395
|
-
|
|
20396
|
-
content
|
|
20400
|
+
partial?: {
|
|
20401
|
+
content?: ({
|
|
20397
20402
|
type: "text";
|
|
20398
20403
|
text: string;
|
|
20399
20404
|
textSignature?: string;
|
|
@@ -20403,9 +20408,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20403
20408
|
mimeType: string;
|
|
20404
20409
|
})[];
|
|
20405
20410
|
details?: any;
|
|
20406
|
-
isError: false;
|
|
20407
20411
|
};
|
|
20408
|
-
status: "
|
|
20412
|
+
status: "running";
|
|
20409
20413
|
thoughtSignature?: string;
|
|
20410
20414
|
time: {
|
|
20411
20415
|
start: number;
|
|
@@ -20429,9 +20433,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20429
20433
|
mimeType: string;
|
|
20430
20434
|
})[];
|
|
20431
20435
|
details?: any;
|
|
20432
|
-
isError:
|
|
20436
|
+
isError: false;
|
|
20433
20437
|
};
|
|
20434
|
-
status: "
|
|
20438
|
+
status: "completed";
|
|
20435
20439
|
thoughtSignature?: string;
|
|
20436
20440
|
time: {
|
|
20437
20441
|
start: number;
|
|
@@ -20457,7 +20461,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20457
20461
|
details?: any;
|
|
20458
20462
|
isError: true;
|
|
20459
20463
|
};
|
|
20460
|
-
status: "
|
|
20464
|
+
status: "error";
|
|
20461
20465
|
thoughtSignature?: string;
|
|
20462
20466
|
time: {
|
|
20463
20467
|
start: number;
|
|
@@ -20483,26 +20487,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20483
20487
|
details?: any;
|
|
20484
20488
|
isError: true;
|
|
20485
20489
|
};
|
|
20486
|
-
status: "
|
|
20490
|
+
status: "skipped";
|
|
20487
20491
|
thoughtSignature?: string;
|
|
20488
20492
|
time: {
|
|
20489
20493
|
start: number;
|
|
20490
20494
|
end: number;
|
|
20491
20495
|
};
|
|
20492
20496
|
type: "toolCall";
|
|
20493
|
-
} | {
|
|
20494
|
-
type: "thinking";
|
|
20495
|
-
thinking: string;
|
|
20496
|
-
thinkingSignature?: string;
|
|
20497
|
-
redacted?: boolean;
|
|
20498
20497
|
} | {
|
|
20499
20498
|
addedToolNames?: string[];
|
|
20500
20499
|
arguments: Record<string, any>;
|
|
20501
20500
|
callID: string;
|
|
20502
20501
|
name: string;
|
|
20503
20502
|
namespace?: string;
|
|
20504
|
-
|
|
20505
|
-
content
|
|
20503
|
+
result: {
|
|
20504
|
+
content: ({
|
|
20506
20505
|
type: "text";
|
|
20507
20506
|
text: string;
|
|
20508
20507
|
textSignature?: string;
|
|
@@ -20512,8 +20511,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
20512
20511
|
mimeType: string;
|
|
20513
20512
|
})[];
|
|
20514
20513
|
details?: any;
|
|
20514
|
+
isError: true;
|
|
20515
20515
|
};
|
|
20516
|
-
status: "
|
|
20516
|
+
status: "aborted";
|
|
20517
20517
|
thoughtSignature?: string;
|
|
20518
20518
|
time: {
|
|
20519
20519
|
start: number;
|
|
@@ -21915,14 +21915,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21915
21915
|
type: "image";
|
|
21916
21916
|
data: string;
|
|
21917
21917
|
mimeType: string;
|
|
21918
|
+
} | {
|
|
21919
|
+
type: "thinking";
|
|
21920
|
+
thinking: string;
|
|
21921
|
+
thinkingSignature?: string;
|
|
21922
|
+
redacted?: boolean;
|
|
21918
21923
|
} | {
|
|
21919
21924
|
addedToolNames?: string[];
|
|
21920
21925
|
arguments: Record<string, any>;
|
|
21921
21926
|
callID: string;
|
|
21922
21927
|
name: string;
|
|
21923
21928
|
namespace?: string;
|
|
21924
|
-
|
|
21925
|
-
content
|
|
21929
|
+
partial?: {
|
|
21930
|
+
content?: ({
|
|
21926
21931
|
type: "text";
|
|
21927
21932
|
text: string;
|
|
21928
21933
|
textSignature?: string;
|
|
@@ -21932,9 +21937,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21932
21937
|
mimeType: string;
|
|
21933
21938
|
})[];
|
|
21934
21939
|
details?: any;
|
|
21935
|
-
isError: false;
|
|
21936
21940
|
};
|
|
21937
|
-
status: "
|
|
21941
|
+
status: "running";
|
|
21938
21942
|
thoughtSignature?: string;
|
|
21939
21943
|
time: {
|
|
21940
21944
|
start: number;
|
|
@@ -21958,9 +21962,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21958
21962
|
mimeType: string;
|
|
21959
21963
|
})[];
|
|
21960
21964
|
details?: any;
|
|
21961
|
-
isError:
|
|
21965
|
+
isError: false;
|
|
21962
21966
|
};
|
|
21963
|
-
status: "
|
|
21967
|
+
status: "completed";
|
|
21964
21968
|
thoughtSignature?: string;
|
|
21965
21969
|
time: {
|
|
21966
21970
|
start: number;
|
|
@@ -21986,7 +21990,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21986
21990
|
details?: any;
|
|
21987
21991
|
isError: true;
|
|
21988
21992
|
};
|
|
21989
|
-
status: "
|
|
21993
|
+
status: "error";
|
|
21990
21994
|
thoughtSignature?: string;
|
|
21991
21995
|
time: {
|
|
21992
21996
|
start: number;
|
|
@@ -22012,26 +22016,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22012
22016
|
details?: any;
|
|
22013
22017
|
isError: true;
|
|
22014
22018
|
};
|
|
22015
|
-
status: "
|
|
22019
|
+
status: "skipped";
|
|
22016
22020
|
thoughtSignature?: string;
|
|
22017
22021
|
time: {
|
|
22018
22022
|
start: number;
|
|
22019
22023
|
end: number;
|
|
22020
22024
|
};
|
|
22021
22025
|
type: "toolCall";
|
|
22022
|
-
} | {
|
|
22023
|
-
type: "thinking";
|
|
22024
|
-
thinking: string;
|
|
22025
|
-
thinkingSignature?: string;
|
|
22026
|
-
redacted?: boolean;
|
|
22027
22026
|
} | {
|
|
22028
22027
|
addedToolNames?: string[];
|
|
22029
22028
|
arguments: Record<string, any>;
|
|
22030
22029
|
callID: string;
|
|
22031
22030
|
name: string;
|
|
22032
22031
|
namespace?: string;
|
|
22033
|
-
|
|
22034
|
-
content
|
|
22032
|
+
result: {
|
|
22033
|
+
content: ({
|
|
22035
22034
|
type: "text";
|
|
22036
22035
|
text: string;
|
|
22037
22036
|
textSignature?: string;
|
|
@@ -22041,8 +22040,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22041
22040
|
mimeType: string;
|
|
22042
22041
|
})[];
|
|
22043
22042
|
details?: any;
|
|
22043
|
+
isError: true;
|
|
22044
22044
|
};
|
|
22045
|
-
status: "
|
|
22045
|
+
status: "aborted";
|
|
22046
22046
|
thoughtSignature?: string;
|
|
22047
22047
|
time: {
|
|
22048
22048
|
start: number;
|
|
@@ -22217,14 +22217,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22217
22217
|
type: "image";
|
|
22218
22218
|
data: string;
|
|
22219
22219
|
mimeType: string;
|
|
22220
|
+
} | {
|
|
22221
|
+
type: "thinking";
|
|
22222
|
+
thinking: string;
|
|
22223
|
+
thinkingSignature?: string;
|
|
22224
|
+
redacted?: boolean;
|
|
22220
22225
|
} | {
|
|
22221
22226
|
addedToolNames?: string[];
|
|
22222
22227
|
arguments: Record<string, any>;
|
|
22223
22228
|
callID: string;
|
|
22224
22229
|
name: string;
|
|
22225
22230
|
namespace?: string;
|
|
22226
|
-
|
|
22227
|
-
content
|
|
22231
|
+
partial?: {
|
|
22232
|
+
content?: ({
|
|
22228
22233
|
type: "text";
|
|
22229
22234
|
text: string;
|
|
22230
22235
|
textSignature?: string;
|
|
@@ -22234,9 +22239,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22234
22239
|
mimeType: string;
|
|
22235
22240
|
})[];
|
|
22236
22241
|
details?: any;
|
|
22237
|
-
isError: false;
|
|
22238
22242
|
};
|
|
22239
|
-
status: "
|
|
22243
|
+
status: "running";
|
|
22240
22244
|
thoughtSignature?: string;
|
|
22241
22245
|
time: {
|
|
22242
22246
|
start: number;
|
|
@@ -22260,9 +22264,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22260
22264
|
mimeType: string;
|
|
22261
22265
|
})[];
|
|
22262
22266
|
details?: any;
|
|
22263
|
-
isError:
|
|
22267
|
+
isError: false;
|
|
22264
22268
|
};
|
|
22265
|
-
status: "
|
|
22269
|
+
status: "completed";
|
|
22266
22270
|
thoughtSignature?: string;
|
|
22267
22271
|
time: {
|
|
22268
22272
|
start: number;
|
|
@@ -22288,7 +22292,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22288
22292
|
details?: any;
|
|
22289
22293
|
isError: true;
|
|
22290
22294
|
};
|
|
22291
|
-
status: "
|
|
22295
|
+
status: "error";
|
|
22292
22296
|
thoughtSignature?: string;
|
|
22293
22297
|
time: {
|
|
22294
22298
|
start: number;
|
|
@@ -22314,26 +22318,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22314
22318
|
details?: any;
|
|
22315
22319
|
isError: true;
|
|
22316
22320
|
};
|
|
22317
|
-
status: "
|
|
22321
|
+
status: "skipped";
|
|
22318
22322
|
thoughtSignature?: string;
|
|
22319
22323
|
time: {
|
|
22320
22324
|
start: number;
|
|
22321
22325
|
end: number;
|
|
22322
22326
|
};
|
|
22323
22327
|
type: "toolCall";
|
|
22324
|
-
} | {
|
|
22325
|
-
type: "thinking";
|
|
22326
|
-
thinking: string;
|
|
22327
|
-
thinkingSignature?: string;
|
|
22328
|
-
redacted?: boolean;
|
|
22329
22328
|
} | {
|
|
22330
22329
|
addedToolNames?: string[];
|
|
22331
22330
|
arguments: Record<string, any>;
|
|
22332
22331
|
callID: string;
|
|
22333
22332
|
name: string;
|
|
22334
22333
|
namespace?: string;
|
|
22335
|
-
|
|
22336
|
-
content
|
|
22334
|
+
result: {
|
|
22335
|
+
content: ({
|
|
22337
22336
|
type: "text";
|
|
22338
22337
|
text: string;
|
|
22339
22338
|
textSignature?: string;
|
|
@@ -22343,8 +22342,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22343
22342
|
mimeType: string;
|
|
22344
22343
|
})[];
|
|
22345
22344
|
details?: any;
|
|
22345
|
+
isError: true;
|
|
22346
22346
|
};
|
|
22347
|
-
status: "
|
|
22347
|
+
status: "aborted";
|
|
22348
22348
|
thoughtSignature?: string;
|
|
22349
22349
|
time: {
|
|
22350
22350
|
start: number;
|
|
@@ -22537,14 +22537,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22537
22537
|
type: "image";
|
|
22538
22538
|
data: string;
|
|
22539
22539
|
mimeType: string;
|
|
22540
|
+
} | {
|
|
22541
|
+
type: "thinking";
|
|
22542
|
+
thinking: string;
|
|
22543
|
+
thinkingSignature?: string;
|
|
22544
|
+
redacted?: boolean;
|
|
22540
22545
|
} | {
|
|
22541
22546
|
addedToolNames?: string[];
|
|
22542
22547
|
arguments: Record<string, any>;
|
|
22543
22548
|
callID: string;
|
|
22544
22549
|
name: string;
|
|
22545
22550
|
namespace?: string;
|
|
22546
|
-
|
|
22547
|
-
content
|
|
22551
|
+
partial?: {
|
|
22552
|
+
content?: ({
|
|
22548
22553
|
type: "text";
|
|
22549
22554
|
text: string;
|
|
22550
22555
|
textSignature?: string;
|
|
@@ -22554,9 +22559,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22554
22559
|
mimeType: string;
|
|
22555
22560
|
})[];
|
|
22556
22561
|
details?: any;
|
|
22557
|
-
isError: false;
|
|
22558
22562
|
};
|
|
22559
|
-
status: "
|
|
22563
|
+
status: "running";
|
|
22560
22564
|
thoughtSignature?: string;
|
|
22561
22565
|
time: {
|
|
22562
22566
|
start: number;
|
|
@@ -22580,9 +22584,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22580
22584
|
mimeType: string;
|
|
22581
22585
|
})[];
|
|
22582
22586
|
details?: any;
|
|
22583
|
-
isError:
|
|
22587
|
+
isError: false;
|
|
22584
22588
|
};
|
|
22585
|
-
status: "
|
|
22589
|
+
status: "completed";
|
|
22586
22590
|
thoughtSignature?: string;
|
|
22587
22591
|
time: {
|
|
22588
22592
|
start: number;
|
|
@@ -22608,7 +22612,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22608
22612
|
details?: any;
|
|
22609
22613
|
isError: true;
|
|
22610
22614
|
};
|
|
22611
|
-
status: "
|
|
22615
|
+
status: "error";
|
|
22612
22616
|
thoughtSignature?: string;
|
|
22613
22617
|
time: {
|
|
22614
22618
|
start: number;
|
|
@@ -22634,26 +22638,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22634
22638
|
details?: any;
|
|
22635
22639
|
isError: true;
|
|
22636
22640
|
};
|
|
22637
|
-
status: "
|
|
22641
|
+
status: "skipped";
|
|
22638
22642
|
thoughtSignature?: string;
|
|
22639
22643
|
time: {
|
|
22640
22644
|
start: number;
|
|
22641
22645
|
end: number;
|
|
22642
22646
|
};
|
|
22643
22647
|
type: "toolCall";
|
|
22644
|
-
} | {
|
|
22645
|
-
type: "thinking";
|
|
22646
|
-
thinking: string;
|
|
22647
|
-
thinkingSignature?: string;
|
|
22648
|
-
redacted?: boolean;
|
|
22649
22648
|
} | {
|
|
22650
22649
|
addedToolNames?: string[];
|
|
22651
22650
|
arguments: Record<string, any>;
|
|
22652
22651
|
callID: string;
|
|
22653
22652
|
name: string;
|
|
22654
22653
|
namespace?: string;
|
|
22655
|
-
|
|
22656
|
-
content
|
|
22654
|
+
result: {
|
|
22655
|
+
content: ({
|
|
22657
22656
|
type: "text";
|
|
22658
22657
|
text: string;
|
|
22659
22658
|
textSignature?: string;
|
|
@@ -22663,8 +22662,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22663
22662
|
mimeType: string;
|
|
22664
22663
|
})[];
|
|
22665
22664
|
details?: any;
|
|
22665
|
+
isError: true;
|
|
22666
22666
|
};
|
|
22667
|
-
status: "
|
|
22667
|
+
status: "aborted";
|
|
22668
22668
|
thoughtSignature?: string;
|
|
22669
22669
|
time: {
|
|
22670
22670
|
start: number;
|
|
@@ -22839,14 +22839,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22839
22839
|
type: "image";
|
|
22840
22840
|
data: string;
|
|
22841
22841
|
mimeType: string;
|
|
22842
|
+
} | {
|
|
22843
|
+
type: "thinking";
|
|
22844
|
+
thinking: string;
|
|
22845
|
+
thinkingSignature?: string;
|
|
22846
|
+
redacted?: boolean;
|
|
22842
22847
|
} | {
|
|
22843
22848
|
addedToolNames?: string[];
|
|
22844
22849
|
arguments: Record<string, any>;
|
|
22845
22850
|
callID: string;
|
|
22846
22851
|
name: string;
|
|
22847
22852
|
namespace?: string;
|
|
22848
|
-
|
|
22849
|
-
content
|
|
22853
|
+
partial?: {
|
|
22854
|
+
content?: ({
|
|
22850
22855
|
type: "text";
|
|
22851
22856
|
text: string;
|
|
22852
22857
|
textSignature?: string;
|
|
@@ -22856,9 +22861,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22856
22861
|
mimeType: string;
|
|
22857
22862
|
})[];
|
|
22858
22863
|
details?: any;
|
|
22859
|
-
isError: false;
|
|
22860
22864
|
};
|
|
22861
|
-
status: "
|
|
22865
|
+
status: "running";
|
|
22862
22866
|
thoughtSignature?: string;
|
|
22863
22867
|
time: {
|
|
22864
22868
|
start: number;
|
|
@@ -22882,9 +22886,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22882
22886
|
mimeType: string;
|
|
22883
22887
|
})[];
|
|
22884
22888
|
details?: any;
|
|
22885
|
-
isError:
|
|
22889
|
+
isError: false;
|
|
22886
22890
|
};
|
|
22887
|
-
status: "
|
|
22891
|
+
status: "completed";
|
|
22888
22892
|
thoughtSignature?: string;
|
|
22889
22893
|
time: {
|
|
22890
22894
|
start: number;
|
|
@@ -22910,7 +22914,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22910
22914
|
details?: any;
|
|
22911
22915
|
isError: true;
|
|
22912
22916
|
};
|
|
22913
|
-
status: "
|
|
22917
|
+
status: "error";
|
|
22914
22918
|
thoughtSignature?: string;
|
|
22915
22919
|
time: {
|
|
22916
22920
|
start: number;
|
|
@@ -22936,26 +22940,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22936
22940
|
details?: any;
|
|
22937
22941
|
isError: true;
|
|
22938
22942
|
};
|
|
22939
|
-
status: "
|
|
22943
|
+
status: "skipped";
|
|
22940
22944
|
thoughtSignature?: string;
|
|
22941
22945
|
time: {
|
|
22942
22946
|
start: number;
|
|
22943
22947
|
end: number;
|
|
22944
22948
|
};
|
|
22945
22949
|
type: "toolCall";
|
|
22946
|
-
} | {
|
|
22947
|
-
type: "thinking";
|
|
22948
|
-
thinking: string;
|
|
22949
|
-
thinkingSignature?: string;
|
|
22950
|
-
redacted?: boolean;
|
|
22951
22950
|
} | {
|
|
22952
22951
|
addedToolNames?: string[];
|
|
22953
22952
|
arguments: Record<string, any>;
|
|
22954
22953
|
callID: string;
|
|
22955
22954
|
name: string;
|
|
22956
22955
|
namespace?: string;
|
|
22957
|
-
|
|
22958
|
-
content
|
|
22956
|
+
result: {
|
|
22957
|
+
content: ({
|
|
22959
22958
|
type: "text";
|
|
22960
22959
|
text: string;
|
|
22961
22960
|
textSignature?: string;
|
|
@@ -22965,8 +22964,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22965
22964
|
mimeType: string;
|
|
22966
22965
|
})[];
|
|
22967
22966
|
details?: any;
|
|
22967
|
+
isError: true;
|
|
22968
22968
|
};
|
|
22969
|
-
status: "
|
|
22969
|
+
status: "aborted";
|
|
22970
22970
|
thoughtSignature?: string;
|
|
22971
22971
|
time: {
|
|
22972
22972
|
start: number;
|
|
@@ -23169,14 +23169,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23169
23169
|
type: "image";
|
|
23170
23170
|
data: string;
|
|
23171
23171
|
mimeType: string;
|
|
23172
|
+
} | {
|
|
23173
|
+
type: "thinking";
|
|
23174
|
+
thinking: string;
|
|
23175
|
+
thinkingSignature?: string;
|
|
23176
|
+
redacted?: boolean;
|
|
23172
23177
|
} | {
|
|
23173
23178
|
addedToolNames?: string[];
|
|
23174
23179
|
arguments: Record<string, any>;
|
|
23175
23180
|
callID: string;
|
|
23176
23181
|
name: string;
|
|
23177
23182
|
namespace?: string;
|
|
23178
|
-
|
|
23179
|
-
content
|
|
23183
|
+
partial?: {
|
|
23184
|
+
content?: ({
|
|
23180
23185
|
type: "text";
|
|
23181
23186
|
text: string;
|
|
23182
23187
|
textSignature?: string;
|
|
@@ -23186,9 +23191,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23186
23191
|
mimeType: string;
|
|
23187
23192
|
})[];
|
|
23188
23193
|
details?: any;
|
|
23189
|
-
isError: false;
|
|
23190
23194
|
};
|
|
23191
|
-
status: "
|
|
23195
|
+
status: "running";
|
|
23192
23196
|
thoughtSignature?: string;
|
|
23193
23197
|
time: {
|
|
23194
23198
|
start: number;
|
|
@@ -23212,9 +23216,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23212
23216
|
mimeType: string;
|
|
23213
23217
|
})[];
|
|
23214
23218
|
details?: any;
|
|
23215
|
-
isError:
|
|
23219
|
+
isError: false;
|
|
23216
23220
|
};
|
|
23217
|
-
status: "
|
|
23221
|
+
status: "completed";
|
|
23218
23222
|
thoughtSignature?: string;
|
|
23219
23223
|
time: {
|
|
23220
23224
|
start: number;
|
|
@@ -23240,7 +23244,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23240
23244
|
details?: any;
|
|
23241
23245
|
isError: true;
|
|
23242
23246
|
};
|
|
23243
|
-
status: "
|
|
23247
|
+
status: "error";
|
|
23244
23248
|
thoughtSignature?: string;
|
|
23245
23249
|
time: {
|
|
23246
23250
|
start: number;
|
|
@@ -23266,26 +23270,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23266
23270
|
details?: any;
|
|
23267
23271
|
isError: true;
|
|
23268
23272
|
};
|
|
23269
|
-
status: "
|
|
23273
|
+
status: "skipped";
|
|
23270
23274
|
thoughtSignature?: string;
|
|
23271
23275
|
time: {
|
|
23272
23276
|
start: number;
|
|
23273
23277
|
end: number;
|
|
23274
23278
|
};
|
|
23275
23279
|
type: "toolCall";
|
|
23276
|
-
} | {
|
|
23277
|
-
type: "thinking";
|
|
23278
|
-
thinking: string;
|
|
23279
|
-
thinkingSignature?: string;
|
|
23280
|
-
redacted?: boolean;
|
|
23281
23280
|
} | {
|
|
23282
23281
|
addedToolNames?: string[];
|
|
23283
23282
|
arguments: Record<string, any>;
|
|
23284
23283
|
callID: string;
|
|
23285
23284
|
name: string;
|
|
23286
23285
|
namespace?: string;
|
|
23287
|
-
|
|
23288
|
-
content
|
|
23286
|
+
result: {
|
|
23287
|
+
content: ({
|
|
23289
23288
|
type: "text";
|
|
23290
23289
|
text: string;
|
|
23291
23290
|
textSignature?: string;
|
|
@@ -23295,8 +23294,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23295
23294
|
mimeType: string;
|
|
23296
23295
|
})[];
|
|
23297
23296
|
details?: any;
|
|
23297
|
+
isError: true;
|
|
23298
23298
|
};
|
|
23299
|
-
status: "
|
|
23299
|
+
status: "aborted";
|
|
23300
23300
|
thoughtSignature?: string;
|
|
23301
23301
|
time: {
|
|
23302
23302
|
start: number;
|
|
@@ -23471,14 +23471,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23471
23471
|
type: "image";
|
|
23472
23472
|
data: string;
|
|
23473
23473
|
mimeType: string;
|
|
23474
|
+
} | {
|
|
23475
|
+
type: "thinking";
|
|
23476
|
+
thinking: string;
|
|
23477
|
+
thinkingSignature?: string;
|
|
23478
|
+
redacted?: boolean;
|
|
23474
23479
|
} | {
|
|
23475
23480
|
addedToolNames?: string[];
|
|
23476
23481
|
arguments: Record<string, any>;
|
|
23477
23482
|
callID: string;
|
|
23478
23483
|
name: string;
|
|
23479
23484
|
namespace?: string;
|
|
23480
|
-
|
|
23481
|
-
content
|
|
23485
|
+
partial?: {
|
|
23486
|
+
content?: ({
|
|
23482
23487
|
type: "text";
|
|
23483
23488
|
text: string;
|
|
23484
23489
|
textSignature?: string;
|
|
@@ -23488,9 +23493,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23488
23493
|
mimeType: string;
|
|
23489
23494
|
})[];
|
|
23490
23495
|
details?: any;
|
|
23491
|
-
isError: false;
|
|
23492
23496
|
};
|
|
23493
|
-
status: "
|
|
23497
|
+
status: "running";
|
|
23494
23498
|
thoughtSignature?: string;
|
|
23495
23499
|
time: {
|
|
23496
23500
|
start: number;
|
|
@@ -23514,9 +23518,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23514
23518
|
mimeType: string;
|
|
23515
23519
|
})[];
|
|
23516
23520
|
details?: any;
|
|
23517
|
-
isError:
|
|
23521
|
+
isError: false;
|
|
23518
23522
|
};
|
|
23519
|
-
status: "
|
|
23523
|
+
status: "completed";
|
|
23520
23524
|
thoughtSignature?: string;
|
|
23521
23525
|
time: {
|
|
23522
23526
|
start: number;
|
|
@@ -23542,7 +23546,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23542
23546
|
details?: any;
|
|
23543
23547
|
isError: true;
|
|
23544
23548
|
};
|
|
23545
|
-
status: "
|
|
23549
|
+
status: "error";
|
|
23546
23550
|
thoughtSignature?: string;
|
|
23547
23551
|
time: {
|
|
23548
23552
|
start: number;
|
|
@@ -23568,26 +23572,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23568
23572
|
details?: any;
|
|
23569
23573
|
isError: true;
|
|
23570
23574
|
};
|
|
23571
|
-
status: "
|
|
23575
|
+
status: "skipped";
|
|
23572
23576
|
thoughtSignature?: string;
|
|
23573
23577
|
time: {
|
|
23574
23578
|
start: number;
|
|
23575
23579
|
end: number;
|
|
23576
23580
|
};
|
|
23577
23581
|
type: "toolCall";
|
|
23578
|
-
} | {
|
|
23579
|
-
type: "thinking";
|
|
23580
|
-
thinking: string;
|
|
23581
|
-
thinkingSignature?: string;
|
|
23582
|
-
redacted?: boolean;
|
|
23583
23582
|
} | {
|
|
23584
23583
|
addedToolNames?: string[];
|
|
23585
23584
|
arguments: Record<string, any>;
|
|
23586
23585
|
callID: string;
|
|
23587
23586
|
name: string;
|
|
23588
23587
|
namespace?: string;
|
|
23589
|
-
|
|
23590
|
-
content
|
|
23588
|
+
result: {
|
|
23589
|
+
content: ({
|
|
23591
23590
|
type: "text";
|
|
23592
23591
|
text: string;
|
|
23593
23592
|
textSignature?: string;
|
|
@@ -23597,8 +23596,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23597
23596
|
mimeType: string;
|
|
23598
23597
|
})[];
|
|
23599
23598
|
details?: any;
|
|
23599
|
+
isError: true;
|
|
23600
23600
|
};
|
|
23601
|
-
status: "
|
|
23601
|
+
status: "aborted";
|
|
23602
23602
|
thoughtSignature?: string;
|
|
23603
23603
|
time: {
|
|
23604
23604
|
start: number;
|
|
@@ -23792,14 +23792,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23792
23792
|
type: "image";
|
|
23793
23793
|
data: string;
|
|
23794
23794
|
mimeType: string;
|
|
23795
|
+
} | {
|
|
23796
|
+
type: "thinking";
|
|
23797
|
+
thinking: string;
|
|
23798
|
+
thinkingSignature?: string;
|
|
23799
|
+
redacted?: boolean;
|
|
23795
23800
|
} | {
|
|
23796
23801
|
addedToolNames?: string[];
|
|
23797
23802
|
arguments: Record<string, any>;
|
|
23798
23803
|
callID: string;
|
|
23799
23804
|
name: string;
|
|
23800
23805
|
namespace?: string;
|
|
23801
|
-
|
|
23802
|
-
content
|
|
23806
|
+
partial?: {
|
|
23807
|
+
content?: ({
|
|
23803
23808
|
type: "text";
|
|
23804
23809
|
text: string;
|
|
23805
23810
|
textSignature?: string;
|
|
@@ -23809,9 +23814,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23809
23814
|
mimeType: string;
|
|
23810
23815
|
})[];
|
|
23811
23816
|
details?: any;
|
|
23812
|
-
isError: false;
|
|
23813
23817
|
};
|
|
23814
|
-
status: "
|
|
23818
|
+
status: "running";
|
|
23815
23819
|
thoughtSignature?: string;
|
|
23816
23820
|
time: {
|
|
23817
23821
|
start: number;
|
|
@@ -23835,9 +23839,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23835
23839
|
mimeType: string;
|
|
23836
23840
|
})[];
|
|
23837
23841
|
details?: any;
|
|
23838
|
-
isError:
|
|
23842
|
+
isError: false;
|
|
23839
23843
|
};
|
|
23840
|
-
status: "
|
|
23844
|
+
status: "completed";
|
|
23841
23845
|
thoughtSignature?: string;
|
|
23842
23846
|
time: {
|
|
23843
23847
|
start: number;
|
|
@@ -23863,7 +23867,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23863
23867
|
details?: any;
|
|
23864
23868
|
isError: true;
|
|
23865
23869
|
};
|
|
23866
|
-
status: "
|
|
23870
|
+
status: "error";
|
|
23867
23871
|
thoughtSignature?: string;
|
|
23868
23872
|
time: {
|
|
23869
23873
|
start: number;
|
|
@@ -23889,26 +23893,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23889
23893
|
details?: any;
|
|
23890
23894
|
isError: true;
|
|
23891
23895
|
};
|
|
23892
|
-
status: "
|
|
23896
|
+
status: "skipped";
|
|
23893
23897
|
thoughtSignature?: string;
|
|
23894
23898
|
time: {
|
|
23895
23899
|
start: number;
|
|
23896
23900
|
end: number;
|
|
23897
23901
|
};
|
|
23898
23902
|
type: "toolCall";
|
|
23899
|
-
} | {
|
|
23900
|
-
type: "thinking";
|
|
23901
|
-
thinking: string;
|
|
23902
|
-
thinkingSignature?: string;
|
|
23903
|
-
redacted?: boolean;
|
|
23904
23903
|
} | {
|
|
23905
23904
|
addedToolNames?: string[];
|
|
23906
23905
|
arguments: Record<string, any>;
|
|
23907
23906
|
callID: string;
|
|
23908
23907
|
name: string;
|
|
23909
23908
|
namespace?: string;
|
|
23910
|
-
|
|
23911
|
-
content
|
|
23909
|
+
result: {
|
|
23910
|
+
content: ({
|
|
23912
23911
|
type: "text";
|
|
23913
23912
|
text: string;
|
|
23914
23913
|
textSignature?: string;
|
|
@@ -23918,8 +23917,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23918
23917
|
mimeType: string;
|
|
23919
23918
|
})[];
|
|
23920
23919
|
details?: any;
|
|
23920
|
+
isError: true;
|
|
23921
23921
|
};
|
|
23922
|
-
status: "
|
|
23922
|
+
status: "aborted";
|
|
23923
23923
|
thoughtSignature?: string;
|
|
23924
23924
|
time: {
|
|
23925
23925
|
start: number;
|
|
@@ -24094,14 +24094,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24094
24094
|
type: "image";
|
|
24095
24095
|
data: string;
|
|
24096
24096
|
mimeType: string;
|
|
24097
|
+
} | {
|
|
24098
|
+
type: "thinking";
|
|
24099
|
+
thinking: string;
|
|
24100
|
+
thinkingSignature?: string;
|
|
24101
|
+
redacted?: boolean;
|
|
24097
24102
|
} | {
|
|
24098
24103
|
addedToolNames?: string[];
|
|
24099
24104
|
arguments: Record<string, any>;
|
|
24100
24105
|
callID: string;
|
|
24101
24106
|
name: string;
|
|
24102
24107
|
namespace?: string;
|
|
24103
|
-
|
|
24104
|
-
content
|
|
24108
|
+
partial?: {
|
|
24109
|
+
content?: ({
|
|
24105
24110
|
type: "text";
|
|
24106
24111
|
text: string;
|
|
24107
24112
|
textSignature?: string;
|
|
@@ -24111,9 +24116,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24111
24116
|
mimeType: string;
|
|
24112
24117
|
})[];
|
|
24113
24118
|
details?: any;
|
|
24114
|
-
isError: false;
|
|
24115
24119
|
};
|
|
24116
|
-
status: "
|
|
24120
|
+
status: "running";
|
|
24117
24121
|
thoughtSignature?: string;
|
|
24118
24122
|
time: {
|
|
24119
24123
|
start: number;
|
|
@@ -24137,9 +24141,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24137
24141
|
mimeType: string;
|
|
24138
24142
|
})[];
|
|
24139
24143
|
details?: any;
|
|
24140
|
-
isError:
|
|
24144
|
+
isError: false;
|
|
24141
24145
|
};
|
|
24142
|
-
status: "
|
|
24146
|
+
status: "completed";
|
|
24143
24147
|
thoughtSignature?: string;
|
|
24144
24148
|
time: {
|
|
24145
24149
|
start: number;
|
|
@@ -24165,7 +24169,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24165
24169
|
details?: any;
|
|
24166
24170
|
isError: true;
|
|
24167
24171
|
};
|
|
24168
|
-
status: "
|
|
24172
|
+
status: "error";
|
|
24169
24173
|
thoughtSignature?: string;
|
|
24170
24174
|
time: {
|
|
24171
24175
|
start: number;
|
|
@@ -24191,26 +24195,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24191
24195
|
details?: any;
|
|
24192
24196
|
isError: true;
|
|
24193
24197
|
};
|
|
24194
|
-
status: "
|
|
24198
|
+
status: "skipped";
|
|
24195
24199
|
thoughtSignature?: string;
|
|
24196
24200
|
time: {
|
|
24197
24201
|
start: number;
|
|
24198
24202
|
end: number;
|
|
24199
24203
|
};
|
|
24200
24204
|
type: "toolCall";
|
|
24201
|
-
} | {
|
|
24202
|
-
type: "thinking";
|
|
24203
|
-
thinking: string;
|
|
24204
|
-
thinkingSignature?: string;
|
|
24205
|
-
redacted?: boolean;
|
|
24206
24205
|
} | {
|
|
24207
24206
|
addedToolNames?: string[];
|
|
24208
24207
|
arguments: Record<string, any>;
|
|
24209
24208
|
callID: string;
|
|
24210
24209
|
name: string;
|
|
24211
24210
|
namespace?: string;
|
|
24212
|
-
|
|
24213
|
-
content
|
|
24211
|
+
result: {
|
|
24212
|
+
content: ({
|
|
24214
24213
|
type: "text";
|
|
24215
24214
|
text: string;
|
|
24216
24215
|
textSignature?: string;
|
|
@@ -24220,8 +24219,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24220
24219
|
mimeType: string;
|
|
24221
24220
|
})[];
|
|
24222
24221
|
details?: any;
|
|
24222
|
+
isError: true;
|
|
24223
24223
|
};
|
|
24224
|
-
status: "
|
|
24224
|
+
status: "aborted";
|
|
24225
24225
|
thoughtSignature?: string;
|
|
24226
24226
|
time: {
|
|
24227
24227
|
start: number;
|
|
@@ -24424,14 +24424,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24424
24424
|
type: "image";
|
|
24425
24425
|
data: string;
|
|
24426
24426
|
mimeType: string;
|
|
24427
|
+
} | {
|
|
24428
|
+
type: "thinking";
|
|
24429
|
+
thinking: string;
|
|
24430
|
+
thinkingSignature?: string;
|
|
24431
|
+
redacted?: boolean;
|
|
24427
24432
|
} | {
|
|
24428
24433
|
addedToolNames?: string[];
|
|
24429
24434
|
arguments: Record<string, any>;
|
|
24430
24435
|
callID: string;
|
|
24431
24436
|
name: string;
|
|
24432
24437
|
namespace?: string;
|
|
24433
|
-
|
|
24434
|
-
content
|
|
24438
|
+
partial?: {
|
|
24439
|
+
content?: ({
|
|
24435
24440
|
type: "text";
|
|
24436
24441
|
text: string;
|
|
24437
24442
|
textSignature?: string;
|
|
@@ -24441,9 +24446,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24441
24446
|
mimeType: string;
|
|
24442
24447
|
})[];
|
|
24443
24448
|
details?: any;
|
|
24444
|
-
isError: false;
|
|
24445
24449
|
};
|
|
24446
|
-
status: "
|
|
24450
|
+
status: "running";
|
|
24447
24451
|
thoughtSignature?: string;
|
|
24448
24452
|
time: {
|
|
24449
24453
|
start: number;
|
|
@@ -24467,9 +24471,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24467
24471
|
mimeType: string;
|
|
24468
24472
|
})[];
|
|
24469
24473
|
details?: any;
|
|
24470
|
-
isError:
|
|
24474
|
+
isError: false;
|
|
24471
24475
|
};
|
|
24472
|
-
status: "
|
|
24476
|
+
status: "completed";
|
|
24473
24477
|
thoughtSignature?: string;
|
|
24474
24478
|
time: {
|
|
24475
24479
|
start: number;
|
|
@@ -24495,7 +24499,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24495
24499
|
details?: any;
|
|
24496
24500
|
isError: true;
|
|
24497
24501
|
};
|
|
24498
|
-
status: "
|
|
24502
|
+
status: "error";
|
|
24499
24503
|
thoughtSignature?: string;
|
|
24500
24504
|
time: {
|
|
24501
24505
|
start: number;
|
|
@@ -24521,26 +24525,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24521
24525
|
details?: any;
|
|
24522
24526
|
isError: true;
|
|
24523
24527
|
};
|
|
24524
|
-
status: "
|
|
24528
|
+
status: "skipped";
|
|
24525
24529
|
thoughtSignature?: string;
|
|
24526
24530
|
time: {
|
|
24527
24531
|
start: number;
|
|
24528
24532
|
end: number;
|
|
24529
24533
|
};
|
|
24530
24534
|
type: "toolCall";
|
|
24531
|
-
} | {
|
|
24532
|
-
type: "thinking";
|
|
24533
|
-
thinking: string;
|
|
24534
|
-
thinkingSignature?: string;
|
|
24535
|
-
redacted?: boolean;
|
|
24536
24535
|
} | {
|
|
24537
24536
|
addedToolNames?: string[];
|
|
24538
24537
|
arguments: Record<string, any>;
|
|
24539
24538
|
callID: string;
|
|
24540
24539
|
name: string;
|
|
24541
24540
|
namespace?: string;
|
|
24542
|
-
|
|
24543
|
-
content
|
|
24541
|
+
result: {
|
|
24542
|
+
content: ({
|
|
24544
24543
|
type: "text";
|
|
24545
24544
|
text: string;
|
|
24546
24545
|
textSignature?: string;
|
|
@@ -24550,8 +24549,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24550
24549
|
mimeType: string;
|
|
24551
24550
|
})[];
|
|
24552
24551
|
details?: any;
|
|
24552
|
+
isError: true;
|
|
24553
24553
|
};
|
|
24554
|
-
status: "
|
|
24554
|
+
status: "aborted";
|
|
24555
24555
|
thoughtSignature?: string;
|
|
24556
24556
|
time: {
|
|
24557
24557
|
start: number;
|
|
@@ -24726,14 +24726,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24726
24726
|
type: "image";
|
|
24727
24727
|
data: string;
|
|
24728
24728
|
mimeType: string;
|
|
24729
|
+
} | {
|
|
24730
|
+
type: "thinking";
|
|
24731
|
+
thinking: string;
|
|
24732
|
+
thinkingSignature?: string;
|
|
24733
|
+
redacted?: boolean;
|
|
24729
24734
|
} | {
|
|
24730
24735
|
addedToolNames?: string[];
|
|
24731
24736
|
arguments: Record<string, any>;
|
|
24732
24737
|
callID: string;
|
|
24733
24738
|
name: string;
|
|
24734
24739
|
namespace?: string;
|
|
24735
|
-
|
|
24736
|
-
content
|
|
24740
|
+
partial?: {
|
|
24741
|
+
content?: ({
|
|
24737
24742
|
type: "text";
|
|
24738
24743
|
text: string;
|
|
24739
24744
|
textSignature?: string;
|
|
@@ -24743,9 +24748,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24743
24748
|
mimeType: string;
|
|
24744
24749
|
})[];
|
|
24745
24750
|
details?: any;
|
|
24746
|
-
isError: false;
|
|
24747
24751
|
};
|
|
24748
|
-
status: "
|
|
24752
|
+
status: "running";
|
|
24749
24753
|
thoughtSignature?: string;
|
|
24750
24754
|
time: {
|
|
24751
24755
|
start: number;
|
|
@@ -24769,9 +24773,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24769
24773
|
mimeType: string;
|
|
24770
24774
|
})[];
|
|
24771
24775
|
details?: any;
|
|
24772
|
-
isError:
|
|
24776
|
+
isError: false;
|
|
24773
24777
|
};
|
|
24774
|
-
status: "
|
|
24778
|
+
status: "completed";
|
|
24775
24779
|
thoughtSignature?: string;
|
|
24776
24780
|
time: {
|
|
24777
24781
|
start: number;
|
|
@@ -24797,7 +24801,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24797
24801
|
details?: any;
|
|
24798
24802
|
isError: true;
|
|
24799
24803
|
};
|
|
24800
|
-
status: "
|
|
24804
|
+
status: "error";
|
|
24801
24805
|
thoughtSignature?: string;
|
|
24802
24806
|
time: {
|
|
24803
24807
|
start: number;
|
|
@@ -24823,26 +24827,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24823
24827
|
details?: any;
|
|
24824
24828
|
isError: true;
|
|
24825
24829
|
};
|
|
24826
|
-
status: "
|
|
24830
|
+
status: "skipped";
|
|
24827
24831
|
thoughtSignature?: string;
|
|
24828
24832
|
time: {
|
|
24829
24833
|
start: number;
|
|
24830
24834
|
end: number;
|
|
24831
24835
|
};
|
|
24832
24836
|
type: "toolCall";
|
|
24833
|
-
} | {
|
|
24834
|
-
type: "thinking";
|
|
24835
|
-
thinking: string;
|
|
24836
|
-
thinkingSignature?: string;
|
|
24837
|
-
redacted?: boolean;
|
|
24838
24837
|
} | {
|
|
24839
24838
|
addedToolNames?: string[];
|
|
24840
24839
|
arguments: Record<string, any>;
|
|
24841
24840
|
callID: string;
|
|
24842
24841
|
name: string;
|
|
24843
24842
|
namespace?: string;
|
|
24844
|
-
|
|
24845
|
-
content
|
|
24843
|
+
result: {
|
|
24844
|
+
content: ({
|
|
24846
24845
|
type: "text";
|
|
24847
24846
|
text: string;
|
|
24848
24847
|
textSignature?: string;
|
|
@@ -24852,8 +24851,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24852
24851
|
mimeType: string;
|
|
24853
24852
|
})[];
|
|
24854
24853
|
details?: any;
|
|
24854
|
+
isError: true;
|
|
24855
24855
|
};
|
|
24856
|
-
status: "
|
|
24856
|
+
status: "aborted";
|
|
24857
24857
|
thoughtSignature?: string;
|
|
24858
24858
|
time: {
|
|
24859
24859
|
start: number;
|
|
@@ -25047,14 +25047,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25047
25047
|
type: "image";
|
|
25048
25048
|
data: string;
|
|
25049
25049
|
mimeType: string;
|
|
25050
|
+
} | {
|
|
25051
|
+
type: "thinking";
|
|
25052
|
+
thinking: string;
|
|
25053
|
+
thinkingSignature?: string;
|
|
25054
|
+
redacted?: boolean;
|
|
25050
25055
|
} | {
|
|
25051
25056
|
addedToolNames?: string[];
|
|
25052
25057
|
arguments: Record<string, any>;
|
|
25053
25058
|
callID: string;
|
|
25054
25059
|
name: string;
|
|
25055
25060
|
namespace?: string;
|
|
25056
|
-
|
|
25057
|
-
content
|
|
25061
|
+
partial?: {
|
|
25062
|
+
content?: ({
|
|
25058
25063
|
type: "text";
|
|
25059
25064
|
text: string;
|
|
25060
25065
|
textSignature?: string;
|
|
@@ -25064,9 +25069,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25064
25069
|
mimeType: string;
|
|
25065
25070
|
})[];
|
|
25066
25071
|
details?: any;
|
|
25067
|
-
isError: false;
|
|
25068
25072
|
};
|
|
25069
|
-
status: "
|
|
25073
|
+
status: "running";
|
|
25070
25074
|
thoughtSignature?: string;
|
|
25071
25075
|
time: {
|
|
25072
25076
|
start: number;
|
|
@@ -25090,9 +25094,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25090
25094
|
mimeType: string;
|
|
25091
25095
|
})[];
|
|
25092
25096
|
details?: any;
|
|
25093
|
-
isError:
|
|
25097
|
+
isError: false;
|
|
25094
25098
|
};
|
|
25095
|
-
status: "
|
|
25099
|
+
status: "completed";
|
|
25096
25100
|
thoughtSignature?: string;
|
|
25097
25101
|
time: {
|
|
25098
25102
|
start: number;
|
|
@@ -25118,7 +25122,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25118
25122
|
details?: any;
|
|
25119
25123
|
isError: true;
|
|
25120
25124
|
};
|
|
25121
|
-
status: "
|
|
25125
|
+
status: "error";
|
|
25122
25126
|
thoughtSignature?: string;
|
|
25123
25127
|
time: {
|
|
25124
25128
|
start: number;
|
|
@@ -25144,26 +25148,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25144
25148
|
details?: any;
|
|
25145
25149
|
isError: true;
|
|
25146
25150
|
};
|
|
25147
|
-
status: "
|
|
25151
|
+
status: "skipped";
|
|
25148
25152
|
thoughtSignature?: string;
|
|
25149
25153
|
time: {
|
|
25150
25154
|
start: number;
|
|
25151
25155
|
end: number;
|
|
25152
25156
|
};
|
|
25153
25157
|
type: "toolCall";
|
|
25154
|
-
} | {
|
|
25155
|
-
type: "thinking";
|
|
25156
|
-
thinking: string;
|
|
25157
|
-
thinkingSignature?: string;
|
|
25158
|
-
redacted?: boolean;
|
|
25159
25158
|
} | {
|
|
25160
25159
|
addedToolNames?: string[];
|
|
25161
25160
|
arguments: Record<string, any>;
|
|
25162
25161
|
callID: string;
|
|
25163
25162
|
name: string;
|
|
25164
25163
|
namespace?: string;
|
|
25165
|
-
|
|
25166
|
-
content
|
|
25164
|
+
result: {
|
|
25165
|
+
content: ({
|
|
25167
25166
|
type: "text";
|
|
25168
25167
|
text: string;
|
|
25169
25168
|
textSignature?: string;
|
|
@@ -25173,8 +25172,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25173
25172
|
mimeType: string;
|
|
25174
25173
|
})[];
|
|
25175
25174
|
details?: any;
|
|
25175
|
+
isError: true;
|
|
25176
25176
|
};
|
|
25177
|
-
status: "
|
|
25177
|
+
status: "aborted";
|
|
25178
25178
|
thoughtSignature?: string;
|
|
25179
25179
|
time: {
|
|
25180
25180
|
start: number;
|
|
@@ -25349,14 +25349,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25349
25349
|
type: "image";
|
|
25350
25350
|
data: string;
|
|
25351
25351
|
mimeType: string;
|
|
25352
|
+
} | {
|
|
25353
|
+
type: "thinking";
|
|
25354
|
+
thinking: string;
|
|
25355
|
+
thinkingSignature?: string;
|
|
25356
|
+
redacted?: boolean;
|
|
25352
25357
|
} | {
|
|
25353
25358
|
addedToolNames?: string[];
|
|
25354
25359
|
arguments: Record<string, any>;
|
|
25355
25360
|
callID: string;
|
|
25356
25361
|
name: string;
|
|
25357
25362
|
namespace?: string;
|
|
25358
|
-
|
|
25359
|
-
content
|
|
25363
|
+
partial?: {
|
|
25364
|
+
content?: ({
|
|
25360
25365
|
type: "text";
|
|
25361
25366
|
text: string;
|
|
25362
25367
|
textSignature?: string;
|
|
@@ -25366,9 +25371,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25366
25371
|
mimeType: string;
|
|
25367
25372
|
})[];
|
|
25368
25373
|
details?: any;
|
|
25369
|
-
isError: false;
|
|
25370
25374
|
};
|
|
25371
|
-
status: "
|
|
25375
|
+
status: "running";
|
|
25372
25376
|
thoughtSignature?: string;
|
|
25373
25377
|
time: {
|
|
25374
25378
|
start: number;
|
|
@@ -25392,9 +25396,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25392
25396
|
mimeType: string;
|
|
25393
25397
|
})[];
|
|
25394
25398
|
details?: any;
|
|
25395
|
-
isError:
|
|
25399
|
+
isError: false;
|
|
25396
25400
|
};
|
|
25397
|
-
status: "
|
|
25401
|
+
status: "completed";
|
|
25398
25402
|
thoughtSignature?: string;
|
|
25399
25403
|
time: {
|
|
25400
25404
|
start: number;
|
|
@@ -25420,7 +25424,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25420
25424
|
details?: any;
|
|
25421
25425
|
isError: true;
|
|
25422
25426
|
};
|
|
25423
|
-
status: "
|
|
25427
|
+
status: "error";
|
|
25424
25428
|
thoughtSignature?: string;
|
|
25425
25429
|
time: {
|
|
25426
25430
|
start: number;
|
|
@@ -25446,26 +25450,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25446
25450
|
details?: any;
|
|
25447
25451
|
isError: true;
|
|
25448
25452
|
};
|
|
25449
|
-
status: "
|
|
25453
|
+
status: "skipped";
|
|
25450
25454
|
thoughtSignature?: string;
|
|
25451
25455
|
time: {
|
|
25452
25456
|
start: number;
|
|
25453
25457
|
end: number;
|
|
25454
25458
|
};
|
|
25455
25459
|
type: "toolCall";
|
|
25456
|
-
} | {
|
|
25457
|
-
type: "thinking";
|
|
25458
|
-
thinking: string;
|
|
25459
|
-
thinkingSignature?: string;
|
|
25460
|
-
redacted?: boolean;
|
|
25461
25460
|
} | {
|
|
25462
25461
|
addedToolNames?: string[];
|
|
25463
25462
|
arguments: Record<string, any>;
|
|
25464
25463
|
callID: string;
|
|
25465
25464
|
name: string;
|
|
25466
25465
|
namespace?: string;
|
|
25467
|
-
|
|
25468
|
-
content
|
|
25466
|
+
result: {
|
|
25467
|
+
content: ({
|
|
25469
25468
|
type: "text";
|
|
25470
25469
|
text: string;
|
|
25471
25470
|
textSignature?: string;
|
|
@@ -25475,8 +25474,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
25475
25474
|
mimeType: string;
|
|
25476
25475
|
})[];
|
|
25477
25476
|
details?: any;
|
|
25477
|
+
isError: true;
|
|
25478
25478
|
};
|
|
25479
|
-
status: "
|
|
25479
|
+
status: "aborted";
|
|
25480
25480
|
thoughtSignature?: string;
|
|
25481
25481
|
time: {
|
|
25482
25482
|
start: number;
|