@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.
Files changed (2) hide show
  1. package/effect.d.mts +800 -800
  2. 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
- result: {
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: "completed";
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: true;
2980
+ isError: false;
2977
2981
  };
2978
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
3314
+ isError: false;
3311
3315
  };
3312
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
5343
+ isError: false;
5340
5344
  };
5341
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
5645
+ isError: false;
5642
5646
  };
5643
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
5965
+ isError: false;
5962
5966
  };
5963
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
6267
+ isError: false;
6264
6268
  };
6265
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
6890
+ isError: false;
6887
6891
  };
6888
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
7192
+ isError: false;
7189
7193
  };
7190
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
7513
+ isError: false;
7510
7514
  };
7511
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
7815
+ isError: false;
7812
7816
  };
7813
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
8148
+ isError: false;
8145
8149
  };
8146
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
8450
+ isError: false;
8447
8451
  };
8448
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
8771
+ isError: false;
8768
8772
  };
8769
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
9073
+ isError: false;
9070
9074
  };
9071
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
11162
+ isError: false;
11159
11163
  };
11160
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
11464
+ isError: false;
11461
11465
  };
11462
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
11784
+ isError: false;
11781
11785
  };
11782
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12086
+ isError: false;
12083
12087
  };
12084
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12694
+ isError: false;
12691
12695
  };
12692
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12996
+ isError: false;
12993
12997
  };
12994
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
13317
+ isError: false;
13314
13318
  };
13315
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
13619
+ isError: false;
13616
13620
  };
13617
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
13949
+ isError: false;
13946
13950
  };
13947
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
14251
+ isError: false;
14248
14252
  };
14249
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
14572
+ isError: false;
14569
14573
  };
14570
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
14874
+ isError: false;
14871
14875
  };
14872
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
16724
+ isError: false;
16721
16725
  };
16722
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
17026
+ isError: false;
17023
17027
  };
17024
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
17346
+ isError: false;
17343
17347
  };
17344
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
17648
+ isError: false;
17645
17649
  };
17646
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18256
+ isError: false;
18253
18257
  };
18254
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18558
+ isError: false;
18555
18559
  };
18556
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18879
+ isError: false;
18876
18880
  };
18877
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
19181
+ isError: false;
19178
19182
  };
19179
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
19511
+ isError: false;
19508
19512
  };
19509
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
19813
+ isError: false;
19810
19814
  };
19811
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
20134
+ isError: false;
20131
20135
  };
20132
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
20436
+ isError: false;
20433
20437
  };
20434
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
21965
+ isError: false;
21962
21966
  };
21963
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
22267
+ isError: false;
22264
22268
  };
22265
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
22587
+ isError: false;
22584
22588
  };
22585
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
22889
+ isError: false;
22886
22890
  };
22887
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
23219
+ isError: false;
23216
23220
  };
23217
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
23521
+ isError: false;
23518
23522
  };
23519
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
23842
+ isError: false;
23839
23843
  };
23840
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
24144
+ isError: false;
24141
24145
  };
24142
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
24474
+ isError: false;
24471
24475
  };
24472
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
24776
+ isError: false;
24773
24777
  };
24774
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
25097
+ isError: false;
25094
25098
  };
25095
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
25399
+ isError: false;
25396
25400
  };
25397
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
25479
+ status: "aborted";
25480
25480
  thoughtSignature?: string;
25481
25481
  time: {
25482
25482
  start: number;