@codeworksh/harness 0.2.0-canary.17.1.gd1cf9b0f → 0.2.0-canary.18.1.gc4473ccb

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