@codeworksh/harness 0.1.0-canary.18.1.g00a873ad → 0.1.0-canary.19.1.gbef2d437

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/effect.d.mts +824 -824
  2. package/package.json +3 -3
package/effect.d.mts CHANGED
@@ -2710,6 +2710,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2710
2710
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2711
2711
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2712
2712
  declare const encodeMessage: (message: {
2713
+ messageId: string;
2714
+ role: "user";
2715
+ time: {
2716
+ created: number;
2717
+ };
2718
+ parts: ({
2719
+ type: "text";
2720
+ text: string;
2721
+ textSignature?: string;
2722
+ } | {
2723
+ type: "image";
2724
+ data: string;
2725
+ mimeType: string;
2726
+ })[];
2727
+ } | {
2713
2728
  role: "assistant";
2714
2729
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2715
2730
  provider: {
@@ -2859,19 +2874,14 @@ declare const encodeMessage: (message: {
2859
2874
  type: "image";
2860
2875
  data: string;
2861
2876
  mimeType: string;
2862
- } | {
2863
- type: "thinking";
2864
- thinking: string;
2865
- thinkingSignature?: string;
2866
- redacted?: boolean;
2867
2877
  } | {
2868
2878
  addedToolNames?: string[];
2869
2879
  arguments: Record<string, any>;
2870
2880
  callID: string;
2871
2881
  name: string;
2872
2882
  namespace?: string;
2873
- partial?: {
2874
- content?: ({
2883
+ result: {
2884
+ content: ({
2875
2885
  type: "text";
2876
2886
  text: string;
2877
2887
  textSignature?: string;
@@ -2881,8 +2891,9 @@ declare const encodeMessage: (message: {
2881
2891
  mimeType: string;
2882
2892
  })[];
2883
2893
  details?: any;
2894
+ isError: false;
2884
2895
  };
2885
- status: "running";
2896
+ status: "completed";
2886
2897
  thoughtSignature?: string;
2887
2898
  time: {
2888
2899
  start: number;
@@ -2906,9 +2917,9 @@ declare const encodeMessage: (message: {
2906
2917
  mimeType: string;
2907
2918
  })[];
2908
2919
  details?: any;
2909
- isError: false;
2920
+ isError: true;
2910
2921
  };
2911
- status: "completed";
2922
+ status: "error";
2912
2923
  thoughtSignature?: string;
2913
2924
  time: {
2914
2925
  start: number;
@@ -2934,7 +2945,7 @@ declare const encodeMessage: (message: {
2934
2945
  details?: any;
2935
2946
  isError: true;
2936
2947
  };
2937
- status: "error";
2948
+ status: "skipped";
2938
2949
  thoughtSignature?: string;
2939
2950
  time: {
2940
2951
  start: number;
@@ -2960,21 +2971,26 @@ declare const encodeMessage: (message: {
2960
2971
  details?: any;
2961
2972
  isError: true;
2962
2973
  };
2963
- status: "skipped";
2974
+ status: "aborted";
2964
2975
  thoughtSignature?: string;
2965
2976
  time: {
2966
2977
  start: number;
2967
2978
  end: number;
2968
2979
  };
2969
2980
  type: "toolCall";
2981
+ } | {
2982
+ type: "thinking";
2983
+ thinking: string;
2984
+ thinkingSignature?: string;
2985
+ redacted?: boolean;
2970
2986
  } | {
2971
2987
  addedToolNames?: string[];
2972
2988
  arguments: Record<string, any>;
2973
2989
  callID: string;
2974
2990
  name: string;
2975
2991
  namespace?: string;
2976
- result: {
2977
- content: ({
2992
+ partial?: {
2993
+ content?: ({
2978
2994
  type: "text";
2979
2995
  text: string;
2980
2996
  textSignature?: string;
@@ -2984,9 +3000,8 @@ declare const encodeMessage: (message: {
2984
3000
  mimeType: string;
2985
3001
  })[];
2986
3002
  details?: any;
2987
- isError: true;
2988
3003
  };
2989
- status: "aborted";
3004
+ status: "running";
2990
3005
  thoughtSignature?: string;
2991
3006
  time: {
2992
3007
  start: number;
@@ -3011,7 +3026,8 @@ declare const encodeMessage: (message: {
3011
3026
  responseId?: string;
3012
3027
  responseModel?: string;
3013
3028
  messageId: string;
3014
- } | {
3029
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3030
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3015
3031
  messageId: string;
3016
3032
  role: "user";
3017
3033
  time: {
@@ -3026,8 +3042,8 @@ declare const encodeMessage: (message: {
3026
3042
  data: string;
3027
3043
  mimeType: string;
3028
3044
  })[];
3029
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3030
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3045
+ }, ContextDecodeError, never>;
3046
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3031
3047
  messageId: string;
3032
3048
  role: "user";
3033
3049
  time: {
@@ -3042,8 +3058,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3042
3058
  data: string;
3043
3059
  mimeType: string;
3044
3060
  })[];
3045
- }, ContextDecodeError, never>;
3046
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3061
+ } | {
3047
3062
  role: "assistant";
3048
3063
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3049
3064
  provider: {
@@ -3193,19 +3208,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3193
3208
  type: "image";
3194
3209
  data: string;
3195
3210
  mimeType: string;
3196
- } | {
3197
- type: "thinking";
3198
- thinking: string;
3199
- thinkingSignature?: string;
3200
- redacted?: boolean;
3201
3211
  } | {
3202
3212
  addedToolNames?: string[];
3203
3213
  arguments: Record<string, any>;
3204
3214
  callID: string;
3205
3215
  name: string;
3206
3216
  namespace?: string;
3207
- partial?: {
3208
- content?: ({
3217
+ result: {
3218
+ content: ({
3209
3219
  type: "text";
3210
3220
  text: string;
3211
3221
  textSignature?: string;
@@ -3215,8 +3225,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3215
3225
  mimeType: string;
3216
3226
  })[];
3217
3227
  details?: any;
3228
+ isError: false;
3218
3229
  };
3219
- status: "running";
3230
+ status: "completed";
3220
3231
  thoughtSignature?: string;
3221
3232
  time: {
3222
3233
  start: number;
@@ -3240,9 +3251,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3240
3251
  mimeType: string;
3241
3252
  })[];
3242
3253
  details?: any;
3243
- isError: false;
3254
+ isError: true;
3244
3255
  };
3245
- status: "completed";
3256
+ status: "error";
3246
3257
  thoughtSignature?: string;
3247
3258
  time: {
3248
3259
  start: number;
@@ -3268,7 +3279,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3268
3279
  details?: any;
3269
3280
  isError: true;
3270
3281
  };
3271
- status: "error";
3282
+ status: "skipped";
3272
3283
  thoughtSignature?: string;
3273
3284
  time: {
3274
3285
  start: number;
@@ -3294,21 +3305,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3294
3305
  details?: any;
3295
3306
  isError: true;
3296
3307
  };
3297
- status: "skipped";
3308
+ status: "aborted";
3298
3309
  thoughtSignature?: string;
3299
3310
  time: {
3300
3311
  start: number;
3301
3312
  end: number;
3302
3313
  };
3303
3314
  type: "toolCall";
3315
+ } | {
3316
+ type: "thinking";
3317
+ thinking: string;
3318
+ thinkingSignature?: string;
3319
+ redacted?: boolean;
3304
3320
  } | {
3305
3321
  addedToolNames?: string[];
3306
3322
  arguments: Record<string, any>;
3307
3323
  callID: string;
3308
3324
  name: string;
3309
3325
  namespace?: string;
3310
- result: {
3311
- content: ({
3326
+ partial?: {
3327
+ content?: ({
3312
3328
  type: "text";
3313
3329
  text: string;
3314
3330
  textSignature?: string;
@@ -3318,9 +3334,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3318
3334
  mimeType: string;
3319
3335
  })[];
3320
3336
  details?: any;
3321
- isError: true;
3322
3337
  };
3323
- status: "aborted";
3338
+ status: "running";
3324
3339
  thoughtSignature?: string;
3325
3340
  time: {
3326
3341
  start: number;
@@ -3345,21 +3360,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3345
3360
  responseId?: string;
3346
3361
  responseModel?: string;
3347
3362
  messageId: string;
3348
- } | {
3349
- messageId: string;
3350
- role: "user";
3351
- time: {
3352
- created: number;
3353
- };
3354
- parts: ({
3355
- type: "text";
3356
- text: string;
3357
- textSignature?: string;
3358
- } | {
3359
- type: "image";
3360
- data: string;
3361
- mimeType: string;
3362
- })[];
3363
3363
  }, ContextDecodeError, never>;
3364
3364
  declare namespace context_d_exports {
3365
3365
  export { context_d_exports as Context, assemble_d_exports as ContextAssembly, codec_d_exports as ContextCodec, ContextDecodeError, ContextEncodeError, ContextInvariantError, ContextReadError, EncodedMessage, Interface$1 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$4 as layer, validateUserMessage };
@@ -4801,19 +4801,14 @@ declare const LLMStarted: Schema.Struct<{
4801
4801
  type: "image";
4802
4802
  data: string;
4803
4803
  mimeType: string;
4804
- } | {
4805
- type: "thinking";
4806
- thinking: string;
4807
- thinkingSignature?: string;
4808
- redacted?: boolean;
4809
4804
  } | {
4810
4805
  addedToolNames?: string[];
4811
4806
  arguments: Record<string, any>;
4812
4807
  callID: string;
4813
4808
  name: string;
4814
4809
  namespace?: string;
4815
- partial?: {
4816
- content?: ({
4810
+ result: {
4811
+ content: ({
4817
4812
  type: "text";
4818
4813
  text: string;
4819
4814
  textSignature?: string;
@@ -4823,8 +4818,9 @@ declare const LLMStarted: Schema.Struct<{
4823
4818
  mimeType: string;
4824
4819
  })[];
4825
4820
  details?: any;
4821
+ isError: false;
4826
4822
  };
4827
- status: "running";
4823
+ status: "completed";
4828
4824
  thoughtSignature?: string;
4829
4825
  time: {
4830
4826
  start: number;
@@ -4848,9 +4844,9 @@ declare const LLMStarted: Schema.Struct<{
4848
4844
  mimeType: string;
4849
4845
  })[];
4850
4846
  details?: any;
4851
- isError: false;
4847
+ isError: true;
4852
4848
  };
4853
- status: "completed";
4849
+ status: "error";
4854
4850
  thoughtSignature?: string;
4855
4851
  time: {
4856
4852
  start: number;
@@ -4876,7 +4872,7 @@ declare const LLMStarted: Schema.Struct<{
4876
4872
  details?: any;
4877
4873
  isError: true;
4878
4874
  };
4879
- status: "error";
4875
+ status: "skipped";
4880
4876
  thoughtSignature?: string;
4881
4877
  time: {
4882
4878
  start: number;
@@ -4902,21 +4898,26 @@ declare const LLMStarted: Schema.Struct<{
4902
4898
  details?: any;
4903
4899
  isError: true;
4904
4900
  };
4905
- status: "skipped";
4901
+ status: "aborted";
4906
4902
  thoughtSignature?: string;
4907
4903
  time: {
4908
4904
  start: number;
4909
4905
  end: number;
4910
4906
  };
4911
4907
  type: "toolCall";
4908
+ } | {
4909
+ type: "thinking";
4910
+ thinking: string;
4911
+ thinkingSignature?: string;
4912
+ redacted?: boolean;
4912
4913
  } | {
4913
4914
  addedToolNames?: string[];
4914
4915
  arguments: Record<string, any>;
4915
4916
  callID: string;
4916
4917
  name: string;
4917
4918
  namespace?: string;
4918
- result: {
4919
- content: ({
4919
+ partial?: {
4920
+ content?: ({
4920
4921
  type: "text";
4921
4922
  text: string;
4922
4923
  textSignature?: string;
@@ -4926,9 +4927,8 @@ declare const LLMStarted: Schema.Struct<{
4926
4927
  mimeType: string;
4927
4928
  })[];
4928
4929
  details?: any;
4929
- isError: true;
4930
4930
  };
4931
- status: "aborted";
4931
+ status: "running";
4932
4932
  thoughtSignature?: string;
4933
4933
  time: {
4934
4934
  start: number;
@@ -5103,19 +5103,14 @@ declare const LLMStarted: Schema.Struct<{
5103
5103
  type: "image";
5104
5104
  data: string;
5105
5105
  mimeType: string;
5106
- } | {
5107
- type: "thinking";
5108
- thinking: string;
5109
- thinkingSignature?: string;
5110
- redacted?: boolean;
5111
5106
  } | {
5112
5107
  addedToolNames?: string[];
5113
5108
  arguments: Record<string, any>;
5114
5109
  callID: string;
5115
5110
  name: string;
5116
5111
  namespace?: string;
5117
- partial?: {
5118
- content?: ({
5112
+ result: {
5113
+ content: ({
5119
5114
  type: "text";
5120
5115
  text: string;
5121
5116
  textSignature?: string;
@@ -5125,8 +5120,9 @@ declare const LLMStarted: Schema.Struct<{
5125
5120
  mimeType: string;
5126
5121
  })[];
5127
5122
  details?: any;
5123
+ isError: false;
5128
5124
  };
5129
- status: "running";
5125
+ status: "completed";
5130
5126
  thoughtSignature?: string;
5131
5127
  time: {
5132
5128
  start: number;
@@ -5150,9 +5146,9 @@ declare const LLMStarted: Schema.Struct<{
5150
5146
  mimeType: string;
5151
5147
  })[];
5152
5148
  details?: any;
5153
- isError: false;
5149
+ isError: true;
5154
5150
  };
5155
- status: "completed";
5151
+ status: "error";
5156
5152
  thoughtSignature?: string;
5157
5153
  time: {
5158
5154
  start: number;
@@ -5178,7 +5174,7 @@ declare const LLMStarted: Schema.Struct<{
5178
5174
  details?: any;
5179
5175
  isError: true;
5180
5176
  };
5181
- status: "error";
5177
+ status: "skipped";
5182
5178
  thoughtSignature?: string;
5183
5179
  time: {
5184
5180
  start: number;
@@ -5204,21 +5200,26 @@ declare const LLMStarted: Schema.Struct<{
5204
5200
  details?: any;
5205
5201
  isError: true;
5206
5202
  };
5207
- status: "skipped";
5203
+ status: "aborted";
5208
5204
  thoughtSignature?: string;
5209
5205
  time: {
5210
5206
  start: number;
5211
5207
  end: number;
5212
5208
  };
5213
5209
  type: "toolCall";
5210
+ } | {
5211
+ type: "thinking";
5212
+ thinking: string;
5213
+ thinkingSignature?: string;
5214
+ redacted?: boolean;
5214
5215
  } | {
5215
5216
  addedToolNames?: string[];
5216
5217
  arguments: Record<string, any>;
5217
5218
  callID: string;
5218
5219
  name: string;
5219
5220
  namespace?: string;
5220
- result: {
5221
- content: ({
5221
+ partial?: {
5222
+ content?: ({
5222
5223
  type: "text";
5223
5224
  text: string;
5224
5225
  textSignature?: string;
@@ -5228,9 +5229,8 @@ declare const LLMStarted: Schema.Struct<{
5228
5229
  mimeType: string;
5229
5230
  })[];
5230
5231
  details?: any;
5231
- isError: true;
5232
5232
  };
5233
- status: "aborted";
5233
+ status: "running";
5234
5234
  thoughtSignature?: string;
5235
5235
  time: {
5236
5236
  start: number;
@@ -5423,19 +5423,14 @@ declare const LLMStarted: Schema.Struct<{
5423
5423
  type: "image";
5424
5424
  data: string;
5425
5425
  mimeType: string;
5426
- } | {
5427
- type: "thinking";
5428
- thinking: string;
5429
- thinkingSignature?: string;
5430
- redacted?: boolean;
5431
5426
  } | {
5432
5427
  addedToolNames?: string[];
5433
5428
  arguments: Record<string, any>;
5434
5429
  callID: string;
5435
5430
  name: string;
5436
5431
  namespace?: string;
5437
- partial?: {
5438
- content?: ({
5432
+ result: {
5433
+ content: ({
5439
5434
  type: "text";
5440
5435
  text: string;
5441
5436
  textSignature?: string;
@@ -5445,8 +5440,9 @@ declare const LLMStarted: Schema.Struct<{
5445
5440
  mimeType: string;
5446
5441
  })[];
5447
5442
  details?: any;
5443
+ isError: false;
5448
5444
  };
5449
- status: "running";
5445
+ status: "completed";
5450
5446
  thoughtSignature?: string;
5451
5447
  time: {
5452
5448
  start: number;
@@ -5470,9 +5466,9 @@ declare const LLMStarted: Schema.Struct<{
5470
5466
  mimeType: string;
5471
5467
  })[];
5472
5468
  details?: any;
5473
- isError: false;
5469
+ isError: true;
5474
5470
  };
5475
- status: "completed";
5471
+ status: "error";
5476
5472
  thoughtSignature?: string;
5477
5473
  time: {
5478
5474
  start: number;
@@ -5498,7 +5494,7 @@ declare const LLMStarted: Schema.Struct<{
5498
5494
  details?: any;
5499
5495
  isError: true;
5500
5496
  };
5501
- status: "error";
5497
+ status: "skipped";
5502
5498
  thoughtSignature?: string;
5503
5499
  time: {
5504
5500
  start: number;
@@ -5524,21 +5520,26 @@ declare const LLMStarted: Schema.Struct<{
5524
5520
  details?: any;
5525
5521
  isError: true;
5526
5522
  };
5527
- status: "skipped";
5523
+ status: "aborted";
5528
5524
  thoughtSignature?: string;
5529
5525
  time: {
5530
5526
  start: number;
5531
5527
  end: number;
5532
5528
  };
5533
5529
  type: "toolCall";
5530
+ } | {
5531
+ type: "thinking";
5532
+ thinking: string;
5533
+ thinkingSignature?: string;
5534
+ redacted?: boolean;
5534
5535
  } | {
5535
5536
  addedToolNames?: string[];
5536
5537
  arguments: Record<string, any>;
5537
5538
  callID: string;
5538
5539
  name: string;
5539
5540
  namespace?: string;
5540
- result: {
5541
- content: ({
5541
+ partial?: {
5542
+ content?: ({
5542
5543
  type: "text";
5543
5544
  text: string;
5544
5545
  textSignature?: string;
@@ -5548,9 +5549,8 @@ declare const LLMStarted: Schema.Struct<{
5548
5549
  mimeType: string;
5549
5550
  })[];
5550
5551
  details?: any;
5551
- isError: true;
5552
5552
  };
5553
- status: "aborted";
5553
+ status: "running";
5554
5554
  thoughtSignature?: string;
5555
5555
  time: {
5556
5556
  start: number;
@@ -5725,19 +5725,14 @@ declare const LLMStarted: Schema.Struct<{
5725
5725
  type: "image";
5726
5726
  data: string;
5727
5727
  mimeType: string;
5728
- } | {
5729
- type: "thinking";
5730
- thinking: string;
5731
- thinkingSignature?: string;
5732
- redacted?: boolean;
5733
5728
  } | {
5734
5729
  addedToolNames?: string[];
5735
5730
  arguments: Record<string, any>;
5736
5731
  callID: string;
5737
5732
  name: string;
5738
5733
  namespace?: string;
5739
- partial?: {
5740
- content?: ({
5734
+ result: {
5735
+ content: ({
5741
5736
  type: "text";
5742
5737
  text: string;
5743
5738
  textSignature?: string;
@@ -5747,8 +5742,9 @@ declare const LLMStarted: Schema.Struct<{
5747
5742
  mimeType: string;
5748
5743
  })[];
5749
5744
  details?: any;
5745
+ isError: false;
5750
5746
  };
5751
- status: "running";
5747
+ status: "completed";
5752
5748
  thoughtSignature?: string;
5753
5749
  time: {
5754
5750
  start: number;
@@ -5772,9 +5768,9 @@ declare const LLMStarted: Schema.Struct<{
5772
5768
  mimeType: string;
5773
5769
  })[];
5774
5770
  details?: any;
5775
- isError: false;
5771
+ isError: true;
5776
5772
  };
5777
- status: "completed";
5773
+ status: "error";
5778
5774
  thoughtSignature?: string;
5779
5775
  time: {
5780
5776
  start: number;
@@ -5800,7 +5796,7 @@ declare const LLMStarted: Schema.Struct<{
5800
5796
  details?: any;
5801
5797
  isError: true;
5802
5798
  };
5803
- status: "error";
5799
+ status: "skipped";
5804
5800
  thoughtSignature?: string;
5805
5801
  time: {
5806
5802
  start: number;
@@ -5826,21 +5822,26 @@ declare const LLMStarted: Schema.Struct<{
5826
5822
  details?: any;
5827
5823
  isError: true;
5828
5824
  };
5829
- status: "skipped";
5825
+ status: "aborted";
5830
5826
  thoughtSignature?: string;
5831
5827
  time: {
5832
5828
  start: number;
5833
5829
  end: number;
5834
5830
  };
5835
5831
  type: "toolCall";
5832
+ } | {
5833
+ type: "thinking";
5834
+ thinking: string;
5835
+ thinkingSignature?: string;
5836
+ redacted?: boolean;
5836
5837
  } | {
5837
5838
  addedToolNames?: string[];
5838
5839
  arguments: Record<string, any>;
5839
5840
  callID: string;
5840
5841
  name: string;
5841
5842
  namespace?: string;
5842
- result: {
5843
- content: ({
5843
+ partial?: {
5844
+ content?: ({
5844
5845
  type: "text";
5845
5846
  text: string;
5846
5847
  textSignature?: string;
@@ -5850,9 +5851,8 @@ declare const LLMStarted: Schema.Struct<{
5850
5851
  mimeType: string;
5851
5852
  })[];
5852
5853
  details?: any;
5853
- isError: true;
5854
5854
  };
5855
- status: "aborted";
5855
+ status: "running";
5856
5856
  thoughtSignature?: string;
5857
5857
  time: {
5858
5858
  start: number;
@@ -6348,19 +6348,14 @@ declare const LLMEnded: Schema.Struct<{
6348
6348
  type: "image";
6349
6349
  data: string;
6350
6350
  mimeType: string;
6351
- } | {
6352
- type: "thinking";
6353
- thinking: string;
6354
- thinkingSignature?: string;
6355
- redacted?: boolean;
6356
6351
  } | {
6357
6352
  addedToolNames?: string[];
6358
6353
  arguments: Record<string, any>;
6359
6354
  callID: string;
6360
6355
  name: string;
6361
6356
  namespace?: string;
6362
- partial?: {
6363
- content?: ({
6357
+ result: {
6358
+ content: ({
6364
6359
  type: "text";
6365
6360
  text: string;
6366
6361
  textSignature?: string;
@@ -6370,8 +6365,9 @@ declare const LLMEnded: Schema.Struct<{
6370
6365
  mimeType: string;
6371
6366
  })[];
6372
6367
  details?: any;
6368
+ isError: false;
6373
6369
  };
6374
- status: "running";
6370
+ status: "completed";
6375
6371
  thoughtSignature?: string;
6376
6372
  time: {
6377
6373
  start: number;
@@ -6395,9 +6391,9 @@ declare const LLMEnded: Schema.Struct<{
6395
6391
  mimeType: string;
6396
6392
  })[];
6397
6393
  details?: any;
6398
- isError: false;
6394
+ isError: true;
6399
6395
  };
6400
- status: "completed";
6396
+ status: "error";
6401
6397
  thoughtSignature?: string;
6402
6398
  time: {
6403
6399
  start: number;
@@ -6423,7 +6419,7 @@ declare const LLMEnded: Schema.Struct<{
6423
6419
  details?: any;
6424
6420
  isError: true;
6425
6421
  };
6426
- status: "error";
6422
+ status: "skipped";
6427
6423
  thoughtSignature?: string;
6428
6424
  time: {
6429
6425
  start: number;
@@ -6449,7 +6445,7 @@ declare const LLMEnded: Schema.Struct<{
6449
6445
  details?: any;
6450
6446
  isError: true;
6451
6447
  };
6452
- status: "skipped";
6448
+ status: "aborted";
6453
6449
  thoughtSignature?: string;
6454
6450
  time: {
6455
6451
  start: number;
@@ -6457,13 +6453,18 @@ declare const LLMEnded: Schema.Struct<{
6457
6453
  };
6458
6454
  type: "toolCall";
6459
6455
  } | {
6460
- addedToolNames?: string[];
6461
- arguments: Record<string, any>;
6462
- callID: string;
6463
- name: string;
6456
+ type: "thinking";
6457
+ thinking: string;
6458
+ thinkingSignature?: string;
6459
+ redacted?: boolean;
6460
+ } | {
6461
+ addedToolNames?: string[];
6462
+ arguments: Record<string, any>;
6463
+ callID: string;
6464
+ name: string;
6464
6465
  namespace?: string;
6465
- result: {
6466
- content: ({
6466
+ partial?: {
6467
+ content?: ({
6467
6468
  type: "text";
6468
6469
  text: string;
6469
6470
  textSignature?: string;
@@ -6473,9 +6474,8 @@ declare const LLMEnded: Schema.Struct<{
6473
6474
  mimeType: string;
6474
6475
  })[];
6475
6476
  details?: any;
6476
- isError: true;
6477
6477
  };
6478
- status: "aborted";
6478
+ status: "running";
6479
6479
  thoughtSignature?: string;
6480
6480
  time: {
6481
6481
  start: number;
@@ -6650,19 +6650,14 @@ declare const LLMEnded: Schema.Struct<{
6650
6650
  type: "image";
6651
6651
  data: string;
6652
6652
  mimeType: string;
6653
- } | {
6654
- type: "thinking";
6655
- thinking: string;
6656
- thinkingSignature?: string;
6657
- redacted?: boolean;
6658
6653
  } | {
6659
6654
  addedToolNames?: string[];
6660
6655
  arguments: Record<string, any>;
6661
6656
  callID: string;
6662
6657
  name: string;
6663
6658
  namespace?: string;
6664
- partial?: {
6665
- content?: ({
6659
+ result: {
6660
+ content: ({
6666
6661
  type: "text";
6667
6662
  text: string;
6668
6663
  textSignature?: string;
@@ -6672,8 +6667,9 @@ declare const LLMEnded: Schema.Struct<{
6672
6667
  mimeType: string;
6673
6668
  })[];
6674
6669
  details?: any;
6670
+ isError: false;
6675
6671
  };
6676
- status: "running";
6672
+ status: "completed";
6677
6673
  thoughtSignature?: string;
6678
6674
  time: {
6679
6675
  start: number;
@@ -6697,9 +6693,9 @@ declare const LLMEnded: Schema.Struct<{
6697
6693
  mimeType: string;
6698
6694
  })[];
6699
6695
  details?: any;
6700
- isError: false;
6696
+ isError: true;
6701
6697
  };
6702
- status: "completed";
6698
+ status: "error";
6703
6699
  thoughtSignature?: string;
6704
6700
  time: {
6705
6701
  start: number;
@@ -6725,7 +6721,7 @@ declare const LLMEnded: Schema.Struct<{
6725
6721
  details?: any;
6726
6722
  isError: true;
6727
6723
  };
6728
- status: "error";
6724
+ status: "skipped";
6729
6725
  thoughtSignature?: string;
6730
6726
  time: {
6731
6727
  start: number;
@@ -6751,21 +6747,26 @@ declare const LLMEnded: Schema.Struct<{
6751
6747
  details?: any;
6752
6748
  isError: true;
6753
6749
  };
6754
- status: "skipped";
6750
+ status: "aborted";
6755
6751
  thoughtSignature?: string;
6756
6752
  time: {
6757
6753
  start: number;
6758
6754
  end: number;
6759
6755
  };
6760
6756
  type: "toolCall";
6757
+ } | {
6758
+ type: "thinking";
6759
+ thinking: string;
6760
+ thinkingSignature?: string;
6761
+ redacted?: boolean;
6761
6762
  } | {
6762
6763
  addedToolNames?: string[];
6763
6764
  arguments: Record<string, any>;
6764
6765
  callID: string;
6765
6766
  name: string;
6766
6767
  namespace?: string;
6767
- result: {
6768
- content: ({
6768
+ partial?: {
6769
+ content?: ({
6769
6770
  type: "text";
6770
6771
  text: string;
6771
6772
  textSignature?: string;
@@ -6775,9 +6776,8 @@ declare const LLMEnded: Schema.Struct<{
6775
6776
  mimeType: string;
6776
6777
  })[];
6777
6778
  details?: any;
6778
- isError: true;
6779
6779
  };
6780
- status: "aborted";
6780
+ status: "running";
6781
6781
  thoughtSignature?: string;
6782
6782
  time: {
6783
6783
  start: number;
@@ -6971,19 +6971,14 @@ declare const LLMEnded: Schema.Struct<{
6971
6971
  type: "image";
6972
6972
  data: string;
6973
6973
  mimeType: string;
6974
- } | {
6975
- type: "thinking";
6976
- thinking: string;
6977
- thinkingSignature?: string;
6978
- redacted?: boolean;
6979
6974
  } | {
6980
6975
  addedToolNames?: string[];
6981
6976
  arguments: Record<string, any>;
6982
6977
  callID: string;
6983
6978
  name: string;
6984
6979
  namespace?: string;
6985
- partial?: {
6986
- content?: ({
6980
+ result: {
6981
+ content: ({
6987
6982
  type: "text";
6988
6983
  text: string;
6989
6984
  textSignature?: string;
@@ -6993,8 +6988,9 @@ declare const LLMEnded: Schema.Struct<{
6993
6988
  mimeType: string;
6994
6989
  })[];
6995
6990
  details?: any;
6991
+ isError: false;
6996
6992
  };
6997
- status: "running";
6993
+ status: "completed";
6998
6994
  thoughtSignature?: string;
6999
6995
  time: {
7000
6996
  start: number;
@@ -7018,9 +7014,9 @@ declare const LLMEnded: Schema.Struct<{
7018
7014
  mimeType: string;
7019
7015
  })[];
7020
7016
  details?: any;
7021
- isError: false;
7017
+ isError: true;
7022
7018
  };
7023
- status: "completed";
7019
+ status: "error";
7024
7020
  thoughtSignature?: string;
7025
7021
  time: {
7026
7022
  start: number;
@@ -7046,7 +7042,7 @@ declare const LLMEnded: Schema.Struct<{
7046
7042
  details?: any;
7047
7043
  isError: true;
7048
7044
  };
7049
- status: "error";
7045
+ status: "skipped";
7050
7046
  thoughtSignature?: string;
7051
7047
  time: {
7052
7048
  start: number;
@@ -7072,21 +7068,26 @@ declare const LLMEnded: Schema.Struct<{
7072
7068
  details?: any;
7073
7069
  isError: true;
7074
7070
  };
7075
- status: "skipped";
7071
+ status: "aborted";
7076
7072
  thoughtSignature?: string;
7077
7073
  time: {
7078
7074
  start: number;
7079
7075
  end: number;
7080
7076
  };
7081
7077
  type: "toolCall";
7078
+ } | {
7079
+ type: "thinking";
7080
+ thinking: string;
7081
+ thinkingSignature?: string;
7082
+ redacted?: boolean;
7082
7083
  } | {
7083
7084
  addedToolNames?: string[];
7084
7085
  arguments: Record<string, any>;
7085
7086
  callID: string;
7086
7087
  name: string;
7087
7088
  namespace?: string;
7088
- result: {
7089
- content: ({
7089
+ partial?: {
7090
+ content?: ({
7090
7091
  type: "text";
7091
7092
  text: string;
7092
7093
  textSignature?: string;
@@ -7096,9 +7097,8 @@ declare const LLMEnded: Schema.Struct<{
7096
7097
  mimeType: string;
7097
7098
  })[];
7098
7099
  details?: any;
7099
- isError: true;
7100
7100
  };
7101
- status: "aborted";
7101
+ status: "running";
7102
7102
  thoughtSignature?: string;
7103
7103
  time: {
7104
7104
  start: number;
@@ -7273,19 +7273,14 @@ declare const LLMEnded: Schema.Struct<{
7273
7273
  type: "image";
7274
7274
  data: string;
7275
7275
  mimeType: string;
7276
- } | {
7277
- type: "thinking";
7278
- thinking: string;
7279
- thinkingSignature?: string;
7280
- redacted?: boolean;
7281
7276
  } | {
7282
7277
  addedToolNames?: string[];
7283
7278
  arguments: Record<string, any>;
7284
7279
  callID: string;
7285
7280
  name: string;
7286
7281
  namespace?: string;
7287
- partial?: {
7288
- content?: ({
7282
+ result: {
7283
+ content: ({
7289
7284
  type: "text";
7290
7285
  text: string;
7291
7286
  textSignature?: string;
@@ -7295,8 +7290,9 @@ declare const LLMEnded: Schema.Struct<{
7295
7290
  mimeType: string;
7296
7291
  })[];
7297
7292
  details?: any;
7293
+ isError: false;
7298
7294
  };
7299
- status: "running";
7295
+ status: "completed";
7300
7296
  thoughtSignature?: string;
7301
7297
  time: {
7302
7298
  start: number;
@@ -7320,9 +7316,9 @@ declare const LLMEnded: Schema.Struct<{
7320
7316
  mimeType: string;
7321
7317
  })[];
7322
7318
  details?: any;
7323
- isError: false;
7319
+ isError: true;
7324
7320
  };
7325
- status: "completed";
7321
+ status: "error";
7326
7322
  thoughtSignature?: string;
7327
7323
  time: {
7328
7324
  start: number;
@@ -7348,7 +7344,7 @@ declare const LLMEnded: Schema.Struct<{
7348
7344
  details?: any;
7349
7345
  isError: true;
7350
7346
  };
7351
- status: "error";
7347
+ status: "skipped";
7352
7348
  thoughtSignature?: string;
7353
7349
  time: {
7354
7350
  start: number;
@@ -7374,21 +7370,26 @@ declare const LLMEnded: Schema.Struct<{
7374
7370
  details?: any;
7375
7371
  isError: true;
7376
7372
  };
7377
- status: "skipped";
7373
+ status: "aborted";
7378
7374
  thoughtSignature?: string;
7379
7375
  time: {
7380
7376
  start: number;
7381
7377
  end: number;
7382
7378
  };
7383
7379
  type: "toolCall";
7380
+ } | {
7381
+ type: "thinking";
7382
+ thinking: string;
7383
+ thinkingSignature?: string;
7384
+ redacted?: boolean;
7384
7385
  } | {
7385
7386
  addedToolNames?: string[];
7386
7387
  arguments: Record<string, any>;
7387
7388
  callID: string;
7388
7389
  name: string;
7389
7390
  namespace?: string;
7390
- result: {
7391
- content: ({
7391
+ partial?: {
7392
+ content?: ({
7392
7393
  type: "text";
7393
7394
  text: string;
7394
7395
  textSignature?: string;
@@ -7398,9 +7399,8 @@ declare const LLMEnded: Schema.Struct<{
7398
7399
  mimeType: string;
7399
7400
  })[];
7400
7401
  details?: any;
7401
- isError: true;
7402
7402
  };
7403
- status: "aborted";
7403
+ status: "running";
7404
7404
  thoughtSignature?: string;
7405
7405
  time: {
7406
7406
  start: number;
@@ -7606,19 +7606,14 @@ declare const LLMFailed: Schema.Struct<{
7606
7606
  type: "image";
7607
7607
  data: string;
7608
7608
  mimeType: string;
7609
- } | {
7610
- type: "thinking";
7611
- thinking: string;
7612
- thinkingSignature?: string;
7613
- redacted?: boolean;
7614
7609
  } | {
7615
7610
  addedToolNames?: string[];
7616
7611
  arguments: Record<string, any>;
7617
7612
  callID: string;
7618
7613
  name: string;
7619
7614
  namespace?: string;
7620
- partial?: {
7621
- content?: ({
7615
+ result: {
7616
+ content: ({
7622
7617
  type: "text";
7623
7618
  text: string;
7624
7619
  textSignature?: string;
@@ -7628,8 +7623,9 @@ declare const LLMFailed: Schema.Struct<{
7628
7623
  mimeType: string;
7629
7624
  })[];
7630
7625
  details?: any;
7626
+ isError: false;
7631
7627
  };
7632
- status: "running";
7628
+ status: "completed";
7633
7629
  thoughtSignature?: string;
7634
7630
  time: {
7635
7631
  start: number;
@@ -7653,9 +7649,9 @@ declare const LLMFailed: Schema.Struct<{
7653
7649
  mimeType: string;
7654
7650
  })[];
7655
7651
  details?: any;
7656
- isError: false;
7652
+ isError: true;
7657
7653
  };
7658
- status: "completed";
7654
+ status: "error";
7659
7655
  thoughtSignature?: string;
7660
7656
  time: {
7661
7657
  start: number;
@@ -7681,7 +7677,7 @@ declare const LLMFailed: Schema.Struct<{
7681
7677
  details?: any;
7682
7678
  isError: true;
7683
7679
  };
7684
- status: "error";
7680
+ status: "skipped";
7685
7681
  thoughtSignature?: string;
7686
7682
  time: {
7687
7683
  start: number;
@@ -7707,21 +7703,26 @@ declare const LLMFailed: Schema.Struct<{
7707
7703
  details?: any;
7708
7704
  isError: true;
7709
7705
  };
7710
- status: "skipped";
7706
+ status: "aborted";
7711
7707
  thoughtSignature?: string;
7712
7708
  time: {
7713
7709
  start: number;
7714
7710
  end: number;
7715
7711
  };
7716
7712
  type: "toolCall";
7713
+ } | {
7714
+ type: "thinking";
7715
+ thinking: string;
7716
+ thinkingSignature?: string;
7717
+ redacted?: boolean;
7717
7718
  } | {
7718
7719
  addedToolNames?: string[];
7719
7720
  arguments: Record<string, any>;
7720
7721
  callID: string;
7721
7722
  name: string;
7722
7723
  namespace?: string;
7723
- result: {
7724
- content: ({
7724
+ partial?: {
7725
+ content?: ({
7725
7726
  type: "text";
7726
7727
  text: string;
7727
7728
  textSignature?: string;
@@ -7731,9 +7732,8 @@ declare const LLMFailed: Schema.Struct<{
7731
7732
  mimeType: string;
7732
7733
  })[];
7733
7734
  details?: any;
7734
- isError: true;
7735
7735
  };
7736
- status: "aborted";
7736
+ status: "running";
7737
7737
  thoughtSignature?: string;
7738
7738
  time: {
7739
7739
  start: number;
@@ -7908,19 +7908,14 @@ declare const LLMFailed: Schema.Struct<{
7908
7908
  type: "image";
7909
7909
  data: string;
7910
7910
  mimeType: string;
7911
- } | {
7912
- type: "thinking";
7913
- thinking: string;
7914
- thinkingSignature?: string;
7915
- redacted?: boolean;
7916
7911
  } | {
7917
7912
  addedToolNames?: string[];
7918
7913
  arguments: Record<string, any>;
7919
7914
  callID: string;
7920
7915
  name: string;
7921
7916
  namespace?: string;
7922
- partial?: {
7923
- content?: ({
7917
+ result: {
7918
+ content: ({
7924
7919
  type: "text";
7925
7920
  text: string;
7926
7921
  textSignature?: string;
@@ -7930,8 +7925,9 @@ declare const LLMFailed: Schema.Struct<{
7930
7925
  mimeType: string;
7931
7926
  })[];
7932
7927
  details?: any;
7928
+ isError: false;
7933
7929
  };
7934
- status: "running";
7930
+ status: "completed";
7935
7931
  thoughtSignature?: string;
7936
7932
  time: {
7937
7933
  start: number;
@@ -7955,9 +7951,9 @@ declare const LLMFailed: Schema.Struct<{
7955
7951
  mimeType: string;
7956
7952
  })[];
7957
7953
  details?: any;
7958
- isError: false;
7954
+ isError: true;
7959
7955
  };
7960
- status: "completed";
7956
+ status: "error";
7961
7957
  thoughtSignature?: string;
7962
7958
  time: {
7963
7959
  start: number;
@@ -7983,7 +7979,7 @@ declare const LLMFailed: Schema.Struct<{
7983
7979
  details?: any;
7984
7980
  isError: true;
7985
7981
  };
7986
- status: "error";
7982
+ status: "skipped";
7987
7983
  thoughtSignature?: string;
7988
7984
  time: {
7989
7985
  start: number;
@@ -8009,21 +8005,26 @@ declare const LLMFailed: Schema.Struct<{
8009
8005
  details?: any;
8010
8006
  isError: true;
8011
8007
  };
8012
- status: "skipped";
8008
+ status: "aborted";
8013
8009
  thoughtSignature?: string;
8014
8010
  time: {
8015
8011
  start: number;
8016
8012
  end: number;
8017
8013
  };
8018
8014
  type: "toolCall";
8015
+ } | {
8016
+ type: "thinking";
8017
+ thinking: string;
8018
+ thinkingSignature?: string;
8019
+ redacted?: boolean;
8019
8020
  } | {
8020
8021
  addedToolNames?: string[];
8021
8022
  arguments: Record<string, any>;
8022
8023
  callID: string;
8023
8024
  name: string;
8024
8025
  namespace?: string;
8025
- result: {
8026
- content: ({
8026
+ partial?: {
8027
+ content?: ({
8027
8028
  type: "text";
8028
8029
  text: string;
8029
8030
  textSignature?: string;
@@ -8033,9 +8034,8 @@ declare const LLMFailed: Schema.Struct<{
8033
8034
  mimeType: string;
8034
8035
  })[];
8035
8036
  details?: any;
8036
- isError: true;
8037
8037
  };
8038
- status: "aborted";
8038
+ status: "running";
8039
8039
  thoughtSignature?: string;
8040
8040
  time: {
8041
8041
  start: number;
@@ -8229,19 +8229,14 @@ declare const LLMFailed: Schema.Struct<{
8229
8229
  type: "image";
8230
8230
  data: string;
8231
8231
  mimeType: string;
8232
- } | {
8233
- type: "thinking";
8234
- thinking: string;
8235
- thinkingSignature?: string;
8236
- redacted?: boolean;
8237
8232
  } | {
8238
8233
  addedToolNames?: string[];
8239
8234
  arguments: Record<string, any>;
8240
8235
  callID: string;
8241
8236
  name: string;
8242
8237
  namespace?: string;
8243
- partial?: {
8244
- content?: ({
8238
+ result: {
8239
+ content: ({
8245
8240
  type: "text";
8246
8241
  text: string;
8247
8242
  textSignature?: string;
@@ -8251,8 +8246,9 @@ declare const LLMFailed: Schema.Struct<{
8251
8246
  mimeType: string;
8252
8247
  })[];
8253
8248
  details?: any;
8249
+ isError: false;
8254
8250
  };
8255
- status: "running";
8251
+ status: "completed";
8256
8252
  thoughtSignature?: string;
8257
8253
  time: {
8258
8254
  start: number;
@@ -8276,9 +8272,9 @@ declare const LLMFailed: Schema.Struct<{
8276
8272
  mimeType: string;
8277
8273
  })[];
8278
8274
  details?: any;
8279
- isError: false;
8275
+ isError: true;
8280
8276
  };
8281
- status: "completed";
8277
+ status: "error";
8282
8278
  thoughtSignature?: string;
8283
8279
  time: {
8284
8280
  start: number;
@@ -8304,7 +8300,7 @@ declare const LLMFailed: Schema.Struct<{
8304
8300
  details?: any;
8305
8301
  isError: true;
8306
8302
  };
8307
- status: "error";
8303
+ status: "skipped";
8308
8304
  thoughtSignature?: string;
8309
8305
  time: {
8310
8306
  start: number;
@@ -8330,21 +8326,26 @@ declare const LLMFailed: Schema.Struct<{
8330
8326
  details?: any;
8331
8327
  isError: true;
8332
8328
  };
8333
- status: "skipped";
8329
+ status: "aborted";
8334
8330
  thoughtSignature?: string;
8335
8331
  time: {
8336
8332
  start: number;
8337
8333
  end: number;
8338
8334
  };
8339
8335
  type: "toolCall";
8336
+ } | {
8337
+ type: "thinking";
8338
+ thinking: string;
8339
+ thinkingSignature?: string;
8340
+ redacted?: boolean;
8340
8341
  } | {
8341
8342
  addedToolNames?: string[];
8342
8343
  arguments: Record<string, any>;
8343
8344
  callID: string;
8344
8345
  name: string;
8345
8346
  namespace?: string;
8346
- result: {
8347
- content: ({
8347
+ partial?: {
8348
+ content?: ({
8348
8349
  type: "text";
8349
8350
  text: string;
8350
8351
  textSignature?: string;
@@ -8354,9 +8355,8 @@ declare const LLMFailed: Schema.Struct<{
8354
8355
  mimeType: string;
8355
8356
  })[];
8356
8357
  details?: any;
8357
- isError: true;
8358
8358
  };
8359
- status: "aborted";
8359
+ status: "running";
8360
8360
  thoughtSignature?: string;
8361
8361
  time: {
8362
8362
  start: number;
@@ -8531,19 +8531,14 @@ declare const LLMFailed: Schema.Struct<{
8531
8531
  type: "image";
8532
8532
  data: string;
8533
8533
  mimeType: string;
8534
- } | {
8535
- type: "thinking";
8536
- thinking: string;
8537
- thinkingSignature?: string;
8538
- redacted?: boolean;
8539
8534
  } | {
8540
8535
  addedToolNames?: string[];
8541
8536
  arguments: Record<string, any>;
8542
8537
  callID: string;
8543
8538
  name: string;
8544
8539
  namespace?: string;
8545
- partial?: {
8546
- content?: ({
8540
+ result: {
8541
+ content: ({
8547
8542
  type: "text";
8548
8543
  text: string;
8549
8544
  textSignature?: string;
@@ -8553,8 +8548,9 @@ declare const LLMFailed: Schema.Struct<{
8553
8548
  mimeType: string;
8554
8549
  })[];
8555
8550
  details?: any;
8551
+ isError: false;
8556
8552
  };
8557
- status: "running";
8553
+ status: "completed";
8558
8554
  thoughtSignature?: string;
8559
8555
  time: {
8560
8556
  start: number;
@@ -8578,9 +8574,9 @@ declare const LLMFailed: Schema.Struct<{
8578
8574
  mimeType: string;
8579
8575
  })[];
8580
8576
  details?: any;
8581
- isError: false;
8577
+ isError: true;
8582
8578
  };
8583
- status: "completed";
8579
+ status: "error";
8584
8580
  thoughtSignature?: string;
8585
8581
  time: {
8586
8582
  start: number;
@@ -8606,7 +8602,7 @@ declare const LLMFailed: Schema.Struct<{
8606
8602
  details?: any;
8607
8603
  isError: true;
8608
8604
  };
8609
- status: "error";
8605
+ status: "skipped";
8610
8606
  thoughtSignature?: string;
8611
8607
  time: {
8612
8608
  start: number;
@@ -8632,21 +8628,26 @@ declare const LLMFailed: Schema.Struct<{
8632
8628
  details?: any;
8633
8629
  isError: true;
8634
8630
  };
8635
- status: "skipped";
8631
+ status: "aborted";
8636
8632
  thoughtSignature?: string;
8637
8633
  time: {
8638
8634
  start: number;
8639
8635
  end: number;
8640
8636
  };
8641
8637
  type: "toolCall";
8638
+ } | {
8639
+ type: "thinking";
8640
+ thinking: string;
8641
+ thinkingSignature?: string;
8642
+ redacted?: boolean;
8642
8643
  } | {
8643
8644
  addedToolNames?: string[];
8644
8645
  arguments: Record<string, any>;
8645
8646
  callID: string;
8646
8647
  name: string;
8647
8648
  namespace?: string;
8648
- result: {
8649
- content: ({
8649
+ partial?: {
8650
+ content?: ({
8650
8651
  type: "text";
8651
8652
  text: string;
8652
8653
  textSignature?: string;
@@ -8656,9 +8657,8 @@ declare const LLMFailed: Schema.Struct<{
8656
8657
  mimeType: string;
8657
8658
  })[];
8658
8659
  details?: any;
8659
- isError: true;
8660
8660
  };
8661
- status: "aborted";
8661
+ status: "running";
8662
8662
  thoughtSignature?: string;
8663
8663
  time: {
8664
8664
  start: number;
@@ -10406,19 +10406,14 @@ declare const Definitions: readonly [Schema.Struct<{
10406
10406
  type: "image";
10407
10407
  data: string;
10408
10408
  mimeType: string;
10409
- } | {
10410
- type: "thinking";
10411
- thinking: string;
10412
- thinkingSignature?: string;
10413
- redacted?: boolean;
10414
10409
  } | {
10415
10410
  addedToolNames?: string[];
10416
10411
  arguments: Record<string, any>;
10417
10412
  callID: string;
10418
10413
  name: string;
10419
10414
  namespace?: string;
10420
- partial?: {
10421
- content?: ({
10415
+ result: {
10416
+ content: ({
10422
10417
  type: "text";
10423
10418
  text: string;
10424
10419
  textSignature?: string;
@@ -10428,8 +10423,9 @@ declare const Definitions: readonly [Schema.Struct<{
10428
10423
  mimeType: string;
10429
10424
  })[];
10430
10425
  details?: any;
10426
+ isError: false;
10431
10427
  };
10432
- status: "running";
10428
+ status: "completed";
10433
10429
  thoughtSignature?: string;
10434
10430
  time: {
10435
10431
  start: number;
@@ -10453,9 +10449,9 @@ declare const Definitions: readonly [Schema.Struct<{
10453
10449
  mimeType: string;
10454
10450
  })[];
10455
10451
  details?: any;
10456
- isError: false;
10452
+ isError: true;
10457
10453
  };
10458
- status: "completed";
10454
+ status: "error";
10459
10455
  thoughtSignature?: string;
10460
10456
  time: {
10461
10457
  start: number;
@@ -10481,7 +10477,7 @@ declare const Definitions: readonly [Schema.Struct<{
10481
10477
  details?: any;
10482
10478
  isError: true;
10483
10479
  };
10484
- status: "error";
10480
+ status: "skipped";
10485
10481
  thoughtSignature?: string;
10486
10482
  time: {
10487
10483
  start: number;
@@ -10507,21 +10503,26 @@ declare const Definitions: readonly [Schema.Struct<{
10507
10503
  details?: any;
10508
10504
  isError: true;
10509
10505
  };
10510
- status: "skipped";
10506
+ status: "aborted";
10511
10507
  thoughtSignature?: string;
10512
10508
  time: {
10513
10509
  start: number;
10514
10510
  end: number;
10515
10511
  };
10516
10512
  type: "toolCall";
10513
+ } | {
10514
+ type: "thinking";
10515
+ thinking: string;
10516
+ thinkingSignature?: string;
10517
+ redacted?: boolean;
10517
10518
  } | {
10518
10519
  addedToolNames?: string[];
10519
10520
  arguments: Record<string, any>;
10520
10521
  callID: string;
10521
10522
  name: string;
10522
10523
  namespace?: string;
10523
- result: {
10524
- content: ({
10524
+ partial?: {
10525
+ content?: ({
10525
10526
  type: "text";
10526
10527
  text: string;
10527
10528
  textSignature?: string;
@@ -10531,9 +10532,8 @@ declare const Definitions: readonly [Schema.Struct<{
10531
10532
  mimeType: string;
10532
10533
  })[];
10533
10534
  details?: any;
10534
- isError: true;
10535
10535
  };
10536
- status: "aborted";
10536
+ status: "running";
10537
10537
  thoughtSignature?: string;
10538
10538
  time: {
10539
10539
  start: number;
@@ -10708,19 +10708,14 @@ declare const Definitions: readonly [Schema.Struct<{
10708
10708
  type: "image";
10709
10709
  data: string;
10710
10710
  mimeType: string;
10711
- } | {
10712
- type: "thinking";
10713
- thinking: string;
10714
- thinkingSignature?: string;
10715
- redacted?: boolean;
10716
10711
  } | {
10717
10712
  addedToolNames?: string[];
10718
10713
  arguments: Record<string, any>;
10719
10714
  callID: string;
10720
10715
  name: string;
10721
10716
  namespace?: string;
10722
- partial?: {
10723
- content?: ({
10717
+ result: {
10718
+ content: ({
10724
10719
  type: "text";
10725
10720
  text: string;
10726
10721
  textSignature?: string;
@@ -10730,8 +10725,9 @@ declare const Definitions: readonly [Schema.Struct<{
10730
10725
  mimeType: string;
10731
10726
  })[];
10732
10727
  details?: any;
10728
+ isError: false;
10733
10729
  };
10734
- status: "running";
10730
+ status: "completed";
10735
10731
  thoughtSignature?: string;
10736
10732
  time: {
10737
10733
  start: number;
@@ -10755,9 +10751,9 @@ declare const Definitions: readonly [Schema.Struct<{
10755
10751
  mimeType: string;
10756
10752
  })[];
10757
10753
  details?: any;
10758
- isError: false;
10754
+ isError: true;
10759
10755
  };
10760
- status: "completed";
10756
+ status: "error";
10761
10757
  thoughtSignature?: string;
10762
10758
  time: {
10763
10759
  start: number;
@@ -10783,7 +10779,7 @@ declare const Definitions: readonly [Schema.Struct<{
10783
10779
  details?: any;
10784
10780
  isError: true;
10785
10781
  };
10786
- status: "error";
10782
+ status: "skipped";
10787
10783
  thoughtSignature?: string;
10788
10784
  time: {
10789
10785
  start: number;
@@ -10809,21 +10805,26 @@ declare const Definitions: readonly [Schema.Struct<{
10809
10805
  details?: any;
10810
10806
  isError: true;
10811
10807
  };
10812
- status: "skipped";
10808
+ status: "aborted";
10813
10809
  thoughtSignature?: string;
10814
10810
  time: {
10815
10811
  start: number;
10816
10812
  end: number;
10817
10813
  };
10818
10814
  type: "toolCall";
10815
+ } | {
10816
+ type: "thinking";
10817
+ thinking: string;
10818
+ thinkingSignature?: string;
10819
+ redacted?: boolean;
10819
10820
  } | {
10820
10821
  addedToolNames?: string[];
10821
10822
  arguments: Record<string, any>;
10822
10823
  callID: string;
10823
10824
  name: string;
10824
10825
  namespace?: string;
10825
- result: {
10826
- content: ({
10826
+ partial?: {
10827
+ content?: ({
10827
10828
  type: "text";
10828
10829
  text: string;
10829
10830
  textSignature?: string;
@@ -10833,9 +10834,8 @@ declare const Definitions: readonly [Schema.Struct<{
10833
10834
  mimeType: string;
10834
10835
  })[];
10835
10836
  details?: any;
10836
- isError: true;
10837
10837
  };
10838
- status: "aborted";
10838
+ status: "running";
10839
10839
  thoughtSignature?: string;
10840
10840
  time: {
10841
10841
  start: number;
@@ -11028,19 +11028,14 @@ declare const Definitions: readonly [Schema.Struct<{
11028
11028
  type: "image";
11029
11029
  data: string;
11030
11030
  mimeType: string;
11031
- } | {
11032
- type: "thinking";
11033
- thinking: string;
11034
- thinkingSignature?: string;
11035
- redacted?: boolean;
11036
11031
  } | {
11037
11032
  addedToolNames?: string[];
11038
11033
  arguments: Record<string, any>;
11039
11034
  callID: string;
11040
11035
  name: string;
11041
11036
  namespace?: string;
11042
- partial?: {
11043
- content?: ({
11037
+ result: {
11038
+ content: ({
11044
11039
  type: "text";
11045
11040
  text: string;
11046
11041
  textSignature?: string;
@@ -11050,8 +11045,9 @@ declare const Definitions: readonly [Schema.Struct<{
11050
11045
  mimeType: string;
11051
11046
  })[];
11052
11047
  details?: any;
11048
+ isError: false;
11053
11049
  };
11054
- status: "running";
11050
+ status: "completed";
11055
11051
  thoughtSignature?: string;
11056
11052
  time: {
11057
11053
  start: number;
@@ -11075,9 +11071,9 @@ declare const Definitions: readonly [Schema.Struct<{
11075
11071
  mimeType: string;
11076
11072
  })[];
11077
11073
  details?: any;
11078
- isError: false;
11074
+ isError: true;
11079
11075
  };
11080
- status: "completed";
11076
+ status: "error";
11081
11077
  thoughtSignature?: string;
11082
11078
  time: {
11083
11079
  start: number;
@@ -11103,7 +11099,7 @@ declare const Definitions: readonly [Schema.Struct<{
11103
11099
  details?: any;
11104
11100
  isError: true;
11105
11101
  };
11106
- status: "error";
11102
+ status: "skipped";
11107
11103
  thoughtSignature?: string;
11108
11104
  time: {
11109
11105
  start: number;
@@ -11129,21 +11125,26 @@ declare const Definitions: readonly [Schema.Struct<{
11129
11125
  details?: any;
11130
11126
  isError: true;
11131
11127
  };
11132
- status: "skipped";
11128
+ status: "aborted";
11133
11129
  thoughtSignature?: string;
11134
11130
  time: {
11135
11131
  start: number;
11136
11132
  end: number;
11137
11133
  };
11138
11134
  type: "toolCall";
11135
+ } | {
11136
+ type: "thinking";
11137
+ thinking: string;
11138
+ thinkingSignature?: string;
11139
+ redacted?: boolean;
11139
11140
  } | {
11140
11141
  addedToolNames?: string[];
11141
11142
  arguments: Record<string, any>;
11142
11143
  callID: string;
11143
11144
  name: string;
11144
11145
  namespace?: string;
11145
- result: {
11146
- content: ({
11146
+ partial?: {
11147
+ content?: ({
11147
11148
  type: "text";
11148
11149
  text: string;
11149
11150
  textSignature?: string;
@@ -11153,9 +11154,8 @@ declare const Definitions: readonly [Schema.Struct<{
11153
11154
  mimeType: string;
11154
11155
  })[];
11155
11156
  details?: any;
11156
- isError: true;
11157
11157
  };
11158
- status: "aborted";
11158
+ status: "running";
11159
11159
  thoughtSignature?: string;
11160
11160
  time: {
11161
11161
  start: number;
@@ -11330,19 +11330,14 @@ declare const Definitions: readonly [Schema.Struct<{
11330
11330
  type: "image";
11331
11331
  data: string;
11332
11332
  mimeType: string;
11333
- } | {
11334
- type: "thinking";
11335
- thinking: string;
11336
- thinkingSignature?: string;
11337
- redacted?: boolean;
11338
11333
  } | {
11339
11334
  addedToolNames?: string[];
11340
11335
  arguments: Record<string, any>;
11341
11336
  callID: string;
11342
11337
  name: string;
11343
11338
  namespace?: string;
11344
- partial?: {
11345
- content?: ({
11339
+ result: {
11340
+ content: ({
11346
11341
  type: "text";
11347
11342
  text: string;
11348
11343
  textSignature?: string;
@@ -11352,8 +11347,9 @@ declare const Definitions: readonly [Schema.Struct<{
11352
11347
  mimeType: string;
11353
11348
  })[];
11354
11349
  details?: any;
11350
+ isError: false;
11355
11351
  };
11356
- status: "running";
11352
+ status: "completed";
11357
11353
  thoughtSignature?: string;
11358
11354
  time: {
11359
11355
  start: number;
@@ -11377,9 +11373,9 @@ declare const Definitions: readonly [Schema.Struct<{
11377
11373
  mimeType: string;
11378
11374
  })[];
11379
11375
  details?: any;
11380
- isError: false;
11376
+ isError: true;
11381
11377
  };
11382
- status: "completed";
11378
+ status: "error";
11383
11379
  thoughtSignature?: string;
11384
11380
  time: {
11385
11381
  start: number;
@@ -11405,7 +11401,7 @@ declare const Definitions: readonly [Schema.Struct<{
11405
11401
  details?: any;
11406
11402
  isError: true;
11407
11403
  };
11408
- status: "error";
11404
+ status: "skipped";
11409
11405
  thoughtSignature?: string;
11410
11406
  time: {
11411
11407
  start: number;
@@ -11431,21 +11427,26 @@ declare const Definitions: readonly [Schema.Struct<{
11431
11427
  details?: any;
11432
11428
  isError: true;
11433
11429
  };
11434
- status: "skipped";
11430
+ status: "aborted";
11435
11431
  thoughtSignature?: string;
11436
11432
  time: {
11437
11433
  start: number;
11438
11434
  end: number;
11439
11435
  };
11440
11436
  type: "toolCall";
11437
+ } | {
11438
+ type: "thinking";
11439
+ thinking: string;
11440
+ thinkingSignature?: string;
11441
+ redacted?: boolean;
11441
11442
  } | {
11442
11443
  addedToolNames?: string[];
11443
11444
  arguments: Record<string, any>;
11444
11445
  callID: string;
11445
11446
  name: string;
11446
11447
  namespace?: string;
11447
- result: {
11448
- content: ({
11448
+ partial?: {
11449
+ content?: ({
11449
11450
  type: "text";
11450
11451
  text: string;
11451
11452
  textSignature?: string;
@@ -11455,9 +11456,8 @@ declare const Definitions: readonly [Schema.Struct<{
11455
11456
  mimeType: string;
11456
11457
  })[];
11457
11458
  details?: any;
11458
- isError: true;
11459
11459
  };
11460
- status: "aborted";
11460
+ status: "running";
11461
11461
  thoughtSignature?: string;
11462
11462
  time: {
11463
11463
  start: number;
@@ -11938,19 +11938,14 @@ declare const Definitions: readonly [Schema.Struct<{
11938
11938
  type: "image";
11939
11939
  data: string;
11940
11940
  mimeType: string;
11941
- } | {
11942
- type: "thinking";
11943
- thinking: string;
11944
- thinkingSignature?: string;
11945
- redacted?: boolean;
11946
11941
  } | {
11947
11942
  addedToolNames?: string[];
11948
11943
  arguments: Record<string, any>;
11949
11944
  callID: string;
11950
11945
  name: string;
11951
11946
  namespace?: string;
11952
- partial?: {
11953
- content?: ({
11947
+ result: {
11948
+ content: ({
11954
11949
  type: "text";
11955
11950
  text: string;
11956
11951
  textSignature?: string;
@@ -11960,8 +11955,9 @@ declare const Definitions: readonly [Schema.Struct<{
11960
11955
  mimeType: string;
11961
11956
  })[];
11962
11957
  details?: any;
11958
+ isError: false;
11963
11959
  };
11964
- status: "running";
11960
+ status: "completed";
11965
11961
  thoughtSignature?: string;
11966
11962
  time: {
11967
11963
  start: number;
@@ -11985,9 +11981,9 @@ declare const Definitions: readonly [Schema.Struct<{
11985
11981
  mimeType: string;
11986
11982
  })[];
11987
11983
  details?: any;
11988
- isError: false;
11984
+ isError: true;
11989
11985
  };
11990
- status: "completed";
11986
+ status: "error";
11991
11987
  thoughtSignature?: string;
11992
11988
  time: {
11993
11989
  start: number;
@@ -12013,7 +12009,7 @@ declare const Definitions: readonly [Schema.Struct<{
12013
12009
  details?: any;
12014
12010
  isError: true;
12015
12011
  };
12016
- status: "error";
12012
+ status: "skipped";
12017
12013
  thoughtSignature?: string;
12018
12014
  time: {
12019
12015
  start: number;
@@ -12039,21 +12035,26 @@ declare const Definitions: readonly [Schema.Struct<{
12039
12035
  details?: any;
12040
12036
  isError: true;
12041
12037
  };
12042
- status: "skipped";
12038
+ status: "aborted";
12043
12039
  thoughtSignature?: string;
12044
12040
  time: {
12045
12041
  start: number;
12046
12042
  end: number;
12047
12043
  };
12048
12044
  type: "toolCall";
12045
+ } | {
12046
+ type: "thinking";
12047
+ thinking: string;
12048
+ thinkingSignature?: string;
12049
+ redacted?: boolean;
12049
12050
  } | {
12050
12051
  addedToolNames?: string[];
12051
12052
  arguments: Record<string, any>;
12052
12053
  callID: string;
12053
12054
  name: string;
12054
12055
  namespace?: string;
12055
- result: {
12056
- content: ({
12056
+ partial?: {
12057
+ content?: ({
12057
12058
  type: "text";
12058
12059
  text: string;
12059
12060
  textSignature?: string;
@@ -12063,9 +12064,8 @@ declare const Definitions: readonly [Schema.Struct<{
12063
12064
  mimeType: string;
12064
12065
  })[];
12065
12066
  details?: any;
12066
- isError: true;
12067
12067
  };
12068
- status: "aborted";
12068
+ status: "running";
12069
12069
  thoughtSignature?: string;
12070
12070
  time: {
12071
12071
  start: number;
@@ -12240,19 +12240,14 @@ declare const Definitions: readonly [Schema.Struct<{
12240
12240
  type: "image";
12241
12241
  data: string;
12242
12242
  mimeType: string;
12243
- } | {
12244
- type: "thinking";
12245
- thinking: string;
12246
- thinkingSignature?: string;
12247
- redacted?: boolean;
12248
12243
  } | {
12249
12244
  addedToolNames?: string[];
12250
12245
  arguments: Record<string, any>;
12251
12246
  callID: string;
12252
12247
  name: string;
12253
12248
  namespace?: string;
12254
- partial?: {
12255
- content?: ({
12249
+ result: {
12250
+ content: ({
12256
12251
  type: "text";
12257
12252
  text: string;
12258
12253
  textSignature?: string;
@@ -12262,8 +12257,9 @@ declare const Definitions: readonly [Schema.Struct<{
12262
12257
  mimeType: string;
12263
12258
  })[];
12264
12259
  details?: any;
12260
+ isError: false;
12265
12261
  };
12266
- status: "running";
12262
+ status: "completed";
12267
12263
  thoughtSignature?: string;
12268
12264
  time: {
12269
12265
  start: number;
@@ -12287,9 +12283,9 @@ declare const Definitions: readonly [Schema.Struct<{
12287
12283
  mimeType: string;
12288
12284
  })[];
12289
12285
  details?: any;
12290
- isError: false;
12286
+ isError: true;
12291
12287
  };
12292
- status: "completed";
12288
+ status: "error";
12293
12289
  thoughtSignature?: string;
12294
12290
  time: {
12295
12291
  start: number;
@@ -12315,7 +12311,7 @@ declare const Definitions: readonly [Schema.Struct<{
12315
12311
  details?: any;
12316
12312
  isError: true;
12317
12313
  };
12318
- status: "error";
12314
+ status: "skipped";
12319
12315
  thoughtSignature?: string;
12320
12316
  time: {
12321
12317
  start: number;
@@ -12341,21 +12337,26 @@ declare const Definitions: readonly [Schema.Struct<{
12341
12337
  details?: any;
12342
12338
  isError: true;
12343
12339
  };
12344
- status: "skipped";
12340
+ status: "aborted";
12345
12341
  thoughtSignature?: string;
12346
12342
  time: {
12347
12343
  start: number;
12348
12344
  end: number;
12349
12345
  };
12350
12346
  type: "toolCall";
12347
+ } | {
12348
+ type: "thinking";
12349
+ thinking: string;
12350
+ thinkingSignature?: string;
12351
+ redacted?: boolean;
12351
12352
  } | {
12352
12353
  addedToolNames?: string[];
12353
12354
  arguments: Record<string, any>;
12354
12355
  callID: string;
12355
12356
  name: string;
12356
12357
  namespace?: string;
12357
- result: {
12358
- content: ({
12358
+ partial?: {
12359
+ content?: ({
12359
12360
  type: "text";
12360
12361
  text: string;
12361
12362
  textSignature?: string;
@@ -12365,9 +12366,8 @@ declare const Definitions: readonly [Schema.Struct<{
12365
12366
  mimeType: string;
12366
12367
  })[];
12367
12368
  details?: any;
12368
- isError: true;
12369
12369
  };
12370
- status: "aborted";
12370
+ status: "running";
12371
12371
  thoughtSignature?: string;
12372
12372
  time: {
12373
12373
  start: number;
@@ -12561,19 +12561,14 @@ declare const Definitions: readonly [Schema.Struct<{
12561
12561
  type: "image";
12562
12562
  data: string;
12563
12563
  mimeType: string;
12564
- } | {
12565
- type: "thinking";
12566
- thinking: string;
12567
- thinkingSignature?: string;
12568
- redacted?: boolean;
12569
12564
  } | {
12570
12565
  addedToolNames?: string[];
12571
12566
  arguments: Record<string, any>;
12572
12567
  callID: string;
12573
12568
  name: string;
12574
12569
  namespace?: string;
12575
- partial?: {
12576
- content?: ({
12570
+ result: {
12571
+ content: ({
12577
12572
  type: "text";
12578
12573
  text: string;
12579
12574
  textSignature?: string;
@@ -12583,8 +12578,9 @@ declare const Definitions: readonly [Schema.Struct<{
12583
12578
  mimeType: string;
12584
12579
  })[];
12585
12580
  details?: any;
12581
+ isError: false;
12586
12582
  };
12587
- status: "running";
12583
+ status: "completed";
12588
12584
  thoughtSignature?: string;
12589
12585
  time: {
12590
12586
  start: number;
@@ -12608,9 +12604,9 @@ declare const Definitions: readonly [Schema.Struct<{
12608
12604
  mimeType: string;
12609
12605
  })[];
12610
12606
  details?: any;
12611
- isError: false;
12607
+ isError: true;
12612
12608
  };
12613
- status: "completed";
12609
+ status: "error";
12614
12610
  thoughtSignature?: string;
12615
12611
  time: {
12616
12612
  start: number;
@@ -12636,7 +12632,7 @@ declare const Definitions: readonly [Schema.Struct<{
12636
12632
  details?: any;
12637
12633
  isError: true;
12638
12634
  };
12639
- status: "error";
12635
+ status: "skipped";
12640
12636
  thoughtSignature?: string;
12641
12637
  time: {
12642
12638
  start: number;
@@ -12662,21 +12658,26 @@ declare const Definitions: readonly [Schema.Struct<{
12662
12658
  details?: any;
12663
12659
  isError: true;
12664
12660
  };
12665
- status: "skipped";
12661
+ status: "aborted";
12666
12662
  thoughtSignature?: string;
12667
12663
  time: {
12668
12664
  start: number;
12669
12665
  end: number;
12670
12666
  };
12671
12667
  type: "toolCall";
12668
+ } | {
12669
+ type: "thinking";
12670
+ thinking: string;
12671
+ thinkingSignature?: string;
12672
+ redacted?: boolean;
12672
12673
  } | {
12673
12674
  addedToolNames?: string[];
12674
12675
  arguments: Record<string, any>;
12675
12676
  callID: string;
12676
12677
  name: string;
12677
12678
  namespace?: string;
12678
- result: {
12679
- content: ({
12679
+ partial?: {
12680
+ content?: ({
12680
12681
  type: "text";
12681
12682
  text: string;
12682
12683
  textSignature?: string;
@@ -12686,9 +12687,8 @@ declare const Definitions: readonly [Schema.Struct<{
12686
12687
  mimeType: string;
12687
12688
  })[];
12688
12689
  details?: any;
12689
- isError: true;
12690
12690
  };
12691
- status: "aborted";
12691
+ status: "running";
12692
12692
  thoughtSignature?: string;
12693
12693
  time: {
12694
12694
  start: number;
@@ -12863,19 +12863,14 @@ declare const Definitions: readonly [Schema.Struct<{
12863
12863
  type: "image";
12864
12864
  data: string;
12865
12865
  mimeType: string;
12866
- } | {
12867
- type: "thinking";
12868
- thinking: string;
12869
- thinkingSignature?: string;
12870
- redacted?: boolean;
12871
12866
  } | {
12872
12867
  addedToolNames?: string[];
12873
12868
  arguments: Record<string, any>;
12874
12869
  callID: string;
12875
12870
  name: string;
12876
12871
  namespace?: string;
12877
- partial?: {
12878
- content?: ({
12872
+ result: {
12873
+ content: ({
12879
12874
  type: "text";
12880
12875
  text: string;
12881
12876
  textSignature?: string;
@@ -12885,8 +12880,9 @@ declare const Definitions: readonly [Schema.Struct<{
12885
12880
  mimeType: string;
12886
12881
  })[];
12887
12882
  details?: any;
12883
+ isError: false;
12888
12884
  };
12889
- status: "running";
12885
+ status: "completed";
12890
12886
  thoughtSignature?: string;
12891
12887
  time: {
12892
12888
  start: number;
@@ -12910,9 +12906,9 @@ declare const Definitions: readonly [Schema.Struct<{
12910
12906
  mimeType: string;
12911
12907
  })[];
12912
12908
  details?: any;
12913
- isError: false;
12909
+ isError: true;
12914
12910
  };
12915
- status: "completed";
12911
+ status: "error";
12916
12912
  thoughtSignature?: string;
12917
12913
  time: {
12918
12914
  start: number;
@@ -12938,7 +12934,7 @@ declare const Definitions: readonly [Schema.Struct<{
12938
12934
  details?: any;
12939
12935
  isError: true;
12940
12936
  };
12941
- status: "error";
12937
+ status: "skipped";
12942
12938
  thoughtSignature?: string;
12943
12939
  time: {
12944
12940
  start: number;
@@ -12964,21 +12960,26 @@ declare const Definitions: readonly [Schema.Struct<{
12964
12960
  details?: any;
12965
12961
  isError: true;
12966
12962
  };
12967
- status: "skipped";
12963
+ status: "aborted";
12968
12964
  thoughtSignature?: string;
12969
12965
  time: {
12970
12966
  start: number;
12971
12967
  end: number;
12972
12968
  };
12973
12969
  type: "toolCall";
12970
+ } | {
12971
+ type: "thinking";
12972
+ thinking: string;
12973
+ thinkingSignature?: string;
12974
+ redacted?: boolean;
12974
12975
  } | {
12975
12976
  addedToolNames?: string[];
12976
12977
  arguments: Record<string, any>;
12977
12978
  callID: string;
12978
12979
  name: string;
12979
12980
  namespace?: string;
12980
- result: {
12981
- content: ({
12981
+ partial?: {
12982
+ content?: ({
12982
12983
  type: "text";
12983
12984
  text: string;
12984
12985
  textSignature?: string;
@@ -12988,9 +12989,8 @@ declare const Definitions: readonly [Schema.Struct<{
12988
12989
  mimeType: string;
12989
12990
  })[];
12990
12991
  details?: any;
12991
- isError: true;
12992
12992
  };
12993
- status: "aborted";
12993
+ status: "running";
12994
12994
  thoughtSignature?: string;
12995
12995
  time: {
12996
12996
  start: number;
@@ -13193,19 +13193,14 @@ declare const Definitions: readonly [Schema.Struct<{
13193
13193
  type: "image";
13194
13194
  data: string;
13195
13195
  mimeType: string;
13196
- } | {
13197
- type: "thinking";
13198
- thinking: string;
13199
- thinkingSignature?: string;
13200
- redacted?: boolean;
13201
13196
  } | {
13202
13197
  addedToolNames?: string[];
13203
13198
  arguments: Record<string, any>;
13204
13199
  callID: string;
13205
13200
  name: string;
13206
13201
  namespace?: string;
13207
- partial?: {
13208
- content?: ({
13202
+ result: {
13203
+ content: ({
13209
13204
  type: "text";
13210
13205
  text: string;
13211
13206
  textSignature?: string;
@@ -13215,8 +13210,9 @@ declare const Definitions: readonly [Schema.Struct<{
13215
13210
  mimeType: string;
13216
13211
  })[];
13217
13212
  details?: any;
13213
+ isError: false;
13218
13214
  };
13219
- status: "running";
13215
+ status: "completed";
13220
13216
  thoughtSignature?: string;
13221
13217
  time: {
13222
13218
  start: number;
@@ -13240,9 +13236,9 @@ declare const Definitions: readonly [Schema.Struct<{
13240
13236
  mimeType: string;
13241
13237
  })[];
13242
13238
  details?: any;
13243
- isError: false;
13239
+ isError: true;
13244
13240
  };
13245
- status: "completed";
13241
+ status: "error";
13246
13242
  thoughtSignature?: string;
13247
13243
  time: {
13248
13244
  start: number;
@@ -13268,7 +13264,7 @@ declare const Definitions: readonly [Schema.Struct<{
13268
13264
  details?: any;
13269
13265
  isError: true;
13270
13266
  };
13271
- status: "error";
13267
+ status: "skipped";
13272
13268
  thoughtSignature?: string;
13273
13269
  time: {
13274
13270
  start: number;
@@ -13294,21 +13290,26 @@ declare const Definitions: readonly [Schema.Struct<{
13294
13290
  details?: any;
13295
13291
  isError: true;
13296
13292
  };
13297
- status: "skipped";
13293
+ status: "aborted";
13298
13294
  thoughtSignature?: string;
13299
13295
  time: {
13300
13296
  start: number;
13301
13297
  end: number;
13302
13298
  };
13303
13299
  type: "toolCall";
13300
+ } | {
13301
+ type: "thinking";
13302
+ thinking: string;
13303
+ thinkingSignature?: string;
13304
+ redacted?: boolean;
13304
13305
  } | {
13305
13306
  addedToolNames?: string[];
13306
13307
  arguments: Record<string, any>;
13307
13308
  callID: string;
13308
13309
  name: string;
13309
13310
  namespace?: string;
13310
- result: {
13311
- content: ({
13311
+ partial?: {
13312
+ content?: ({
13312
13313
  type: "text";
13313
13314
  text: string;
13314
13315
  textSignature?: string;
@@ -13318,9 +13319,8 @@ declare const Definitions: readonly [Schema.Struct<{
13318
13319
  mimeType: string;
13319
13320
  })[];
13320
13321
  details?: any;
13321
- isError: true;
13322
13322
  };
13323
- status: "aborted";
13323
+ status: "running";
13324
13324
  thoughtSignature?: string;
13325
13325
  time: {
13326
13326
  start: number;
@@ -13495,19 +13495,14 @@ declare const Definitions: readonly [Schema.Struct<{
13495
13495
  type: "image";
13496
13496
  data: string;
13497
13497
  mimeType: string;
13498
- } | {
13499
- type: "thinking";
13500
- thinking: string;
13501
- thinkingSignature?: string;
13502
- redacted?: boolean;
13503
13498
  } | {
13504
13499
  addedToolNames?: string[];
13505
13500
  arguments: Record<string, any>;
13506
13501
  callID: string;
13507
13502
  name: string;
13508
13503
  namespace?: string;
13509
- partial?: {
13510
- content?: ({
13504
+ result: {
13505
+ content: ({
13511
13506
  type: "text";
13512
13507
  text: string;
13513
13508
  textSignature?: string;
@@ -13517,8 +13512,9 @@ declare const Definitions: readonly [Schema.Struct<{
13517
13512
  mimeType: string;
13518
13513
  })[];
13519
13514
  details?: any;
13515
+ isError: false;
13520
13516
  };
13521
- status: "running";
13517
+ status: "completed";
13522
13518
  thoughtSignature?: string;
13523
13519
  time: {
13524
13520
  start: number;
@@ -13542,9 +13538,9 @@ declare const Definitions: readonly [Schema.Struct<{
13542
13538
  mimeType: string;
13543
13539
  })[];
13544
13540
  details?: any;
13545
- isError: false;
13541
+ isError: true;
13546
13542
  };
13547
- status: "completed";
13543
+ status: "error";
13548
13544
  thoughtSignature?: string;
13549
13545
  time: {
13550
13546
  start: number;
@@ -13570,7 +13566,7 @@ declare const Definitions: readonly [Schema.Struct<{
13570
13566
  details?: any;
13571
13567
  isError: true;
13572
13568
  };
13573
- status: "error";
13569
+ status: "skipped";
13574
13570
  thoughtSignature?: string;
13575
13571
  time: {
13576
13572
  start: number;
@@ -13596,21 +13592,26 @@ declare const Definitions: readonly [Schema.Struct<{
13596
13592
  details?: any;
13597
13593
  isError: true;
13598
13594
  };
13599
- status: "skipped";
13595
+ status: "aborted";
13600
13596
  thoughtSignature?: string;
13601
13597
  time: {
13602
13598
  start: number;
13603
13599
  end: number;
13604
13600
  };
13605
13601
  type: "toolCall";
13602
+ } | {
13603
+ type: "thinking";
13604
+ thinking: string;
13605
+ thinkingSignature?: string;
13606
+ redacted?: boolean;
13606
13607
  } | {
13607
13608
  addedToolNames?: string[];
13608
13609
  arguments: Record<string, any>;
13609
13610
  callID: string;
13610
13611
  name: string;
13611
13612
  namespace?: string;
13612
- result: {
13613
- content: ({
13613
+ partial?: {
13614
+ content?: ({
13614
13615
  type: "text";
13615
13616
  text: string;
13616
13617
  textSignature?: string;
@@ -13620,9 +13621,8 @@ declare const Definitions: readonly [Schema.Struct<{
13620
13621
  mimeType: string;
13621
13622
  })[];
13622
13623
  details?: any;
13623
- isError: true;
13624
13624
  };
13625
- status: "aborted";
13625
+ status: "running";
13626
13626
  thoughtSignature?: string;
13627
13627
  time: {
13628
13628
  start: number;
@@ -13816,19 +13816,14 @@ declare const Definitions: readonly [Schema.Struct<{
13816
13816
  type: "image";
13817
13817
  data: string;
13818
13818
  mimeType: string;
13819
- } | {
13820
- type: "thinking";
13821
- thinking: string;
13822
- thinkingSignature?: string;
13823
- redacted?: boolean;
13824
13819
  } | {
13825
13820
  addedToolNames?: string[];
13826
13821
  arguments: Record<string, any>;
13827
13822
  callID: string;
13828
13823
  name: string;
13829
13824
  namespace?: string;
13830
- partial?: {
13831
- content?: ({
13825
+ result: {
13826
+ content: ({
13832
13827
  type: "text";
13833
13828
  text: string;
13834
13829
  textSignature?: string;
@@ -13838,8 +13833,9 @@ declare const Definitions: readonly [Schema.Struct<{
13838
13833
  mimeType: string;
13839
13834
  })[];
13840
13835
  details?: any;
13836
+ isError: false;
13841
13837
  };
13842
- status: "running";
13838
+ status: "completed";
13843
13839
  thoughtSignature?: string;
13844
13840
  time: {
13845
13841
  start: number;
@@ -13863,9 +13859,9 @@ declare const Definitions: readonly [Schema.Struct<{
13863
13859
  mimeType: string;
13864
13860
  })[];
13865
13861
  details?: any;
13866
- isError: false;
13862
+ isError: true;
13867
13863
  };
13868
- status: "completed";
13864
+ status: "error";
13869
13865
  thoughtSignature?: string;
13870
13866
  time: {
13871
13867
  start: number;
@@ -13891,7 +13887,7 @@ declare const Definitions: readonly [Schema.Struct<{
13891
13887
  details?: any;
13892
13888
  isError: true;
13893
13889
  };
13894
- status: "error";
13890
+ status: "skipped";
13895
13891
  thoughtSignature?: string;
13896
13892
  time: {
13897
13893
  start: number;
@@ -13917,21 +13913,26 @@ declare const Definitions: readonly [Schema.Struct<{
13917
13913
  details?: any;
13918
13914
  isError: true;
13919
13915
  };
13920
- status: "skipped";
13916
+ status: "aborted";
13921
13917
  thoughtSignature?: string;
13922
13918
  time: {
13923
13919
  start: number;
13924
13920
  end: number;
13925
13921
  };
13926
13922
  type: "toolCall";
13923
+ } | {
13924
+ type: "thinking";
13925
+ thinking: string;
13926
+ thinkingSignature?: string;
13927
+ redacted?: boolean;
13927
13928
  } | {
13928
13929
  addedToolNames?: string[];
13929
13930
  arguments: Record<string, any>;
13930
13931
  callID: string;
13931
13932
  name: string;
13932
13933
  namespace?: string;
13933
- result: {
13934
- content: ({
13934
+ partial?: {
13935
+ content?: ({
13935
13936
  type: "text";
13936
13937
  text: string;
13937
13938
  textSignature?: string;
@@ -13941,9 +13942,8 @@ declare const Definitions: readonly [Schema.Struct<{
13941
13942
  mimeType: string;
13942
13943
  })[];
13943
13944
  details?: any;
13944
- isError: true;
13945
13945
  };
13946
- status: "aborted";
13946
+ status: "running";
13947
13947
  thoughtSignature?: string;
13948
13948
  time: {
13949
13949
  start: number;
@@ -14118,19 +14118,14 @@ declare const Definitions: readonly [Schema.Struct<{
14118
14118
  type: "image";
14119
14119
  data: string;
14120
14120
  mimeType: string;
14121
- } | {
14122
- type: "thinking";
14123
- thinking: string;
14124
- thinkingSignature?: string;
14125
- redacted?: boolean;
14126
14121
  } | {
14127
14122
  addedToolNames?: string[];
14128
14123
  arguments: Record<string, any>;
14129
14124
  callID: string;
14130
14125
  name: string;
14131
14126
  namespace?: string;
14132
- partial?: {
14133
- content?: ({
14127
+ result: {
14128
+ content: ({
14134
14129
  type: "text";
14135
14130
  text: string;
14136
14131
  textSignature?: string;
@@ -14140,8 +14135,9 @@ declare const Definitions: readonly [Schema.Struct<{
14140
14135
  mimeType: string;
14141
14136
  })[];
14142
14137
  details?: any;
14138
+ isError: false;
14143
14139
  };
14144
- status: "running";
14140
+ status: "completed";
14145
14141
  thoughtSignature?: string;
14146
14142
  time: {
14147
14143
  start: number;
@@ -14165,9 +14161,9 @@ declare const Definitions: readonly [Schema.Struct<{
14165
14161
  mimeType: string;
14166
14162
  })[];
14167
14163
  details?: any;
14168
- isError: false;
14164
+ isError: true;
14169
14165
  };
14170
- status: "completed";
14166
+ status: "error";
14171
14167
  thoughtSignature?: string;
14172
14168
  time: {
14173
14169
  start: number;
@@ -14193,7 +14189,7 @@ declare const Definitions: readonly [Schema.Struct<{
14193
14189
  details?: any;
14194
14190
  isError: true;
14195
14191
  };
14196
- status: "error";
14192
+ status: "skipped";
14197
14193
  thoughtSignature?: string;
14198
14194
  time: {
14199
14195
  start: number;
@@ -14219,21 +14215,26 @@ declare const Definitions: readonly [Schema.Struct<{
14219
14215
  details?: any;
14220
14216
  isError: true;
14221
14217
  };
14222
- status: "skipped";
14218
+ status: "aborted";
14223
14219
  thoughtSignature?: string;
14224
14220
  time: {
14225
14221
  start: number;
14226
14222
  end: number;
14227
14223
  };
14228
14224
  type: "toolCall";
14225
+ } | {
14226
+ type: "thinking";
14227
+ thinking: string;
14228
+ thinkingSignature?: string;
14229
+ redacted?: boolean;
14229
14230
  } | {
14230
14231
  addedToolNames?: string[];
14231
14232
  arguments: Record<string, any>;
14232
14233
  callID: string;
14233
14234
  name: string;
14234
14235
  namespace?: string;
14235
- result: {
14236
- content: ({
14236
+ partial?: {
14237
+ content?: ({
14237
14238
  type: "text";
14238
14239
  text: string;
14239
14240
  textSignature?: string;
@@ -14243,9 +14244,8 @@ declare const Definitions: readonly [Schema.Struct<{
14243
14244
  mimeType: string;
14244
14245
  })[];
14245
14246
  details?: any;
14246
- isError: true;
14247
14247
  };
14248
- status: "aborted";
14248
+ status: "running";
14249
14249
  thoughtSignature?: string;
14250
14250
  time: {
14251
14251
  start: number;
@@ -15754,19 +15754,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15754
15754
  type: "image";
15755
15755
  data: string;
15756
15756
  mimeType: string;
15757
- } | {
15758
- type: "thinking";
15759
- thinking: string;
15760
- thinkingSignature?: string;
15761
- redacted?: boolean;
15762
15757
  } | {
15763
15758
  addedToolNames?: string[];
15764
15759
  arguments: Record<string, any>;
15765
15760
  callID: string;
15766
15761
  name: string;
15767
15762
  namespace?: string;
15768
- partial?: {
15769
- content?: ({
15763
+ result: {
15764
+ content: ({
15770
15765
  type: "text";
15771
15766
  text: string;
15772
15767
  textSignature?: string;
@@ -15776,8 +15771,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15776
15771
  mimeType: string;
15777
15772
  })[];
15778
15773
  details?: any;
15774
+ isError: false;
15779
15775
  };
15780
- status: "running";
15776
+ status: "completed";
15781
15777
  thoughtSignature?: string;
15782
15778
  time: {
15783
15779
  start: number;
@@ -15801,9 +15797,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15801
15797
  mimeType: string;
15802
15798
  })[];
15803
15799
  details?: any;
15804
- isError: false;
15800
+ isError: true;
15805
15801
  };
15806
- status: "completed";
15802
+ status: "error";
15807
15803
  thoughtSignature?: string;
15808
15804
  time: {
15809
15805
  start: number;
@@ -15829,7 +15825,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15829
15825
  details?: any;
15830
15826
  isError: true;
15831
15827
  };
15832
- status: "error";
15828
+ status: "skipped";
15833
15829
  thoughtSignature?: string;
15834
15830
  time: {
15835
15831
  start: number;
@@ -15855,21 +15851,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15855
15851
  details?: any;
15856
15852
  isError: true;
15857
15853
  };
15858
- status: "skipped";
15854
+ status: "aborted";
15859
15855
  thoughtSignature?: string;
15860
15856
  time: {
15861
15857
  start: number;
15862
15858
  end: number;
15863
15859
  };
15864
15860
  type: "toolCall";
15861
+ } | {
15862
+ type: "thinking";
15863
+ thinking: string;
15864
+ thinkingSignature?: string;
15865
+ redacted?: boolean;
15865
15866
  } | {
15866
15867
  addedToolNames?: string[];
15867
15868
  arguments: Record<string, any>;
15868
15869
  callID: string;
15869
15870
  name: string;
15870
15871
  namespace?: string;
15871
- result: {
15872
- content: ({
15872
+ partial?: {
15873
+ content?: ({
15873
15874
  type: "text";
15874
15875
  text: string;
15875
15876
  textSignature?: string;
@@ -15879,9 +15880,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15879
15880
  mimeType: string;
15880
15881
  })[];
15881
15882
  details?: any;
15882
- isError: true;
15883
15883
  };
15884
- status: "aborted";
15884
+ status: "running";
15885
15885
  thoughtSignature?: string;
15886
15886
  time: {
15887
15887
  start: number;
@@ -16056,19 +16056,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16056
16056
  type: "image";
16057
16057
  data: string;
16058
16058
  mimeType: string;
16059
- } | {
16060
- type: "thinking";
16061
- thinking: string;
16062
- thinkingSignature?: string;
16063
- redacted?: boolean;
16064
16059
  } | {
16065
16060
  addedToolNames?: string[];
16066
16061
  arguments: Record<string, any>;
16067
16062
  callID: string;
16068
16063
  name: string;
16069
16064
  namespace?: string;
16070
- partial?: {
16071
- content?: ({
16065
+ result: {
16066
+ content: ({
16072
16067
  type: "text";
16073
16068
  text: string;
16074
16069
  textSignature?: string;
@@ -16078,8 +16073,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16078
16073
  mimeType: string;
16079
16074
  })[];
16080
16075
  details?: any;
16076
+ isError: false;
16081
16077
  };
16082
- status: "running";
16078
+ status: "completed";
16083
16079
  thoughtSignature?: string;
16084
16080
  time: {
16085
16081
  start: number;
@@ -16103,9 +16099,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16103
16099
  mimeType: string;
16104
16100
  })[];
16105
16101
  details?: any;
16106
- isError: false;
16102
+ isError: true;
16107
16103
  };
16108
- status: "completed";
16104
+ status: "error";
16109
16105
  thoughtSignature?: string;
16110
16106
  time: {
16111
16107
  start: number;
@@ -16131,7 +16127,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16131
16127
  details?: any;
16132
16128
  isError: true;
16133
16129
  };
16134
- status: "error";
16130
+ status: "skipped";
16135
16131
  thoughtSignature?: string;
16136
16132
  time: {
16137
16133
  start: number;
@@ -16157,21 +16153,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16157
16153
  details?: any;
16158
16154
  isError: true;
16159
16155
  };
16160
- status: "skipped";
16156
+ status: "aborted";
16161
16157
  thoughtSignature?: string;
16162
16158
  time: {
16163
16159
  start: number;
16164
16160
  end: number;
16165
16161
  };
16166
16162
  type: "toolCall";
16163
+ } | {
16164
+ type: "thinking";
16165
+ thinking: string;
16166
+ thinkingSignature?: string;
16167
+ redacted?: boolean;
16167
16168
  } | {
16168
16169
  addedToolNames?: string[];
16169
16170
  arguments: Record<string, any>;
16170
16171
  callID: string;
16171
16172
  name: string;
16172
16173
  namespace?: string;
16173
- result: {
16174
- content: ({
16174
+ partial?: {
16175
+ content?: ({
16175
16176
  type: "text";
16176
16177
  text: string;
16177
16178
  textSignature?: string;
@@ -16181,9 +16182,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16181
16182
  mimeType: string;
16182
16183
  })[];
16183
16184
  details?: any;
16184
- isError: true;
16185
16185
  };
16186
- status: "aborted";
16186
+ status: "running";
16187
16187
  thoughtSignature?: string;
16188
16188
  time: {
16189
16189
  start: number;
@@ -16376,19 +16376,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16376
16376
  type: "image";
16377
16377
  data: string;
16378
16378
  mimeType: string;
16379
- } | {
16380
- type: "thinking";
16381
- thinking: string;
16382
- thinkingSignature?: string;
16383
- redacted?: boolean;
16384
16379
  } | {
16385
16380
  addedToolNames?: string[];
16386
16381
  arguments: Record<string, any>;
16387
16382
  callID: string;
16388
16383
  name: string;
16389
16384
  namespace?: string;
16390
- partial?: {
16391
- content?: ({
16385
+ result: {
16386
+ content: ({
16392
16387
  type: "text";
16393
16388
  text: string;
16394
16389
  textSignature?: string;
@@ -16398,8 +16393,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16398
16393
  mimeType: string;
16399
16394
  })[];
16400
16395
  details?: any;
16396
+ isError: false;
16401
16397
  };
16402
- status: "running";
16398
+ status: "completed";
16403
16399
  thoughtSignature?: string;
16404
16400
  time: {
16405
16401
  start: number;
@@ -16423,9 +16419,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16423
16419
  mimeType: string;
16424
16420
  })[];
16425
16421
  details?: any;
16426
- isError: false;
16422
+ isError: true;
16427
16423
  };
16428
- status: "completed";
16424
+ status: "error";
16429
16425
  thoughtSignature?: string;
16430
16426
  time: {
16431
16427
  start: number;
@@ -16451,7 +16447,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16451
16447
  details?: any;
16452
16448
  isError: true;
16453
16449
  };
16454
- status: "error";
16450
+ status: "skipped";
16455
16451
  thoughtSignature?: string;
16456
16452
  time: {
16457
16453
  start: number;
@@ -16477,21 +16473,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16477
16473
  details?: any;
16478
16474
  isError: true;
16479
16475
  };
16480
- status: "skipped";
16476
+ status: "aborted";
16481
16477
  thoughtSignature?: string;
16482
16478
  time: {
16483
16479
  start: number;
16484
16480
  end: number;
16485
16481
  };
16486
16482
  type: "toolCall";
16483
+ } | {
16484
+ type: "thinking";
16485
+ thinking: string;
16486
+ thinkingSignature?: string;
16487
+ redacted?: boolean;
16487
16488
  } | {
16488
16489
  addedToolNames?: string[];
16489
16490
  arguments: Record<string, any>;
16490
16491
  callID: string;
16491
16492
  name: string;
16492
16493
  namespace?: string;
16493
- result: {
16494
- content: ({
16494
+ partial?: {
16495
+ content?: ({
16495
16496
  type: "text";
16496
16497
  text: string;
16497
16498
  textSignature?: string;
@@ -16501,9 +16502,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16501
16502
  mimeType: string;
16502
16503
  })[];
16503
16504
  details?: any;
16504
- isError: true;
16505
16505
  };
16506
- status: "aborted";
16506
+ status: "running";
16507
16507
  thoughtSignature?: string;
16508
16508
  time: {
16509
16509
  start: number;
@@ -16678,19 +16678,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16678
16678
  type: "image";
16679
16679
  data: string;
16680
16680
  mimeType: string;
16681
- } | {
16682
- type: "thinking";
16683
- thinking: string;
16684
- thinkingSignature?: string;
16685
- redacted?: boolean;
16686
16681
  } | {
16687
16682
  addedToolNames?: string[];
16688
16683
  arguments: Record<string, any>;
16689
16684
  callID: string;
16690
16685
  name: string;
16691
16686
  namespace?: string;
16692
- partial?: {
16693
- content?: ({
16687
+ result: {
16688
+ content: ({
16694
16689
  type: "text";
16695
16690
  text: string;
16696
16691
  textSignature?: string;
@@ -16700,8 +16695,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16700
16695
  mimeType: string;
16701
16696
  })[];
16702
16697
  details?: any;
16698
+ isError: false;
16703
16699
  };
16704
- status: "running";
16700
+ status: "completed";
16705
16701
  thoughtSignature?: string;
16706
16702
  time: {
16707
16703
  start: number;
@@ -16725,9 +16721,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16725
16721
  mimeType: string;
16726
16722
  })[];
16727
16723
  details?: any;
16728
- isError: false;
16724
+ isError: true;
16729
16725
  };
16730
- status: "completed";
16726
+ status: "error";
16731
16727
  thoughtSignature?: string;
16732
16728
  time: {
16733
16729
  start: number;
@@ -16753,7 +16749,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16753
16749
  details?: any;
16754
16750
  isError: true;
16755
16751
  };
16756
- status: "error";
16752
+ status: "skipped";
16757
16753
  thoughtSignature?: string;
16758
16754
  time: {
16759
16755
  start: number;
@@ -16779,21 +16775,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16779
16775
  details?: any;
16780
16776
  isError: true;
16781
16777
  };
16782
- status: "skipped";
16778
+ status: "aborted";
16783
16779
  thoughtSignature?: string;
16784
16780
  time: {
16785
16781
  start: number;
16786
16782
  end: number;
16787
16783
  };
16788
16784
  type: "toolCall";
16785
+ } | {
16786
+ type: "thinking";
16787
+ thinking: string;
16788
+ thinkingSignature?: string;
16789
+ redacted?: boolean;
16789
16790
  } | {
16790
16791
  addedToolNames?: string[];
16791
16792
  arguments: Record<string, any>;
16792
16793
  callID: string;
16793
16794
  name: string;
16794
16795
  namespace?: string;
16795
- result: {
16796
- content: ({
16796
+ partial?: {
16797
+ content?: ({
16797
16798
  type: "text";
16798
16799
  text: string;
16799
16800
  textSignature?: string;
@@ -16803,9 +16804,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16803
16804
  mimeType: string;
16804
16805
  })[];
16805
16806
  details?: any;
16806
- isError: true;
16807
16807
  };
16808
- status: "aborted";
16808
+ status: "running";
16809
16809
  thoughtSignature?: string;
16810
16810
  time: {
16811
16811
  start: number;
@@ -17286,19 +17286,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17286
17286
  type: "image";
17287
17287
  data: string;
17288
17288
  mimeType: string;
17289
- } | {
17290
- type: "thinking";
17291
- thinking: string;
17292
- thinkingSignature?: string;
17293
- redacted?: boolean;
17294
17289
  } | {
17295
17290
  addedToolNames?: string[];
17296
17291
  arguments: Record<string, any>;
17297
17292
  callID: string;
17298
17293
  name: string;
17299
17294
  namespace?: string;
17300
- partial?: {
17301
- content?: ({
17295
+ result: {
17296
+ content: ({
17302
17297
  type: "text";
17303
17298
  text: string;
17304
17299
  textSignature?: string;
@@ -17308,8 +17303,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17308
17303
  mimeType: string;
17309
17304
  })[];
17310
17305
  details?: any;
17306
+ isError: false;
17311
17307
  };
17312
- status: "running";
17308
+ status: "completed";
17313
17309
  thoughtSignature?: string;
17314
17310
  time: {
17315
17311
  start: number;
@@ -17333,9 +17329,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17333
17329
  mimeType: string;
17334
17330
  })[];
17335
17331
  details?: any;
17336
- isError: false;
17332
+ isError: true;
17337
17333
  };
17338
- status: "completed";
17334
+ status: "error";
17339
17335
  thoughtSignature?: string;
17340
17336
  time: {
17341
17337
  start: number;
@@ -17361,7 +17357,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17361
17357
  details?: any;
17362
17358
  isError: true;
17363
17359
  };
17364
- status: "error";
17360
+ status: "skipped";
17365
17361
  thoughtSignature?: string;
17366
17362
  time: {
17367
17363
  start: number;
@@ -17387,21 +17383,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17387
17383
  details?: any;
17388
17384
  isError: true;
17389
17385
  };
17390
- status: "skipped";
17386
+ status: "aborted";
17391
17387
  thoughtSignature?: string;
17392
17388
  time: {
17393
17389
  start: number;
17394
17390
  end: number;
17395
17391
  };
17396
17392
  type: "toolCall";
17393
+ } | {
17394
+ type: "thinking";
17395
+ thinking: string;
17396
+ thinkingSignature?: string;
17397
+ redacted?: boolean;
17397
17398
  } | {
17398
17399
  addedToolNames?: string[];
17399
17400
  arguments: Record<string, any>;
17400
17401
  callID: string;
17401
17402
  name: string;
17402
17403
  namespace?: string;
17403
- result: {
17404
- content: ({
17404
+ partial?: {
17405
+ content?: ({
17405
17406
  type: "text";
17406
17407
  text: string;
17407
17408
  textSignature?: string;
@@ -17411,9 +17412,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17411
17412
  mimeType: string;
17412
17413
  })[];
17413
17414
  details?: any;
17414
- isError: true;
17415
17415
  };
17416
- status: "aborted";
17416
+ status: "running";
17417
17417
  thoughtSignature?: string;
17418
17418
  time: {
17419
17419
  start: number;
@@ -17588,19 +17588,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17588
17588
  type: "image";
17589
17589
  data: string;
17590
17590
  mimeType: string;
17591
- } | {
17592
- type: "thinking";
17593
- thinking: string;
17594
- thinkingSignature?: string;
17595
- redacted?: boolean;
17596
17591
  } | {
17597
17592
  addedToolNames?: string[];
17598
17593
  arguments: Record<string, any>;
17599
17594
  callID: string;
17600
17595
  name: string;
17601
17596
  namespace?: string;
17602
- partial?: {
17603
- content?: ({
17597
+ result: {
17598
+ content: ({
17604
17599
  type: "text";
17605
17600
  text: string;
17606
17601
  textSignature?: string;
@@ -17610,8 +17605,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17610
17605
  mimeType: string;
17611
17606
  })[];
17612
17607
  details?: any;
17608
+ isError: false;
17613
17609
  };
17614
- status: "running";
17610
+ status: "completed";
17615
17611
  thoughtSignature?: string;
17616
17612
  time: {
17617
17613
  start: number;
@@ -17635,9 +17631,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17635
17631
  mimeType: string;
17636
17632
  })[];
17637
17633
  details?: any;
17638
- isError: false;
17634
+ isError: true;
17639
17635
  };
17640
- status: "completed";
17636
+ status: "error";
17641
17637
  thoughtSignature?: string;
17642
17638
  time: {
17643
17639
  start: number;
@@ -17663,7 +17659,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17663
17659
  details?: any;
17664
17660
  isError: true;
17665
17661
  };
17666
- status: "error";
17662
+ status: "skipped";
17667
17663
  thoughtSignature?: string;
17668
17664
  time: {
17669
17665
  start: number;
@@ -17689,21 +17685,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17689
17685
  details?: any;
17690
17686
  isError: true;
17691
17687
  };
17692
- status: "skipped";
17688
+ status: "aborted";
17693
17689
  thoughtSignature?: string;
17694
17690
  time: {
17695
17691
  start: number;
17696
17692
  end: number;
17697
17693
  };
17698
17694
  type: "toolCall";
17695
+ } | {
17696
+ type: "thinking";
17697
+ thinking: string;
17698
+ thinkingSignature?: string;
17699
+ redacted?: boolean;
17699
17700
  } | {
17700
17701
  addedToolNames?: string[];
17701
17702
  arguments: Record<string, any>;
17702
17703
  callID: string;
17703
17704
  name: string;
17704
17705
  namespace?: string;
17705
- result: {
17706
- content: ({
17706
+ partial?: {
17707
+ content?: ({
17707
17708
  type: "text";
17708
17709
  text: string;
17709
17710
  textSignature?: string;
@@ -17713,9 +17714,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17713
17714
  mimeType: string;
17714
17715
  })[];
17715
17716
  details?: any;
17716
- isError: true;
17717
17717
  };
17718
- status: "aborted";
17718
+ status: "running";
17719
17719
  thoughtSignature?: string;
17720
17720
  time: {
17721
17721
  start: number;
@@ -17909,19 +17909,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17909
17909
  type: "image";
17910
17910
  data: string;
17911
17911
  mimeType: string;
17912
- } | {
17913
- type: "thinking";
17914
- thinking: string;
17915
- thinkingSignature?: string;
17916
- redacted?: boolean;
17917
17912
  } | {
17918
17913
  addedToolNames?: string[];
17919
17914
  arguments: Record<string, any>;
17920
17915
  callID: string;
17921
17916
  name: string;
17922
17917
  namespace?: string;
17923
- partial?: {
17924
- content?: ({
17918
+ result: {
17919
+ content: ({
17925
17920
  type: "text";
17926
17921
  text: string;
17927
17922
  textSignature?: string;
@@ -17931,8 +17926,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17931
17926
  mimeType: string;
17932
17927
  })[];
17933
17928
  details?: any;
17929
+ isError: false;
17934
17930
  };
17935
- status: "running";
17931
+ status: "completed";
17936
17932
  thoughtSignature?: string;
17937
17933
  time: {
17938
17934
  start: number;
@@ -17956,9 +17952,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17956
17952
  mimeType: string;
17957
17953
  })[];
17958
17954
  details?: any;
17959
- isError: false;
17955
+ isError: true;
17960
17956
  };
17961
- status: "completed";
17957
+ status: "error";
17962
17958
  thoughtSignature?: string;
17963
17959
  time: {
17964
17960
  start: number;
@@ -17984,7 +17980,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17984
17980
  details?: any;
17985
17981
  isError: true;
17986
17982
  };
17987
- status: "error";
17983
+ status: "skipped";
17988
17984
  thoughtSignature?: string;
17989
17985
  time: {
17990
17986
  start: number;
@@ -18010,21 +18006,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18010
18006
  details?: any;
18011
18007
  isError: true;
18012
18008
  };
18013
- status: "skipped";
18009
+ status: "aborted";
18014
18010
  thoughtSignature?: string;
18015
18011
  time: {
18016
18012
  start: number;
18017
18013
  end: number;
18018
18014
  };
18019
18015
  type: "toolCall";
18016
+ } | {
18017
+ type: "thinking";
18018
+ thinking: string;
18019
+ thinkingSignature?: string;
18020
+ redacted?: boolean;
18020
18021
  } | {
18021
18022
  addedToolNames?: string[];
18022
18023
  arguments: Record<string, any>;
18023
18024
  callID: string;
18024
18025
  name: string;
18025
18026
  namespace?: string;
18026
- result: {
18027
- content: ({
18027
+ partial?: {
18028
+ content?: ({
18028
18029
  type: "text";
18029
18030
  text: string;
18030
18031
  textSignature?: string;
@@ -18034,9 +18035,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18034
18035
  mimeType: string;
18035
18036
  })[];
18036
18037
  details?: any;
18037
- isError: true;
18038
18038
  };
18039
- status: "aborted";
18039
+ status: "running";
18040
18040
  thoughtSignature?: string;
18041
18041
  time: {
18042
18042
  start: number;
@@ -18211,19 +18211,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18211
18211
  type: "image";
18212
18212
  data: string;
18213
18213
  mimeType: string;
18214
- } | {
18215
- type: "thinking";
18216
- thinking: string;
18217
- thinkingSignature?: string;
18218
- redacted?: boolean;
18219
18214
  } | {
18220
18215
  addedToolNames?: string[];
18221
18216
  arguments: Record<string, any>;
18222
18217
  callID: string;
18223
18218
  name: string;
18224
18219
  namespace?: string;
18225
- partial?: {
18226
- content?: ({
18220
+ result: {
18221
+ content: ({
18227
18222
  type: "text";
18228
18223
  text: string;
18229
18224
  textSignature?: string;
@@ -18233,8 +18228,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18233
18228
  mimeType: string;
18234
18229
  })[];
18235
18230
  details?: any;
18231
+ isError: false;
18236
18232
  };
18237
- status: "running";
18233
+ status: "completed";
18238
18234
  thoughtSignature?: string;
18239
18235
  time: {
18240
18236
  start: number;
@@ -18258,9 +18254,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18258
18254
  mimeType: string;
18259
18255
  })[];
18260
18256
  details?: any;
18261
- isError: false;
18257
+ isError: true;
18262
18258
  };
18263
- status: "completed";
18259
+ status: "error";
18264
18260
  thoughtSignature?: string;
18265
18261
  time: {
18266
18262
  start: number;
@@ -18286,7 +18282,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18286
18282
  details?: any;
18287
18283
  isError: true;
18288
18284
  };
18289
- status: "error";
18285
+ status: "skipped";
18290
18286
  thoughtSignature?: string;
18291
18287
  time: {
18292
18288
  start: number;
@@ -18312,21 +18308,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18312
18308
  details?: any;
18313
18309
  isError: true;
18314
18310
  };
18315
- status: "skipped";
18311
+ status: "aborted";
18316
18312
  thoughtSignature?: string;
18317
18313
  time: {
18318
18314
  start: number;
18319
18315
  end: number;
18320
18316
  };
18321
18317
  type: "toolCall";
18318
+ } | {
18319
+ type: "thinking";
18320
+ thinking: string;
18321
+ thinkingSignature?: string;
18322
+ redacted?: boolean;
18322
18323
  } | {
18323
18324
  addedToolNames?: string[];
18324
18325
  arguments: Record<string, any>;
18325
18326
  callID: string;
18326
18327
  name: string;
18327
18328
  namespace?: string;
18328
- result: {
18329
- content: ({
18329
+ partial?: {
18330
+ content?: ({
18330
18331
  type: "text";
18331
18332
  text: string;
18332
18333
  textSignature?: string;
@@ -18336,9 +18337,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18336
18337
  mimeType: string;
18337
18338
  })[];
18338
18339
  details?: any;
18339
- isError: true;
18340
18340
  };
18341
- status: "aborted";
18341
+ status: "running";
18342
18342
  thoughtSignature?: string;
18343
18343
  time: {
18344
18344
  start: number;
@@ -18541,19 +18541,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18541
18541
  type: "image";
18542
18542
  data: string;
18543
18543
  mimeType: string;
18544
- } | {
18545
- type: "thinking";
18546
- thinking: string;
18547
- thinkingSignature?: string;
18548
- redacted?: boolean;
18549
18544
  } | {
18550
18545
  addedToolNames?: string[];
18551
18546
  arguments: Record<string, any>;
18552
18547
  callID: string;
18553
18548
  name: string;
18554
18549
  namespace?: string;
18555
- partial?: {
18556
- content?: ({
18550
+ result: {
18551
+ content: ({
18557
18552
  type: "text";
18558
18553
  text: string;
18559
18554
  textSignature?: string;
@@ -18563,8 +18558,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18563
18558
  mimeType: string;
18564
18559
  })[];
18565
18560
  details?: any;
18561
+ isError: false;
18566
18562
  };
18567
- status: "running";
18563
+ status: "completed";
18568
18564
  thoughtSignature?: string;
18569
18565
  time: {
18570
18566
  start: number;
@@ -18588,9 +18584,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18588
18584
  mimeType: string;
18589
18585
  })[];
18590
18586
  details?: any;
18591
- isError: false;
18587
+ isError: true;
18592
18588
  };
18593
- status: "completed";
18589
+ status: "error";
18594
18590
  thoughtSignature?: string;
18595
18591
  time: {
18596
18592
  start: number;
@@ -18616,7 +18612,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18616
18612
  details?: any;
18617
18613
  isError: true;
18618
18614
  };
18619
- status: "error";
18615
+ status: "skipped";
18620
18616
  thoughtSignature?: string;
18621
18617
  time: {
18622
18618
  start: number;
@@ -18642,21 +18638,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18642
18638
  details?: any;
18643
18639
  isError: true;
18644
18640
  };
18645
- status: "skipped";
18641
+ status: "aborted";
18646
18642
  thoughtSignature?: string;
18647
18643
  time: {
18648
18644
  start: number;
18649
18645
  end: number;
18650
18646
  };
18651
18647
  type: "toolCall";
18648
+ } | {
18649
+ type: "thinking";
18650
+ thinking: string;
18651
+ thinkingSignature?: string;
18652
+ redacted?: boolean;
18652
18653
  } | {
18653
18654
  addedToolNames?: string[];
18654
18655
  arguments: Record<string, any>;
18655
18656
  callID: string;
18656
18657
  name: string;
18657
18658
  namespace?: string;
18658
- result: {
18659
- content: ({
18659
+ partial?: {
18660
+ content?: ({
18660
18661
  type: "text";
18661
18662
  text: string;
18662
18663
  textSignature?: string;
@@ -18666,9 +18667,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18666
18667
  mimeType: string;
18667
18668
  })[];
18668
18669
  details?: any;
18669
- isError: true;
18670
18670
  };
18671
- status: "aborted";
18671
+ status: "running";
18672
18672
  thoughtSignature?: string;
18673
18673
  time: {
18674
18674
  start: number;
@@ -18843,19 +18843,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18843
18843
  type: "image";
18844
18844
  data: string;
18845
18845
  mimeType: string;
18846
- } | {
18847
- type: "thinking";
18848
- thinking: string;
18849
- thinkingSignature?: string;
18850
- redacted?: boolean;
18851
18846
  } | {
18852
18847
  addedToolNames?: string[];
18853
18848
  arguments: Record<string, any>;
18854
18849
  callID: string;
18855
18850
  name: string;
18856
18851
  namespace?: string;
18857
- partial?: {
18858
- content?: ({
18852
+ result: {
18853
+ content: ({
18859
18854
  type: "text";
18860
18855
  text: string;
18861
18856
  textSignature?: string;
@@ -18865,8 +18860,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18865
18860
  mimeType: string;
18866
18861
  })[];
18867
18862
  details?: any;
18863
+ isError: false;
18868
18864
  };
18869
- status: "running";
18865
+ status: "completed";
18870
18866
  thoughtSignature?: string;
18871
18867
  time: {
18872
18868
  start: number;
@@ -18890,9 +18886,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18890
18886
  mimeType: string;
18891
18887
  })[];
18892
18888
  details?: any;
18893
- isError: false;
18889
+ isError: true;
18894
18890
  };
18895
- status: "completed";
18891
+ status: "error";
18896
18892
  thoughtSignature?: string;
18897
18893
  time: {
18898
18894
  start: number;
@@ -18918,7 +18914,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18918
18914
  details?: any;
18919
18915
  isError: true;
18920
18916
  };
18921
- status: "error";
18917
+ status: "skipped";
18922
18918
  thoughtSignature?: string;
18923
18919
  time: {
18924
18920
  start: number;
@@ -18944,21 +18940,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18944
18940
  details?: any;
18945
18941
  isError: true;
18946
18942
  };
18947
- status: "skipped";
18943
+ status: "aborted";
18948
18944
  thoughtSignature?: string;
18949
18945
  time: {
18950
18946
  start: number;
18951
18947
  end: number;
18952
18948
  };
18953
18949
  type: "toolCall";
18950
+ } | {
18951
+ type: "thinking";
18952
+ thinking: string;
18953
+ thinkingSignature?: string;
18954
+ redacted?: boolean;
18954
18955
  } | {
18955
18956
  addedToolNames?: string[];
18956
18957
  arguments: Record<string, any>;
18957
18958
  callID: string;
18958
18959
  name: string;
18959
18960
  namespace?: string;
18960
- result: {
18961
- content: ({
18961
+ partial?: {
18962
+ content?: ({
18962
18963
  type: "text";
18963
18964
  text: string;
18964
18965
  textSignature?: string;
@@ -18968,9 +18969,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18968
18969
  mimeType: string;
18969
18970
  })[];
18970
18971
  details?: any;
18971
- isError: true;
18972
18972
  };
18973
- status: "aborted";
18973
+ status: "running";
18974
18974
  thoughtSignature?: string;
18975
18975
  time: {
18976
18976
  start: number;
@@ -19164,19 +19164,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19164
19164
  type: "image";
19165
19165
  data: string;
19166
19166
  mimeType: string;
19167
- } | {
19168
- type: "thinking";
19169
- thinking: string;
19170
- thinkingSignature?: string;
19171
- redacted?: boolean;
19172
19167
  } | {
19173
19168
  addedToolNames?: string[];
19174
19169
  arguments: Record<string, any>;
19175
19170
  callID: string;
19176
19171
  name: string;
19177
19172
  namespace?: string;
19178
- partial?: {
19179
- content?: ({
19173
+ result: {
19174
+ content: ({
19180
19175
  type: "text";
19181
19176
  text: string;
19182
19177
  textSignature?: string;
@@ -19186,8 +19181,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19186
19181
  mimeType: string;
19187
19182
  })[];
19188
19183
  details?: any;
19184
+ isError: false;
19189
19185
  };
19190
- status: "running";
19186
+ status: "completed";
19191
19187
  thoughtSignature?: string;
19192
19188
  time: {
19193
19189
  start: number;
@@ -19211,9 +19207,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19211
19207
  mimeType: string;
19212
19208
  })[];
19213
19209
  details?: any;
19214
- isError: false;
19210
+ isError: true;
19215
19211
  };
19216
- status: "completed";
19212
+ status: "error";
19217
19213
  thoughtSignature?: string;
19218
19214
  time: {
19219
19215
  start: number;
@@ -19239,7 +19235,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19239
19235
  details?: any;
19240
19236
  isError: true;
19241
19237
  };
19242
- status: "error";
19238
+ status: "skipped";
19243
19239
  thoughtSignature?: string;
19244
19240
  time: {
19245
19241
  start: number;
@@ -19265,21 +19261,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19265
19261
  details?: any;
19266
19262
  isError: true;
19267
19263
  };
19268
- status: "skipped";
19264
+ status: "aborted";
19269
19265
  thoughtSignature?: string;
19270
19266
  time: {
19271
19267
  start: number;
19272
19268
  end: number;
19273
19269
  };
19274
19270
  type: "toolCall";
19271
+ } | {
19272
+ type: "thinking";
19273
+ thinking: string;
19274
+ thinkingSignature?: string;
19275
+ redacted?: boolean;
19275
19276
  } | {
19276
19277
  addedToolNames?: string[];
19277
19278
  arguments: Record<string, any>;
19278
19279
  callID: string;
19279
19280
  name: string;
19280
19281
  namespace?: string;
19281
- result: {
19282
- content: ({
19282
+ partial?: {
19283
+ content?: ({
19283
19284
  type: "text";
19284
19285
  text: string;
19285
19286
  textSignature?: string;
@@ -19289,9 +19290,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19289
19290
  mimeType: string;
19290
19291
  })[];
19291
19292
  details?: any;
19292
- isError: true;
19293
19293
  };
19294
- status: "aborted";
19294
+ status: "running";
19295
19295
  thoughtSignature?: string;
19296
19296
  time: {
19297
19297
  start: number;
@@ -19466,19 +19466,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19466
19466
  type: "image";
19467
19467
  data: string;
19468
19468
  mimeType: string;
19469
- } | {
19470
- type: "thinking";
19471
- thinking: string;
19472
- thinkingSignature?: string;
19473
- redacted?: boolean;
19474
19469
  } | {
19475
19470
  addedToolNames?: string[];
19476
19471
  arguments: Record<string, any>;
19477
19472
  callID: string;
19478
19473
  name: string;
19479
19474
  namespace?: string;
19480
- partial?: {
19481
- content?: ({
19475
+ result: {
19476
+ content: ({
19482
19477
  type: "text";
19483
19478
  text: string;
19484
19479
  textSignature?: string;
@@ -19488,8 +19483,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19488
19483
  mimeType: string;
19489
19484
  })[];
19490
19485
  details?: any;
19486
+ isError: false;
19491
19487
  };
19492
- status: "running";
19488
+ status: "completed";
19493
19489
  thoughtSignature?: string;
19494
19490
  time: {
19495
19491
  start: number;
@@ -19513,9 +19509,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19513
19509
  mimeType: string;
19514
19510
  })[];
19515
19511
  details?: any;
19516
- isError: false;
19512
+ isError: true;
19517
19513
  };
19518
- status: "completed";
19514
+ status: "error";
19519
19515
  thoughtSignature?: string;
19520
19516
  time: {
19521
19517
  start: number;
@@ -19541,7 +19537,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19541
19537
  details?: any;
19542
19538
  isError: true;
19543
19539
  };
19544
- status: "error";
19540
+ status: "skipped";
19545
19541
  thoughtSignature?: string;
19546
19542
  time: {
19547
19543
  start: number;
@@ -19567,21 +19563,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19567
19563
  details?: any;
19568
19564
  isError: true;
19569
19565
  };
19570
- status: "skipped";
19566
+ status: "aborted";
19571
19567
  thoughtSignature?: string;
19572
19568
  time: {
19573
19569
  start: number;
19574
19570
  end: number;
19575
19571
  };
19576
19572
  type: "toolCall";
19573
+ } | {
19574
+ type: "thinking";
19575
+ thinking: string;
19576
+ thinkingSignature?: string;
19577
+ redacted?: boolean;
19577
19578
  } | {
19578
19579
  addedToolNames?: string[];
19579
19580
  arguments: Record<string, any>;
19580
19581
  callID: string;
19581
19582
  name: string;
19582
19583
  namespace?: string;
19583
- result: {
19584
- content: ({
19584
+ partial?: {
19585
+ content?: ({
19585
19586
  type: "text";
19586
19587
  text: string;
19587
19588
  textSignature?: string;
@@ -19591,9 +19592,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19591
19592
  mimeType: string;
19592
19593
  })[];
19593
19594
  details?: any;
19594
- isError: true;
19595
19595
  };
19596
- status: "aborted";
19596
+ status: "running";
19597
19597
  thoughtSignature?: string;
19598
19598
  time: {
19599
19599
  start: number;
@@ -20781,19 +20781,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20781
20781
  type: "image";
20782
20782
  data: string;
20783
20783
  mimeType: string;
20784
- } | {
20785
- type: "thinking";
20786
- thinking: string;
20787
- thinkingSignature?: string;
20788
- redacted?: boolean;
20789
20784
  } | {
20790
20785
  addedToolNames?: string[];
20791
20786
  arguments: Record<string, any>;
20792
20787
  callID: string;
20793
20788
  name: string;
20794
20789
  namespace?: string;
20795
- partial?: {
20796
- content?: ({
20790
+ result: {
20791
+ content: ({
20797
20792
  type: "text";
20798
20793
  text: string;
20799
20794
  textSignature?: string;
@@ -20803,8 +20798,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20803
20798
  mimeType: string;
20804
20799
  })[];
20805
20800
  details?: any;
20801
+ isError: false;
20806
20802
  };
20807
- status: "running";
20803
+ status: "completed";
20808
20804
  thoughtSignature?: string;
20809
20805
  time: {
20810
20806
  start: number;
@@ -20828,9 +20824,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20828
20824
  mimeType: string;
20829
20825
  })[];
20830
20826
  details?: any;
20831
- isError: false;
20827
+ isError: true;
20832
20828
  };
20833
- status: "completed";
20829
+ status: "error";
20834
20830
  thoughtSignature?: string;
20835
20831
  time: {
20836
20832
  start: number;
@@ -20856,7 +20852,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20856
20852
  details?: any;
20857
20853
  isError: true;
20858
20854
  };
20859
- status: "error";
20855
+ status: "skipped";
20860
20856
  thoughtSignature?: string;
20861
20857
  time: {
20862
20858
  start: number;
@@ -20882,21 +20878,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20882
20878
  details?: any;
20883
20879
  isError: true;
20884
20880
  };
20885
- status: "skipped";
20881
+ status: "aborted";
20886
20882
  thoughtSignature?: string;
20887
20883
  time: {
20888
20884
  start: number;
20889
20885
  end: number;
20890
20886
  };
20891
20887
  type: "toolCall";
20888
+ } | {
20889
+ type: "thinking";
20890
+ thinking: string;
20891
+ thinkingSignature?: string;
20892
+ redacted?: boolean;
20892
20893
  } | {
20893
20894
  addedToolNames?: string[];
20894
20895
  arguments: Record<string, any>;
20895
20896
  callID: string;
20896
20897
  name: string;
20897
20898
  namespace?: string;
20898
- result: {
20899
- content: ({
20899
+ partial?: {
20900
+ content?: ({
20900
20901
  type: "text";
20901
20902
  text: string;
20902
20903
  textSignature?: string;
@@ -20906,9 +20907,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20906
20907
  mimeType: string;
20907
20908
  })[];
20908
20909
  details?: any;
20909
- isError: true;
20910
20910
  };
20911
- status: "aborted";
20911
+ status: "running";
20912
20912
  thoughtSignature?: string;
20913
20913
  time: {
20914
20914
  start: number;
@@ -21083,19 +21083,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21083
21083
  type: "image";
21084
21084
  data: string;
21085
21085
  mimeType: string;
21086
- } | {
21087
- type: "thinking";
21088
- thinking: string;
21089
- thinkingSignature?: string;
21090
- redacted?: boolean;
21091
21086
  } | {
21092
21087
  addedToolNames?: string[];
21093
21088
  arguments: Record<string, any>;
21094
21089
  callID: string;
21095
21090
  name: string;
21096
21091
  namespace?: string;
21097
- partial?: {
21098
- content?: ({
21092
+ result: {
21093
+ content: ({
21099
21094
  type: "text";
21100
21095
  text: string;
21101
21096
  textSignature?: string;
@@ -21105,8 +21100,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21105
21100
  mimeType: string;
21106
21101
  })[];
21107
21102
  details?: any;
21103
+ isError: false;
21108
21104
  };
21109
- status: "running";
21105
+ status: "completed";
21110
21106
  thoughtSignature?: string;
21111
21107
  time: {
21112
21108
  start: number;
@@ -21130,9 +21126,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21130
21126
  mimeType: string;
21131
21127
  })[];
21132
21128
  details?: any;
21133
- isError: false;
21129
+ isError: true;
21134
21130
  };
21135
- status: "completed";
21131
+ status: "error";
21136
21132
  thoughtSignature?: string;
21137
21133
  time: {
21138
21134
  start: number;
@@ -21158,7 +21154,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21158
21154
  details?: any;
21159
21155
  isError: true;
21160
21156
  };
21161
- status: "error";
21157
+ status: "skipped";
21162
21158
  thoughtSignature?: string;
21163
21159
  time: {
21164
21160
  start: number;
@@ -21184,21 +21180,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21184
21180
  details?: any;
21185
21181
  isError: true;
21186
21182
  };
21187
- status: "skipped";
21183
+ status: "aborted";
21188
21184
  thoughtSignature?: string;
21189
21185
  time: {
21190
21186
  start: number;
21191
21187
  end: number;
21192
21188
  };
21193
21189
  type: "toolCall";
21190
+ } | {
21191
+ type: "thinking";
21192
+ thinking: string;
21193
+ thinkingSignature?: string;
21194
+ redacted?: boolean;
21194
21195
  } | {
21195
21196
  addedToolNames?: string[];
21196
21197
  arguments: Record<string, any>;
21197
21198
  callID: string;
21198
21199
  name: string;
21199
21200
  namespace?: string;
21200
- result: {
21201
- content: ({
21201
+ partial?: {
21202
+ content?: ({
21202
21203
  type: "text";
21203
21204
  text: string;
21204
21205
  textSignature?: string;
@@ -21208,9 +21209,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21208
21209
  mimeType: string;
21209
21210
  })[];
21210
21211
  details?: any;
21211
- isError: true;
21212
21212
  };
21213
- status: "aborted";
21213
+ status: "running";
21214
21214
  thoughtSignature?: string;
21215
21215
  time: {
21216
21216
  start: number;
@@ -21403,19 +21403,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21403
21403
  type: "image";
21404
21404
  data: string;
21405
21405
  mimeType: string;
21406
- } | {
21407
- type: "thinking";
21408
- thinking: string;
21409
- thinkingSignature?: string;
21410
- redacted?: boolean;
21411
21406
  } | {
21412
21407
  addedToolNames?: string[];
21413
21408
  arguments: Record<string, any>;
21414
21409
  callID: string;
21415
21410
  name: string;
21416
21411
  namespace?: string;
21417
- partial?: {
21418
- content?: ({
21412
+ result: {
21413
+ content: ({
21419
21414
  type: "text";
21420
21415
  text: string;
21421
21416
  textSignature?: string;
@@ -21425,8 +21420,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21425
21420
  mimeType: string;
21426
21421
  })[];
21427
21422
  details?: any;
21423
+ isError: false;
21428
21424
  };
21429
- status: "running";
21425
+ status: "completed";
21430
21426
  thoughtSignature?: string;
21431
21427
  time: {
21432
21428
  start: number;
@@ -21450,9 +21446,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21450
21446
  mimeType: string;
21451
21447
  })[];
21452
21448
  details?: any;
21453
- isError: false;
21449
+ isError: true;
21454
21450
  };
21455
- status: "completed";
21451
+ status: "error";
21456
21452
  thoughtSignature?: string;
21457
21453
  time: {
21458
21454
  start: number;
@@ -21478,7 +21474,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21478
21474
  details?: any;
21479
21475
  isError: true;
21480
21476
  };
21481
- status: "error";
21477
+ status: "skipped";
21482
21478
  thoughtSignature?: string;
21483
21479
  time: {
21484
21480
  start: number;
@@ -21504,21 +21500,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21504
21500
  details?: any;
21505
21501
  isError: true;
21506
21502
  };
21507
- status: "skipped";
21503
+ status: "aborted";
21508
21504
  thoughtSignature?: string;
21509
21505
  time: {
21510
21506
  start: number;
21511
21507
  end: number;
21512
21508
  };
21513
21509
  type: "toolCall";
21510
+ } | {
21511
+ type: "thinking";
21512
+ thinking: string;
21513
+ thinkingSignature?: string;
21514
+ redacted?: boolean;
21514
21515
  } | {
21515
21516
  addedToolNames?: string[];
21516
21517
  arguments: Record<string, any>;
21517
21518
  callID: string;
21518
21519
  name: string;
21519
21520
  namespace?: string;
21520
- result: {
21521
- content: ({
21521
+ partial?: {
21522
+ content?: ({
21522
21523
  type: "text";
21523
21524
  text: string;
21524
21525
  textSignature?: string;
@@ -21528,9 +21529,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21528
21529
  mimeType: string;
21529
21530
  })[];
21530
21531
  details?: any;
21531
- isError: true;
21532
21532
  };
21533
- status: "aborted";
21533
+ status: "running";
21534
21534
  thoughtSignature?: string;
21535
21535
  time: {
21536
21536
  start: number;
@@ -21705,19 +21705,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21705
21705
  type: "image";
21706
21706
  data: string;
21707
21707
  mimeType: string;
21708
- } | {
21709
- type: "thinking";
21710
- thinking: string;
21711
- thinkingSignature?: string;
21712
- redacted?: boolean;
21713
21708
  } | {
21714
21709
  addedToolNames?: string[];
21715
21710
  arguments: Record<string, any>;
21716
21711
  callID: string;
21717
21712
  name: string;
21718
21713
  namespace?: string;
21719
- partial?: {
21720
- content?: ({
21714
+ result: {
21715
+ content: ({
21721
21716
  type: "text";
21722
21717
  text: string;
21723
21718
  textSignature?: string;
@@ -21727,8 +21722,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21727
21722
  mimeType: string;
21728
21723
  })[];
21729
21724
  details?: any;
21725
+ isError: false;
21730
21726
  };
21731
- status: "running";
21727
+ status: "completed";
21732
21728
  thoughtSignature?: string;
21733
21729
  time: {
21734
21730
  start: number;
@@ -21752,9 +21748,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21752
21748
  mimeType: string;
21753
21749
  })[];
21754
21750
  details?: any;
21755
- isError: false;
21751
+ isError: true;
21756
21752
  };
21757
- status: "completed";
21753
+ status: "error";
21758
21754
  thoughtSignature?: string;
21759
21755
  time: {
21760
21756
  start: number;
@@ -21780,7 +21776,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21780
21776
  details?: any;
21781
21777
  isError: true;
21782
21778
  };
21783
- status: "error";
21779
+ status: "skipped";
21784
21780
  thoughtSignature?: string;
21785
21781
  time: {
21786
21782
  start: number;
@@ -21806,21 +21802,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21806
21802
  details?: any;
21807
21803
  isError: true;
21808
21804
  };
21809
- status: "skipped";
21805
+ status: "aborted";
21810
21806
  thoughtSignature?: string;
21811
21807
  time: {
21812
21808
  start: number;
21813
21809
  end: number;
21814
21810
  };
21815
21811
  type: "toolCall";
21812
+ } | {
21813
+ type: "thinking";
21814
+ thinking: string;
21815
+ thinkingSignature?: string;
21816
+ redacted?: boolean;
21816
21817
  } | {
21817
21818
  addedToolNames?: string[];
21818
21819
  arguments: Record<string, any>;
21819
21820
  callID: string;
21820
21821
  name: string;
21821
21822
  namespace?: string;
21822
- result: {
21823
- content: ({
21823
+ partial?: {
21824
+ content?: ({
21824
21825
  type: "text";
21825
21826
  text: string;
21826
21827
  textSignature?: string;
@@ -21830,9 +21831,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21830
21831
  mimeType: string;
21831
21832
  })[];
21832
21833
  details?: any;
21833
- isError: true;
21834
21834
  };
21835
- status: "aborted";
21835
+ status: "running";
21836
21836
  thoughtSignature?: string;
21837
21837
  time: {
21838
21838
  start: number;
@@ -22035,19 +22035,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22035
22035
  type: "image";
22036
22036
  data: string;
22037
22037
  mimeType: string;
22038
- } | {
22039
- type: "thinking";
22040
- thinking: string;
22041
- thinkingSignature?: string;
22042
- redacted?: boolean;
22043
22038
  } | {
22044
22039
  addedToolNames?: string[];
22045
22040
  arguments: Record<string, any>;
22046
22041
  callID: string;
22047
22042
  name: string;
22048
22043
  namespace?: string;
22049
- partial?: {
22050
- content?: ({
22044
+ result: {
22045
+ content: ({
22051
22046
  type: "text";
22052
22047
  text: string;
22053
22048
  textSignature?: string;
@@ -22057,8 +22052,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22057
22052
  mimeType: string;
22058
22053
  })[];
22059
22054
  details?: any;
22055
+ isError: false;
22060
22056
  };
22061
- status: "running";
22057
+ status: "completed";
22062
22058
  thoughtSignature?: string;
22063
22059
  time: {
22064
22060
  start: number;
@@ -22082,9 +22078,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22082
22078
  mimeType: string;
22083
22079
  })[];
22084
22080
  details?: any;
22085
- isError: false;
22081
+ isError: true;
22086
22082
  };
22087
- status: "completed";
22083
+ status: "error";
22088
22084
  thoughtSignature?: string;
22089
22085
  time: {
22090
22086
  start: number;
@@ -22110,7 +22106,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22110
22106
  details?: any;
22111
22107
  isError: true;
22112
22108
  };
22113
- status: "error";
22109
+ status: "skipped";
22114
22110
  thoughtSignature?: string;
22115
22111
  time: {
22116
22112
  start: number;
@@ -22136,21 +22132,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22136
22132
  details?: any;
22137
22133
  isError: true;
22138
22134
  };
22139
- status: "skipped";
22135
+ status: "aborted";
22140
22136
  thoughtSignature?: string;
22141
22137
  time: {
22142
22138
  start: number;
22143
22139
  end: number;
22144
22140
  };
22145
22141
  type: "toolCall";
22142
+ } | {
22143
+ type: "thinking";
22144
+ thinking: string;
22145
+ thinkingSignature?: string;
22146
+ redacted?: boolean;
22146
22147
  } | {
22147
22148
  addedToolNames?: string[];
22148
22149
  arguments: Record<string, any>;
22149
22150
  callID: string;
22150
22151
  name: string;
22151
22152
  namespace?: string;
22152
- result: {
22153
- content: ({
22153
+ partial?: {
22154
+ content?: ({
22154
22155
  type: "text";
22155
22156
  text: string;
22156
22157
  textSignature?: string;
@@ -22160,9 +22161,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22160
22161
  mimeType: string;
22161
22162
  })[];
22162
22163
  details?: any;
22163
- isError: true;
22164
22164
  };
22165
- status: "aborted";
22165
+ status: "running";
22166
22166
  thoughtSignature?: string;
22167
22167
  time: {
22168
22168
  start: number;
@@ -22337,19 +22337,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22337
22337
  type: "image";
22338
22338
  data: string;
22339
22339
  mimeType: string;
22340
- } | {
22341
- type: "thinking";
22342
- thinking: string;
22343
- thinkingSignature?: string;
22344
- redacted?: boolean;
22345
22340
  } | {
22346
22341
  addedToolNames?: string[];
22347
22342
  arguments: Record<string, any>;
22348
22343
  callID: string;
22349
22344
  name: string;
22350
22345
  namespace?: string;
22351
- partial?: {
22352
- content?: ({
22346
+ result: {
22347
+ content: ({
22353
22348
  type: "text";
22354
22349
  text: string;
22355
22350
  textSignature?: string;
@@ -22359,8 +22354,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22359
22354
  mimeType: string;
22360
22355
  })[];
22361
22356
  details?: any;
22357
+ isError: false;
22362
22358
  };
22363
- status: "running";
22359
+ status: "completed";
22364
22360
  thoughtSignature?: string;
22365
22361
  time: {
22366
22362
  start: number;
@@ -22384,9 +22380,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22384
22380
  mimeType: string;
22385
22381
  })[];
22386
22382
  details?: any;
22387
- isError: false;
22383
+ isError: true;
22388
22384
  };
22389
- status: "completed";
22385
+ status: "error";
22390
22386
  thoughtSignature?: string;
22391
22387
  time: {
22392
22388
  start: number;
@@ -22412,7 +22408,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22412
22408
  details?: any;
22413
22409
  isError: true;
22414
22410
  };
22415
- status: "error";
22411
+ status: "skipped";
22416
22412
  thoughtSignature?: string;
22417
22413
  time: {
22418
22414
  start: number;
@@ -22438,21 +22434,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22438
22434
  details?: any;
22439
22435
  isError: true;
22440
22436
  };
22441
- status: "skipped";
22437
+ status: "aborted";
22442
22438
  thoughtSignature?: string;
22443
22439
  time: {
22444
22440
  start: number;
22445
22441
  end: number;
22446
22442
  };
22447
22443
  type: "toolCall";
22444
+ } | {
22445
+ type: "thinking";
22446
+ thinking: string;
22447
+ thinkingSignature?: string;
22448
+ redacted?: boolean;
22448
22449
  } | {
22449
22450
  addedToolNames?: string[];
22450
22451
  arguments: Record<string, any>;
22451
22452
  callID: string;
22452
22453
  name: string;
22453
22454
  namespace?: string;
22454
- result: {
22455
- content: ({
22455
+ partial?: {
22456
+ content?: ({
22456
22457
  type: "text";
22457
22458
  text: string;
22458
22459
  textSignature?: string;
@@ -22462,9 +22463,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22462
22463
  mimeType: string;
22463
22464
  })[];
22464
22465
  details?: any;
22465
- isError: true;
22466
22466
  };
22467
- status: "aborted";
22467
+ status: "running";
22468
22468
  thoughtSignature?: string;
22469
22469
  time: {
22470
22470
  start: number;
@@ -22658,19 +22658,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22658
22658
  type: "image";
22659
22659
  data: string;
22660
22660
  mimeType: string;
22661
- } | {
22662
- type: "thinking";
22663
- thinking: string;
22664
- thinkingSignature?: string;
22665
- redacted?: boolean;
22666
22661
  } | {
22667
22662
  addedToolNames?: string[];
22668
22663
  arguments: Record<string, any>;
22669
22664
  callID: string;
22670
22665
  name: string;
22671
22666
  namespace?: string;
22672
- partial?: {
22673
- content?: ({
22667
+ result: {
22668
+ content: ({
22674
22669
  type: "text";
22675
22670
  text: string;
22676
22671
  textSignature?: string;
@@ -22680,8 +22675,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22680
22675
  mimeType: string;
22681
22676
  })[];
22682
22677
  details?: any;
22678
+ isError: false;
22683
22679
  };
22684
- status: "running";
22680
+ status: "completed";
22685
22681
  thoughtSignature?: string;
22686
22682
  time: {
22687
22683
  start: number;
@@ -22705,9 +22701,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22705
22701
  mimeType: string;
22706
22702
  })[];
22707
22703
  details?: any;
22708
- isError: false;
22704
+ isError: true;
22709
22705
  };
22710
- status: "completed";
22706
+ status: "error";
22711
22707
  thoughtSignature?: string;
22712
22708
  time: {
22713
22709
  start: number;
@@ -22733,7 +22729,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22733
22729
  details?: any;
22734
22730
  isError: true;
22735
22731
  };
22736
- status: "error";
22732
+ status: "skipped";
22737
22733
  thoughtSignature?: string;
22738
22734
  time: {
22739
22735
  start: number;
@@ -22759,21 +22755,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22759
22755
  details?: any;
22760
22756
  isError: true;
22761
22757
  };
22762
- status: "skipped";
22758
+ status: "aborted";
22763
22759
  thoughtSignature?: string;
22764
22760
  time: {
22765
22761
  start: number;
22766
22762
  end: number;
22767
22763
  };
22768
22764
  type: "toolCall";
22765
+ } | {
22766
+ type: "thinking";
22767
+ thinking: string;
22768
+ thinkingSignature?: string;
22769
+ redacted?: boolean;
22769
22770
  } | {
22770
22771
  addedToolNames?: string[];
22771
22772
  arguments: Record<string, any>;
22772
22773
  callID: string;
22773
22774
  name: string;
22774
22775
  namespace?: string;
22775
- result: {
22776
- content: ({
22776
+ partial?: {
22777
+ content?: ({
22777
22778
  type: "text";
22778
22779
  text: string;
22779
22780
  textSignature?: string;
@@ -22783,9 +22784,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22783
22784
  mimeType: string;
22784
22785
  })[];
22785
22786
  details?: any;
22786
- isError: true;
22787
22787
  };
22788
- status: "aborted";
22788
+ status: "running";
22789
22789
  thoughtSignature?: string;
22790
22790
  time: {
22791
22791
  start: number;
@@ -22960,19 +22960,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22960
22960
  type: "image";
22961
22961
  data: string;
22962
22962
  mimeType: string;
22963
- } | {
22964
- type: "thinking";
22965
- thinking: string;
22966
- thinkingSignature?: string;
22967
- redacted?: boolean;
22968
22963
  } | {
22969
22964
  addedToolNames?: string[];
22970
22965
  arguments: Record<string, any>;
22971
22966
  callID: string;
22972
22967
  name: string;
22973
22968
  namespace?: string;
22974
- partial?: {
22975
- content?: ({
22969
+ result: {
22970
+ content: ({
22976
22971
  type: "text";
22977
22972
  text: string;
22978
22973
  textSignature?: string;
@@ -22982,8 +22977,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22982
22977
  mimeType: string;
22983
22978
  })[];
22984
22979
  details?: any;
22980
+ isError: false;
22985
22981
  };
22986
- status: "running";
22982
+ status: "completed";
22987
22983
  thoughtSignature?: string;
22988
22984
  time: {
22989
22985
  start: number;
@@ -23007,9 +23003,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23007
23003
  mimeType: string;
23008
23004
  })[];
23009
23005
  details?: any;
23010
- isError: false;
23006
+ isError: true;
23011
23007
  };
23012
- status: "completed";
23008
+ status: "error";
23013
23009
  thoughtSignature?: string;
23014
23010
  time: {
23015
23011
  start: number;
@@ -23035,7 +23031,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23035
23031
  details?: any;
23036
23032
  isError: true;
23037
23033
  };
23038
- status: "error";
23034
+ status: "skipped";
23039
23035
  thoughtSignature?: string;
23040
23036
  time: {
23041
23037
  start: number;
@@ -23061,21 +23057,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23061
23057
  details?: any;
23062
23058
  isError: true;
23063
23059
  };
23064
- status: "skipped";
23060
+ status: "aborted";
23065
23061
  thoughtSignature?: string;
23066
23062
  time: {
23067
23063
  start: number;
23068
23064
  end: number;
23069
23065
  };
23070
23066
  type: "toolCall";
23067
+ } | {
23068
+ type: "thinking";
23069
+ thinking: string;
23070
+ thinkingSignature?: string;
23071
+ redacted?: boolean;
23071
23072
  } | {
23072
23073
  addedToolNames?: string[];
23073
23074
  arguments: Record<string, any>;
23074
23075
  callID: string;
23075
23076
  name: string;
23076
23077
  namespace?: string;
23077
- result: {
23078
- content: ({
23078
+ partial?: {
23079
+ content?: ({
23079
23080
  type: "text";
23080
23081
  text: string;
23081
23082
  textSignature?: string;
@@ -23085,9 +23086,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23085
23086
  mimeType: string;
23086
23087
  })[];
23087
23088
  details?: any;
23088
- isError: true;
23089
23089
  };
23090
- status: "aborted";
23090
+ status: "running";
23091
23091
  thoughtSignature?: string;
23092
23092
  time: {
23093
23093
  start: number;
@@ -23290,19 +23290,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23290
23290
  type: "image";
23291
23291
  data: string;
23292
23292
  mimeType: string;
23293
- } | {
23294
- type: "thinking";
23295
- thinking: string;
23296
- thinkingSignature?: string;
23297
- redacted?: boolean;
23298
23293
  } | {
23299
23294
  addedToolNames?: string[];
23300
23295
  arguments: Record<string, any>;
23301
23296
  callID: string;
23302
23297
  name: string;
23303
23298
  namespace?: string;
23304
- partial?: {
23305
- content?: ({
23299
+ result: {
23300
+ content: ({
23306
23301
  type: "text";
23307
23302
  text: string;
23308
23303
  textSignature?: string;
@@ -23312,8 +23307,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23312
23307
  mimeType: string;
23313
23308
  })[];
23314
23309
  details?: any;
23310
+ isError: false;
23315
23311
  };
23316
- status: "running";
23312
+ status: "completed";
23317
23313
  thoughtSignature?: string;
23318
23314
  time: {
23319
23315
  start: number;
@@ -23337,9 +23333,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23337
23333
  mimeType: string;
23338
23334
  })[];
23339
23335
  details?: any;
23340
- isError: false;
23336
+ isError: true;
23341
23337
  };
23342
- status: "completed";
23338
+ status: "error";
23343
23339
  thoughtSignature?: string;
23344
23340
  time: {
23345
23341
  start: number;
@@ -23365,7 +23361,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23365
23361
  details?: any;
23366
23362
  isError: true;
23367
23363
  };
23368
- status: "error";
23364
+ status: "skipped";
23369
23365
  thoughtSignature?: string;
23370
23366
  time: {
23371
23367
  start: number;
@@ -23391,21 +23387,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23391
23387
  details?: any;
23392
23388
  isError: true;
23393
23389
  };
23394
- status: "skipped";
23390
+ status: "aborted";
23395
23391
  thoughtSignature?: string;
23396
23392
  time: {
23397
23393
  start: number;
23398
23394
  end: number;
23399
23395
  };
23400
23396
  type: "toolCall";
23397
+ } | {
23398
+ type: "thinking";
23399
+ thinking: string;
23400
+ thinkingSignature?: string;
23401
+ redacted?: boolean;
23401
23402
  } | {
23402
23403
  addedToolNames?: string[];
23403
23404
  arguments: Record<string, any>;
23404
23405
  callID: string;
23405
23406
  name: string;
23406
23407
  namespace?: string;
23407
- result: {
23408
- content: ({
23408
+ partial?: {
23409
+ content?: ({
23409
23410
  type: "text";
23410
23411
  text: string;
23411
23412
  textSignature?: string;
@@ -23415,9 +23416,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23415
23416
  mimeType: string;
23416
23417
  })[];
23417
23418
  details?: any;
23418
- isError: true;
23419
23419
  };
23420
- status: "aborted";
23420
+ status: "running";
23421
23421
  thoughtSignature?: string;
23422
23422
  time: {
23423
23423
  start: number;
@@ -23592,19 +23592,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23592
23592
  type: "image";
23593
23593
  data: string;
23594
23594
  mimeType: string;
23595
- } | {
23596
- type: "thinking";
23597
- thinking: string;
23598
- thinkingSignature?: string;
23599
- redacted?: boolean;
23600
23595
  } | {
23601
23596
  addedToolNames?: string[];
23602
23597
  arguments: Record<string, any>;
23603
23598
  callID: string;
23604
23599
  name: string;
23605
23600
  namespace?: string;
23606
- partial?: {
23607
- content?: ({
23601
+ result: {
23602
+ content: ({
23608
23603
  type: "text";
23609
23604
  text: string;
23610
23605
  textSignature?: string;
@@ -23614,8 +23609,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23614
23609
  mimeType: string;
23615
23610
  })[];
23616
23611
  details?: any;
23612
+ isError: false;
23617
23613
  };
23618
- status: "running";
23614
+ status: "completed";
23619
23615
  thoughtSignature?: string;
23620
23616
  time: {
23621
23617
  start: number;
@@ -23639,9 +23635,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23639
23635
  mimeType: string;
23640
23636
  })[];
23641
23637
  details?: any;
23642
- isError: false;
23638
+ isError: true;
23643
23639
  };
23644
- status: "completed";
23640
+ status: "error";
23645
23641
  thoughtSignature?: string;
23646
23642
  time: {
23647
23643
  start: number;
@@ -23667,7 +23663,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23667
23663
  details?: any;
23668
23664
  isError: true;
23669
23665
  };
23670
- status: "error";
23666
+ status: "skipped";
23671
23667
  thoughtSignature?: string;
23672
23668
  time: {
23673
23669
  start: number;
@@ -23693,21 +23689,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23693
23689
  details?: any;
23694
23690
  isError: true;
23695
23691
  };
23696
- status: "skipped";
23692
+ status: "aborted";
23697
23693
  thoughtSignature?: string;
23698
23694
  time: {
23699
23695
  start: number;
23700
23696
  end: number;
23701
23697
  };
23702
23698
  type: "toolCall";
23699
+ } | {
23700
+ type: "thinking";
23701
+ thinking: string;
23702
+ thinkingSignature?: string;
23703
+ redacted?: boolean;
23703
23704
  } | {
23704
23705
  addedToolNames?: string[];
23705
23706
  arguments: Record<string, any>;
23706
23707
  callID: string;
23707
23708
  name: string;
23708
23709
  namespace?: string;
23709
- result: {
23710
- content: ({
23710
+ partial?: {
23711
+ content?: ({
23711
23712
  type: "text";
23712
23713
  text: string;
23713
23714
  textSignature?: string;
@@ -23717,9 +23718,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23717
23718
  mimeType: string;
23718
23719
  })[];
23719
23720
  details?: any;
23720
- isError: true;
23721
23721
  };
23722
- status: "aborted";
23722
+ status: "running";
23723
23723
  thoughtSignature?: string;
23724
23724
  time: {
23725
23725
  start: number;
@@ -23913,19 +23913,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23913
23913
  type: "image";
23914
23914
  data: string;
23915
23915
  mimeType: string;
23916
- } | {
23917
- type: "thinking";
23918
- thinking: string;
23919
- thinkingSignature?: string;
23920
- redacted?: boolean;
23921
23916
  } | {
23922
23917
  addedToolNames?: string[];
23923
23918
  arguments: Record<string, any>;
23924
23919
  callID: string;
23925
23920
  name: string;
23926
23921
  namespace?: string;
23927
- partial?: {
23928
- content?: ({
23922
+ result: {
23923
+ content: ({
23929
23924
  type: "text";
23930
23925
  text: string;
23931
23926
  textSignature?: string;
@@ -23935,8 +23930,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23935
23930
  mimeType: string;
23936
23931
  })[];
23937
23932
  details?: any;
23933
+ isError: false;
23938
23934
  };
23939
- status: "running";
23935
+ status: "completed";
23940
23936
  thoughtSignature?: string;
23941
23937
  time: {
23942
23938
  start: number;
@@ -23960,9 +23956,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23960
23956
  mimeType: string;
23961
23957
  })[];
23962
23958
  details?: any;
23963
- isError: false;
23959
+ isError: true;
23964
23960
  };
23965
- status: "completed";
23961
+ status: "error";
23966
23962
  thoughtSignature?: string;
23967
23963
  time: {
23968
23964
  start: number;
@@ -23988,7 +23984,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23988
23984
  details?: any;
23989
23985
  isError: true;
23990
23986
  };
23991
- status: "error";
23987
+ status: "skipped";
23992
23988
  thoughtSignature?: string;
23993
23989
  time: {
23994
23990
  start: number;
@@ -24014,21 +24010,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24014
24010
  details?: any;
24015
24011
  isError: true;
24016
24012
  };
24017
- status: "skipped";
24013
+ status: "aborted";
24018
24014
  thoughtSignature?: string;
24019
24015
  time: {
24020
24016
  start: number;
24021
24017
  end: number;
24022
24018
  };
24023
24019
  type: "toolCall";
24020
+ } | {
24021
+ type: "thinking";
24022
+ thinking: string;
24023
+ thinkingSignature?: string;
24024
+ redacted?: boolean;
24024
24025
  } | {
24025
24026
  addedToolNames?: string[];
24026
24027
  arguments: Record<string, any>;
24027
24028
  callID: string;
24028
24029
  name: string;
24029
24030
  namespace?: string;
24030
- result: {
24031
- content: ({
24031
+ partial?: {
24032
+ content?: ({
24032
24033
  type: "text";
24033
24034
  text: string;
24034
24035
  textSignature?: string;
@@ -24038,9 +24039,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24038
24039
  mimeType: string;
24039
24040
  })[];
24040
24041
  details?: any;
24041
- isError: true;
24042
24042
  };
24043
- status: "aborted";
24043
+ status: "running";
24044
24044
  thoughtSignature?: string;
24045
24045
  time: {
24046
24046
  start: number;
@@ -24215,19 +24215,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24215
24215
  type: "image";
24216
24216
  data: string;
24217
24217
  mimeType: string;
24218
- } | {
24219
- type: "thinking";
24220
- thinking: string;
24221
- thinkingSignature?: string;
24222
- redacted?: boolean;
24223
24218
  } | {
24224
24219
  addedToolNames?: string[];
24225
24220
  arguments: Record<string, any>;
24226
24221
  callID: string;
24227
24222
  name: string;
24228
24223
  namespace?: string;
24229
- partial?: {
24230
- content?: ({
24224
+ result: {
24225
+ content: ({
24231
24226
  type: "text";
24232
24227
  text: string;
24233
24228
  textSignature?: string;
@@ -24237,8 +24232,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24237
24232
  mimeType: string;
24238
24233
  })[];
24239
24234
  details?: any;
24235
+ isError: false;
24240
24236
  };
24241
- status: "running";
24237
+ status: "completed";
24242
24238
  thoughtSignature?: string;
24243
24239
  time: {
24244
24240
  start: number;
@@ -24262,9 +24258,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24262
24258
  mimeType: string;
24263
24259
  })[];
24264
24260
  details?: any;
24265
- isError: false;
24261
+ isError: true;
24266
24262
  };
24267
- status: "completed";
24263
+ status: "error";
24268
24264
  thoughtSignature?: string;
24269
24265
  time: {
24270
24266
  start: number;
@@ -24290,7 +24286,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24290
24286
  details?: any;
24291
24287
  isError: true;
24292
24288
  };
24293
- status: "error";
24289
+ status: "skipped";
24294
24290
  thoughtSignature?: string;
24295
24291
  time: {
24296
24292
  start: number;
@@ -24316,21 +24312,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24316
24312
  details?: any;
24317
24313
  isError: true;
24318
24314
  };
24319
- status: "skipped";
24315
+ status: "aborted";
24320
24316
  thoughtSignature?: string;
24321
24317
  time: {
24322
24318
  start: number;
24323
24319
  end: number;
24324
24320
  };
24325
24321
  type: "toolCall";
24322
+ } | {
24323
+ type: "thinking";
24324
+ thinking: string;
24325
+ thinkingSignature?: string;
24326
+ redacted?: boolean;
24326
24327
  } | {
24327
24328
  addedToolNames?: string[];
24328
24329
  arguments: Record<string, any>;
24329
24330
  callID: string;
24330
24331
  name: string;
24331
24332
  namespace?: string;
24332
- result: {
24333
- content: ({
24333
+ partial?: {
24334
+ content?: ({
24334
24335
  type: "text";
24335
24336
  text: string;
24336
24337
  textSignature?: string;
@@ -24340,9 +24341,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24340
24341
  mimeType: string;
24341
24342
  })[];
24342
24343
  details?: any;
24343
- isError: true;
24344
24344
  };
24345
- status: "aborted";
24345
+ status: "running";
24346
24346
  thoughtSignature?: string;
24347
24347
  time: {
24348
24348
  start: number;