@codeworksh/harness 0.3.0-canary.35.1.gd8b65e21 → 0.3.0-canary.36.1.g9945773b

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
@@ -2733,6 +2733,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2733
2733
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2734
2734
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2735
2735
  declare const encodeMessage: (message: {
2736
+ messageId: string;
2737
+ role: "user";
2738
+ time: {
2739
+ created: number;
2740
+ };
2741
+ parts: ({
2742
+ type: "text";
2743
+ text: string;
2744
+ textSignature?: string;
2745
+ } | {
2746
+ type: "image";
2747
+ data: string;
2748
+ mimeType: string;
2749
+ })[];
2750
+ } | {
2736
2751
  role: "assistant";
2737
2752
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2738
2753
  provider: {
@@ -2882,19 +2897,14 @@ declare const encodeMessage: (message: {
2882
2897
  type: "image";
2883
2898
  data: string;
2884
2899
  mimeType: string;
2885
- } | {
2886
- type: "thinking";
2887
- thinking: string;
2888
- thinkingSignature?: string;
2889
- redacted?: boolean;
2890
2900
  } | {
2891
2901
  addedToolNames?: string[];
2892
2902
  arguments: Record<string, any>;
2893
2903
  callID: string;
2894
2904
  name: string;
2895
2905
  namespace?: string;
2896
- partial?: {
2897
- content?: ({
2906
+ result: {
2907
+ content: ({
2898
2908
  type: "text";
2899
2909
  text: string;
2900
2910
  textSignature?: string;
@@ -2904,8 +2914,9 @@ declare const encodeMessage: (message: {
2904
2914
  mimeType: string;
2905
2915
  })[];
2906
2916
  details?: any;
2917
+ isError: false;
2907
2918
  };
2908
- status: "running";
2919
+ status: "completed";
2909
2920
  thoughtSignature?: string;
2910
2921
  time: {
2911
2922
  start: number;
@@ -2929,9 +2940,9 @@ declare const encodeMessage: (message: {
2929
2940
  mimeType: string;
2930
2941
  })[];
2931
2942
  details?: any;
2932
- isError: false;
2943
+ isError: true;
2933
2944
  };
2934
- status: "completed";
2945
+ status: "error";
2935
2946
  thoughtSignature?: string;
2936
2947
  time: {
2937
2948
  start: number;
@@ -2957,7 +2968,7 @@ declare const encodeMessage: (message: {
2957
2968
  details?: any;
2958
2969
  isError: true;
2959
2970
  };
2960
- status: "error";
2971
+ status: "skipped";
2961
2972
  thoughtSignature?: string;
2962
2973
  time: {
2963
2974
  start: number;
@@ -2983,21 +2994,26 @@ declare const encodeMessage: (message: {
2983
2994
  details?: any;
2984
2995
  isError: true;
2985
2996
  };
2986
- status: "skipped";
2997
+ status: "aborted";
2987
2998
  thoughtSignature?: string;
2988
2999
  time: {
2989
3000
  start: number;
2990
3001
  end: number;
2991
3002
  };
2992
3003
  type: "toolCall";
3004
+ } | {
3005
+ type: "thinking";
3006
+ thinking: string;
3007
+ thinkingSignature?: string;
3008
+ redacted?: boolean;
2993
3009
  } | {
2994
3010
  addedToolNames?: string[];
2995
3011
  arguments: Record<string, any>;
2996
3012
  callID: string;
2997
3013
  name: string;
2998
3014
  namespace?: string;
2999
- result: {
3000
- content: ({
3015
+ partial?: {
3016
+ content?: ({
3001
3017
  type: "text";
3002
3018
  text: string;
3003
3019
  textSignature?: string;
@@ -3007,9 +3023,8 @@ declare const encodeMessage: (message: {
3007
3023
  mimeType: string;
3008
3024
  })[];
3009
3025
  details?: any;
3010
- isError: true;
3011
3026
  };
3012
- status: "aborted";
3027
+ status: "running";
3013
3028
  thoughtSignature?: string;
3014
3029
  time: {
3015
3030
  start: number;
@@ -3034,7 +3049,8 @@ declare const encodeMessage: (message: {
3034
3049
  responseId?: string;
3035
3050
  responseModel?: string;
3036
3051
  messageId: string;
3037
- } | {
3052
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3053
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3038
3054
  messageId: string;
3039
3055
  role: "user";
3040
3056
  time: {
@@ -3049,8 +3065,8 @@ declare const encodeMessage: (message: {
3049
3065
  data: string;
3050
3066
  mimeType: string;
3051
3067
  })[];
3052
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3053
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3068
+ }, ContextDecodeError, never>;
3069
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3054
3070
  messageId: string;
3055
3071
  role: "user";
3056
3072
  time: {
@@ -3065,8 +3081,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3065
3081
  data: string;
3066
3082
  mimeType: string;
3067
3083
  })[];
3068
- }, ContextDecodeError, never>;
3069
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3084
+ } | {
3070
3085
  role: "assistant";
3071
3086
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3072
3087
  provider: {
@@ -3216,19 +3231,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3216
3231
  type: "image";
3217
3232
  data: string;
3218
3233
  mimeType: string;
3219
- } | {
3220
- type: "thinking";
3221
- thinking: string;
3222
- thinkingSignature?: string;
3223
- redacted?: boolean;
3224
3234
  } | {
3225
3235
  addedToolNames?: string[];
3226
3236
  arguments: Record<string, any>;
3227
3237
  callID: string;
3228
3238
  name: string;
3229
3239
  namespace?: string;
3230
- partial?: {
3231
- content?: ({
3240
+ result: {
3241
+ content: ({
3232
3242
  type: "text";
3233
3243
  text: string;
3234
3244
  textSignature?: string;
@@ -3238,8 +3248,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3238
3248
  mimeType: string;
3239
3249
  })[];
3240
3250
  details?: any;
3251
+ isError: false;
3241
3252
  };
3242
- status: "running";
3253
+ status: "completed";
3243
3254
  thoughtSignature?: string;
3244
3255
  time: {
3245
3256
  start: number;
@@ -3263,9 +3274,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3263
3274
  mimeType: string;
3264
3275
  })[];
3265
3276
  details?: any;
3266
- isError: false;
3277
+ isError: true;
3267
3278
  };
3268
- status: "completed";
3279
+ status: "error";
3269
3280
  thoughtSignature?: string;
3270
3281
  time: {
3271
3282
  start: number;
@@ -3291,7 +3302,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3291
3302
  details?: any;
3292
3303
  isError: true;
3293
3304
  };
3294
- status: "error";
3305
+ status: "skipped";
3295
3306
  thoughtSignature?: string;
3296
3307
  time: {
3297
3308
  start: number;
@@ -3317,21 +3328,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3317
3328
  details?: any;
3318
3329
  isError: true;
3319
3330
  };
3320
- status: "skipped";
3331
+ status: "aborted";
3321
3332
  thoughtSignature?: string;
3322
3333
  time: {
3323
3334
  start: number;
3324
3335
  end: number;
3325
3336
  };
3326
3337
  type: "toolCall";
3338
+ } | {
3339
+ type: "thinking";
3340
+ thinking: string;
3341
+ thinkingSignature?: string;
3342
+ redacted?: boolean;
3327
3343
  } | {
3328
3344
  addedToolNames?: string[];
3329
3345
  arguments: Record<string, any>;
3330
3346
  callID: string;
3331
3347
  name: string;
3332
3348
  namespace?: string;
3333
- result: {
3334
- content: ({
3349
+ partial?: {
3350
+ content?: ({
3335
3351
  type: "text";
3336
3352
  text: string;
3337
3353
  textSignature?: string;
@@ -3341,9 +3357,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3341
3357
  mimeType: string;
3342
3358
  })[];
3343
3359
  details?: any;
3344
- isError: true;
3345
3360
  };
3346
- status: "aborted";
3361
+ status: "running";
3347
3362
  thoughtSignature?: string;
3348
3363
  time: {
3349
3364
  start: number;
@@ -3368,21 +3383,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3368
3383
  responseId?: string;
3369
3384
  responseModel?: string;
3370
3385
  messageId: string;
3371
- } | {
3372
- messageId: string;
3373
- role: "user";
3374
- time: {
3375
- created: number;
3376
- };
3377
- parts: ({
3378
- type: "text";
3379
- text: string;
3380
- textSignature?: string;
3381
- } | {
3382
- type: "image";
3383
- data: string;
3384
- mimeType: string;
3385
- })[];
3386
3386
  }, ContextDecodeError, never>;
3387
3387
  declare namespace context_d_exports {
3388
3388
  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 };
@@ -4868,19 +4868,14 @@ declare const LLMStarted: Schema.Struct<{
4868
4868
  type: "image";
4869
4869
  data: string;
4870
4870
  mimeType: string;
4871
- } | {
4872
- type: "thinking";
4873
- thinking: string;
4874
- thinkingSignature?: string;
4875
- redacted?: boolean;
4876
4871
  } | {
4877
4872
  addedToolNames?: string[];
4878
4873
  arguments: Record<string, any>;
4879
4874
  callID: string;
4880
4875
  name: string;
4881
4876
  namespace?: string;
4882
- partial?: {
4883
- content?: ({
4877
+ result: {
4878
+ content: ({
4884
4879
  type: "text";
4885
4880
  text: string;
4886
4881
  textSignature?: string;
@@ -4890,8 +4885,9 @@ declare const LLMStarted: Schema.Struct<{
4890
4885
  mimeType: string;
4891
4886
  })[];
4892
4887
  details?: any;
4888
+ isError: false;
4893
4889
  };
4894
- status: "running";
4890
+ status: "completed";
4895
4891
  thoughtSignature?: string;
4896
4892
  time: {
4897
4893
  start: number;
@@ -4915,9 +4911,9 @@ declare const LLMStarted: Schema.Struct<{
4915
4911
  mimeType: string;
4916
4912
  })[];
4917
4913
  details?: any;
4918
- isError: false;
4914
+ isError: true;
4919
4915
  };
4920
- status: "completed";
4916
+ status: "error";
4921
4917
  thoughtSignature?: string;
4922
4918
  time: {
4923
4919
  start: number;
@@ -4943,7 +4939,7 @@ declare const LLMStarted: Schema.Struct<{
4943
4939
  details?: any;
4944
4940
  isError: true;
4945
4941
  };
4946
- status: "error";
4942
+ status: "skipped";
4947
4943
  thoughtSignature?: string;
4948
4944
  time: {
4949
4945
  start: number;
@@ -4969,21 +4965,26 @@ declare const LLMStarted: Schema.Struct<{
4969
4965
  details?: any;
4970
4966
  isError: true;
4971
4967
  };
4972
- status: "skipped";
4968
+ status: "aborted";
4973
4969
  thoughtSignature?: string;
4974
4970
  time: {
4975
4971
  start: number;
4976
4972
  end: number;
4977
4973
  };
4978
4974
  type: "toolCall";
4975
+ } | {
4976
+ type: "thinking";
4977
+ thinking: string;
4978
+ thinkingSignature?: string;
4979
+ redacted?: boolean;
4979
4980
  } | {
4980
4981
  addedToolNames?: string[];
4981
4982
  arguments: Record<string, any>;
4982
4983
  callID: string;
4983
4984
  name: string;
4984
4985
  namespace?: string;
4985
- result: {
4986
- content: ({
4986
+ partial?: {
4987
+ content?: ({
4987
4988
  type: "text";
4988
4989
  text: string;
4989
4990
  textSignature?: string;
@@ -4993,9 +4994,8 @@ declare const LLMStarted: Schema.Struct<{
4993
4994
  mimeType: string;
4994
4995
  })[];
4995
4996
  details?: any;
4996
- isError: true;
4997
4997
  };
4998
- status: "aborted";
4998
+ status: "running";
4999
4999
  thoughtSignature?: string;
5000
5000
  time: {
5001
5001
  start: number;
@@ -5170,19 +5170,14 @@ declare const LLMStarted: Schema.Struct<{
5170
5170
  type: "image";
5171
5171
  data: string;
5172
5172
  mimeType: string;
5173
- } | {
5174
- type: "thinking";
5175
- thinking: string;
5176
- thinkingSignature?: string;
5177
- redacted?: boolean;
5178
5173
  } | {
5179
5174
  addedToolNames?: string[];
5180
5175
  arguments: Record<string, any>;
5181
5176
  callID: string;
5182
5177
  name: string;
5183
5178
  namespace?: string;
5184
- partial?: {
5185
- content?: ({
5179
+ result: {
5180
+ content: ({
5186
5181
  type: "text";
5187
5182
  text: string;
5188
5183
  textSignature?: string;
@@ -5192,8 +5187,9 @@ declare const LLMStarted: Schema.Struct<{
5192
5187
  mimeType: string;
5193
5188
  })[];
5194
5189
  details?: any;
5190
+ isError: false;
5195
5191
  };
5196
- status: "running";
5192
+ status: "completed";
5197
5193
  thoughtSignature?: string;
5198
5194
  time: {
5199
5195
  start: number;
@@ -5217,9 +5213,9 @@ declare const LLMStarted: Schema.Struct<{
5217
5213
  mimeType: string;
5218
5214
  })[];
5219
5215
  details?: any;
5220
- isError: false;
5216
+ isError: true;
5221
5217
  };
5222
- status: "completed";
5218
+ status: "error";
5223
5219
  thoughtSignature?: string;
5224
5220
  time: {
5225
5221
  start: number;
@@ -5245,7 +5241,7 @@ declare const LLMStarted: Schema.Struct<{
5245
5241
  details?: any;
5246
5242
  isError: true;
5247
5243
  };
5248
- status: "error";
5244
+ status: "skipped";
5249
5245
  thoughtSignature?: string;
5250
5246
  time: {
5251
5247
  start: number;
@@ -5271,21 +5267,26 @@ declare const LLMStarted: Schema.Struct<{
5271
5267
  details?: any;
5272
5268
  isError: true;
5273
5269
  };
5274
- status: "skipped";
5270
+ status: "aborted";
5275
5271
  thoughtSignature?: string;
5276
5272
  time: {
5277
5273
  start: number;
5278
5274
  end: number;
5279
5275
  };
5280
5276
  type: "toolCall";
5277
+ } | {
5278
+ type: "thinking";
5279
+ thinking: string;
5280
+ thinkingSignature?: string;
5281
+ redacted?: boolean;
5281
5282
  } | {
5282
5283
  addedToolNames?: string[];
5283
5284
  arguments: Record<string, any>;
5284
5285
  callID: string;
5285
5286
  name: string;
5286
5287
  namespace?: string;
5287
- result: {
5288
- content: ({
5288
+ partial?: {
5289
+ content?: ({
5289
5290
  type: "text";
5290
5291
  text: string;
5291
5292
  textSignature?: string;
@@ -5295,9 +5296,8 @@ declare const LLMStarted: Schema.Struct<{
5295
5296
  mimeType: string;
5296
5297
  })[];
5297
5298
  details?: any;
5298
- isError: true;
5299
5299
  };
5300
- status: "aborted";
5300
+ status: "running";
5301
5301
  thoughtSignature?: string;
5302
5302
  time: {
5303
5303
  start: number;
@@ -5490,19 +5490,14 @@ declare const LLMStarted: Schema.Struct<{
5490
5490
  type: "image";
5491
5491
  data: string;
5492
5492
  mimeType: string;
5493
- } | {
5494
- type: "thinking";
5495
- thinking: string;
5496
- thinkingSignature?: string;
5497
- redacted?: boolean;
5498
5493
  } | {
5499
5494
  addedToolNames?: string[];
5500
5495
  arguments: Record<string, any>;
5501
5496
  callID: string;
5502
5497
  name: string;
5503
5498
  namespace?: string;
5504
- partial?: {
5505
- content?: ({
5499
+ result: {
5500
+ content: ({
5506
5501
  type: "text";
5507
5502
  text: string;
5508
5503
  textSignature?: string;
@@ -5512,8 +5507,9 @@ declare const LLMStarted: Schema.Struct<{
5512
5507
  mimeType: string;
5513
5508
  })[];
5514
5509
  details?: any;
5510
+ isError: false;
5515
5511
  };
5516
- status: "running";
5512
+ status: "completed";
5517
5513
  thoughtSignature?: string;
5518
5514
  time: {
5519
5515
  start: number;
@@ -5537,9 +5533,9 @@ declare const LLMStarted: Schema.Struct<{
5537
5533
  mimeType: string;
5538
5534
  })[];
5539
5535
  details?: any;
5540
- isError: false;
5536
+ isError: true;
5541
5537
  };
5542
- status: "completed";
5538
+ status: "error";
5543
5539
  thoughtSignature?: string;
5544
5540
  time: {
5545
5541
  start: number;
@@ -5565,7 +5561,7 @@ declare const LLMStarted: Schema.Struct<{
5565
5561
  details?: any;
5566
5562
  isError: true;
5567
5563
  };
5568
- status: "error";
5564
+ status: "skipped";
5569
5565
  thoughtSignature?: string;
5570
5566
  time: {
5571
5567
  start: number;
@@ -5591,21 +5587,26 @@ declare const LLMStarted: Schema.Struct<{
5591
5587
  details?: any;
5592
5588
  isError: true;
5593
5589
  };
5594
- status: "skipped";
5590
+ status: "aborted";
5595
5591
  thoughtSignature?: string;
5596
5592
  time: {
5597
5593
  start: number;
5598
5594
  end: number;
5599
5595
  };
5600
5596
  type: "toolCall";
5597
+ } | {
5598
+ type: "thinking";
5599
+ thinking: string;
5600
+ thinkingSignature?: string;
5601
+ redacted?: boolean;
5601
5602
  } | {
5602
5603
  addedToolNames?: string[];
5603
5604
  arguments: Record<string, any>;
5604
5605
  callID: string;
5605
5606
  name: string;
5606
5607
  namespace?: string;
5607
- result: {
5608
- content: ({
5608
+ partial?: {
5609
+ content?: ({
5609
5610
  type: "text";
5610
5611
  text: string;
5611
5612
  textSignature?: string;
@@ -5615,9 +5616,8 @@ declare const LLMStarted: Schema.Struct<{
5615
5616
  mimeType: string;
5616
5617
  })[];
5617
5618
  details?: any;
5618
- isError: true;
5619
5619
  };
5620
- status: "aborted";
5620
+ status: "running";
5621
5621
  thoughtSignature?: string;
5622
5622
  time: {
5623
5623
  start: number;
@@ -5792,19 +5792,14 @@ declare const LLMStarted: Schema.Struct<{
5792
5792
  type: "image";
5793
5793
  data: string;
5794
5794
  mimeType: string;
5795
- } | {
5796
- type: "thinking";
5797
- thinking: string;
5798
- thinkingSignature?: string;
5799
- redacted?: boolean;
5800
5795
  } | {
5801
5796
  addedToolNames?: string[];
5802
5797
  arguments: Record<string, any>;
5803
5798
  callID: string;
5804
5799
  name: string;
5805
5800
  namespace?: string;
5806
- partial?: {
5807
- content?: ({
5801
+ result: {
5802
+ content: ({
5808
5803
  type: "text";
5809
5804
  text: string;
5810
5805
  textSignature?: string;
@@ -5814,8 +5809,9 @@ declare const LLMStarted: Schema.Struct<{
5814
5809
  mimeType: string;
5815
5810
  })[];
5816
5811
  details?: any;
5812
+ isError: false;
5817
5813
  };
5818
- status: "running";
5814
+ status: "completed";
5819
5815
  thoughtSignature?: string;
5820
5816
  time: {
5821
5817
  start: number;
@@ -5839,9 +5835,9 @@ declare const LLMStarted: Schema.Struct<{
5839
5835
  mimeType: string;
5840
5836
  })[];
5841
5837
  details?: any;
5842
- isError: false;
5838
+ isError: true;
5843
5839
  };
5844
- status: "completed";
5840
+ status: "error";
5845
5841
  thoughtSignature?: string;
5846
5842
  time: {
5847
5843
  start: number;
@@ -5867,7 +5863,7 @@ declare const LLMStarted: Schema.Struct<{
5867
5863
  details?: any;
5868
5864
  isError: true;
5869
5865
  };
5870
- status: "error";
5866
+ status: "skipped";
5871
5867
  thoughtSignature?: string;
5872
5868
  time: {
5873
5869
  start: number;
@@ -5893,21 +5889,26 @@ declare const LLMStarted: Schema.Struct<{
5893
5889
  details?: any;
5894
5890
  isError: true;
5895
5891
  };
5896
- status: "skipped";
5892
+ status: "aborted";
5897
5893
  thoughtSignature?: string;
5898
5894
  time: {
5899
5895
  start: number;
5900
5896
  end: number;
5901
5897
  };
5902
5898
  type: "toolCall";
5899
+ } | {
5900
+ type: "thinking";
5901
+ thinking: string;
5902
+ thinkingSignature?: string;
5903
+ redacted?: boolean;
5903
5904
  } | {
5904
5905
  addedToolNames?: string[];
5905
5906
  arguments: Record<string, any>;
5906
5907
  callID: string;
5907
5908
  name: string;
5908
5909
  namespace?: string;
5909
- result: {
5910
- content: ({
5910
+ partial?: {
5911
+ content?: ({
5911
5912
  type: "text";
5912
5913
  text: string;
5913
5914
  textSignature?: string;
@@ -5917,9 +5918,8 @@ declare const LLMStarted: Schema.Struct<{
5917
5918
  mimeType: string;
5918
5919
  })[];
5919
5920
  details?: any;
5920
- isError: true;
5921
5921
  };
5922
- status: "aborted";
5922
+ status: "running";
5923
5923
  thoughtSignature?: string;
5924
5924
  time: {
5925
5925
  start: number;
@@ -6415,19 +6415,14 @@ declare const LLMEnded: Schema.Struct<{
6415
6415
  type: "image";
6416
6416
  data: string;
6417
6417
  mimeType: string;
6418
- } | {
6419
- type: "thinking";
6420
- thinking: string;
6421
- thinkingSignature?: string;
6422
- redacted?: boolean;
6423
6418
  } | {
6424
6419
  addedToolNames?: string[];
6425
6420
  arguments: Record<string, any>;
6426
6421
  callID: string;
6427
6422
  name: string;
6428
6423
  namespace?: string;
6429
- partial?: {
6430
- content?: ({
6424
+ result: {
6425
+ content: ({
6431
6426
  type: "text";
6432
6427
  text: string;
6433
6428
  textSignature?: string;
@@ -6437,8 +6432,9 @@ declare const LLMEnded: Schema.Struct<{
6437
6432
  mimeType: string;
6438
6433
  })[];
6439
6434
  details?: any;
6435
+ isError: false;
6440
6436
  };
6441
- status: "running";
6437
+ status: "completed";
6442
6438
  thoughtSignature?: string;
6443
6439
  time: {
6444
6440
  start: number;
@@ -6462,9 +6458,9 @@ declare const LLMEnded: Schema.Struct<{
6462
6458
  mimeType: string;
6463
6459
  })[];
6464
6460
  details?: any;
6465
- isError: false;
6461
+ isError: true;
6466
6462
  };
6467
- status: "completed";
6463
+ status: "error";
6468
6464
  thoughtSignature?: string;
6469
6465
  time: {
6470
6466
  start: number;
@@ -6490,7 +6486,7 @@ declare const LLMEnded: Schema.Struct<{
6490
6486
  details?: any;
6491
6487
  isError: true;
6492
6488
  };
6493
- status: "error";
6489
+ status: "skipped";
6494
6490
  thoughtSignature?: string;
6495
6491
  time: {
6496
6492
  start: number;
@@ -6516,7 +6512,7 @@ declare const LLMEnded: Schema.Struct<{
6516
6512
  details?: any;
6517
6513
  isError: true;
6518
6514
  };
6519
- status: "skipped";
6515
+ status: "aborted";
6520
6516
  thoughtSignature?: string;
6521
6517
  time: {
6522
6518
  start: number;
@@ -6524,13 +6520,18 @@ declare const LLMEnded: Schema.Struct<{
6524
6520
  };
6525
6521
  type: "toolCall";
6526
6522
  } | {
6527
- addedToolNames?: string[];
6528
- arguments: Record<string, any>;
6529
- callID: string;
6530
- name: string;
6523
+ type: "thinking";
6524
+ thinking: string;
6525
+ thinkingSignature?: string;
6526
+ redacted?: boolean;
6527
+ } | {
6528
+ addedToolNames?: string[];
6529
+ arguments: Record<string, any>;
6530
+ callID: string;
6531
+ name: string;
6531
6532
  namespace?: string;
6532
- result: {
6533
- content: ({
6533
+ partial?: {
6534
+ content?: ({
6534
6535
  type: "text";
6535
6536
  text: string;
6536
6537
  textSignature?: string;
@@ -6540,9 +6541,8 @@ declare const LLMEnded: Schema.Struct<{
6540
6541
  mimeType: string;
6541
6542
  })[];
6542
6543
  details?: any;
6543
- isError: true;
6544
6544
  };
6545
- status: "aborted";
6545
+ status: "running";
6546
6546
  thoughtSignature?: string;
6547
6547
  time: {
6548
6548
  start: number;
@@ -6717,19 +6717,14 @@ declare const LLMEnded: Schema.Struct<{
6717
6717
  type: "image";
6718
6718
  data: string;
6719
6719
  mimeType: string;
6720
- } | {
6721
- type: "thinking";
6722
- thinking: string;
6723
- thinkingSignature?: string;
6724
- redacted?: boolean;
6725
6720
  } | {
6726
6721
  addedToolNames?: string[];
6727
6722
  arguments: Record<string, any>;
6728
6723
  callID: string;
6729
6724
  name: string;
6730
6725
  namespace?: string;
6731
- partial?: {
6732
- content?: ({
6726
+ result: {
6727
+ content: ({
6733
6728
  type: "text";
6734
6729
  text: string;
6735
6730
  textSignature?: string;
@@ -6739,8 +6734,9 @@ declare const LLMEnded: Schema.Struct<{
6739
6734
  mimeType: string;
6740
6735
  })[];
6741
6736
  details?: any;
6737
+ isError: false;
6742
6738
  };
6743
- status: "running";
6739
+ status: "completed";
6744
6740
  thoughtSignature?: string;
6745
6741
  time: {
6746
6742
  start: number;
@@ -6764,9 +6760,9 @@ declare const LLMEnded: Schema.Struct<{
6764
6760
  mimeType: string;
6765
6761
  })[];
6766
6762
  details?: any;
6767
- isError: false;
6763
+ isError: true;
6768
6764
  };
6769
- status: "completed";
6765
+ status: "error";
6770
6766
  thoughtSignature?: string;
6771
6767
  time: {
6772
6768
  start: number;
@@ -6792,7 +6788,7 @@ declare const LLMEnded: Schema.Struct<{
6792
6788
  details?: any;
6793
6789
  isError: true;
6794
6790
  };
6795
- status: "error";
6791
+ status: "skipped";
6796
6792
  thoughtSignature?: string;
6797
6793
  time: {
6798
6794
  start: number;
@@ -6818,21 +6814,26 @@ declare const LLMEnded: Schema.Struct<{
6818
6814
  details?: any;
6819
6815
  isError: true;
6820
6816
  };
6821
- status: "skipped";
6817
+ status: "aborted";
6822
6818
  thoughtSignature?: string;
6823
6819
  time: {
6824
6820
  start: number;
6825
6821
  end: number;
6826
6822
  };
6827
6823
  type: "toolCall";
6824
+ } | {
6825
+ type: "thinking";
6826
+ thinking: string;
6827
+ thinkingSignature?: string;
6828
+ redacted?: boolean;
6828
6829
  } | {
6829
6830
  addedToolNames?: string[];
6830
6831
  arguments: Record<string, any>;
6831
6832
  callID: string;
6832
6833
  name: string;
6833
6834
  namespace?: string;
6834
- result: {
6835
- content: ({
6835
+ partial?: {
6836
+ content?: ({
6836
6837
  type: "text";
6837
6838
  text: string;
6838
6839
  textSignature?: string;
@@ -6842,9 +6843,8 @@ declare const LLMEnded: Schema.Struct<{
6842
6843
  mimeType: string;
6843
6844
  })[];
6844
6845
  details?: any;
6845
- isError: true;
6846
6846
  };
6847
- status: "aborted";
6847
+ status: "running";
6848
6848
  thoughtSignature?: string;
6849
6849
  time: {
6850
6850
  start: number;
@@ -7038,19 +7038,14 @@ declare const LLMEnded: Schema.Struct<{
7038
7038
  type: "image";
7039
7039
  data: string;
7040
7040
  mimeType: string;
7041
- } | {
7042
- type: "thinking";
7043
- thinking: string;
7044
- thinkingSignature?: string;
7045
- redacted?: boolean;
7046
7041
  } | {
7047
7042
  addedToolNames?: string[];
7048
7043
  arguments: Record<string, any>;
7049
7044
  callID: string;
7050
7045
  name: string;
7051
7046
  namespace?: string;
7052
- partial?: {
7053
- content?: ({
7047
+ result: {
7048
+ content: ({
7054
7049
  type: "text";
7055
7050
  text: string;
7056
7051
  textSignature?: string;
@@ -7060,8 +7055,9 @@ declare const LLMEnded: Schema.Struct<{
7060
7055
  mimeType: string;
7061
7056
  })[];
7062
7057
  details?: any;
7058
+ isError: false;
7063
7059
  };
7064
- status: "running";
7060
+ status: "completed";
7065
7061
  thoughtSignature?: string;
7066
7062
  time: {
7067
7063
  start: number;
@@ -7085,9 +7081,9 @@ declare const LLMEnded: Schema.Struct<{
7085
7081
  mimeType: string;
7086
7082
  })[];
7087
7083
  details?: any;
7088
- isError: false;
7084
+ isError: true;
7089
7085
  };
7090
- status: "completed";
7086
+ status: "error";
7091
7087
  thoughtSignature?: string;
7092
7088
  time: {
7093
7089
  start: number;
@@ -7113,7 +7109,7 @@ declare const LLMEnded: Schema.Struct<{
7113
7109
  details?: any;
7114
7110
  isError: true;
7115
7111
  };
7116
- status: "error";
7112
+ status: "skipped";
7117
7113
  thoughtSignature?: string;
7118
7114
  time: {
7119
7115
  start: number;
@@ -7139,21 +7135,26 @@ declare const LLMEnded: Schema.Struct<{
7139
7135
  details?: any;
7140
7136
  isError: true;
7141
7137
  };
7142
- status: "skipped";
7138
+ status: "aborted";
7143
7139
  thoughtSignature?: string;
7144
7140
  time: {
7145
7141
  start: number;
7146
7142
  end: number;
7147
7143
  };
7148
7144
  type: "toolCall";
7145
+ } | {
7146
+ type: "thinking";
7147
+ thinking: string;
7148
+ thinkingSignature?: string;
7149
+ redacted?: boolean;
7149
7150
  } | {
7150
7151
  addedToolNames?: string[];
7151
7152
  arguments: Record<string, any>;
7152
7153
  callID: string;
7153
7154
  name: string;
7154
7155
  namespace?: string;
7155
- result: {
7156
- content: ({
7156
+ partial?: {
7157
+ content?: ({
7157
7158
  type: "text";
7158
7159
  text: string;
7159
7160
  textSignature?: string;
@@ -7163,9 +7164,8 @@ declare const LLMEnded: Schema.Struct<{
7163
7164
  mimeType: string;
7164
7165
  })[];
7165
7166
  details?: any;
7166
- isError: true;
7167
7167
  };
7168
- status: "aborted";
7168
+ status: "running";
7169
7169
  thoughtSignature?: string;
7170
7170
  time: {
7171
7171
  start: number;
@@ -7340,19 +7340,14 @@ declare const LLMEnded: Schema.Struct<{
7340
7340
  type: "image";
7341
7341
  data: string;
7342
7342
  mimeType: string;
7343
- } | {
7344
- type: "thinking";
7345
- thinking: string;
7346
- thinkingSignature?: string;
7347
- redacted?: boolean;
7348
7343
  } | {
7349
7344
  addedToolNames?: string[];
7350
7345
  arguments: Record<string, any>;
7351
7346
  callID: string;
7352
7347
  name: string;
7353
7348
  namespace?: string;
7354
- partial?: {
7355
- content?: ({
7349
+ result: {
7350
+ content: ({
7356
7351
  type: "text";
7357
7352
  text: string;
7358
7353
  textSignature?: string;
@@ -7362,8 +7357,9 @@ declare const LLMEnded: Schema.Struct<{
7362
7357
  mimeType: string;
7363
7358
  })[];
7364
7359
  details?: any;
7360
+ isError: false;
7365
7361
  };
7366
- status: "running";
7362
+ status: "completed";
7367
7363
  thoughtSignature?: string;
7368
7364
  time: {
7369
7365
  start: number;
@@ -7387,9 +7383,9 @@ declare const LLMEnded: Schema.Struct<{
7387
7383
  mimeType: string;
7388
7384
  })[];
7389
7385
  details?: any;
7390
- isError: false;
7386
+ isError: true;
7391
7387
  };
7392
- status: "completed";
7388
+ status: "error";
7393
7389
  thoughtSignature?: string;
7394
7390
  time: {
7395
7391
  start: number;
@@ -7415,7 +7411,7 @@ declare const LLMEnded: Schema.Struct<{
7415
7411
  details?: any;
7416
7412
  isError: true;
7417
7413
  };
7418
- status: "error";
7414
+ status: "skipped";
7419
7415
  thoughtSignature?: string;
7420
7416
  time: {
7421
7417
  start: number;
@@ -7441,21 +7437,26 @@ declare const LLMEnded: Schema.Struct<{
7441
7437
  details?: any;
7442
7438
  isError: true;
7443
7439
  };
7444
- status: "skipped";
7440
+ status: "aborted";
7445
7441
  thoughtSignature?: string;
7446
7442
  time: {
7447
7443
  start: number;
7448
7444
  end: number;
7449
7445
  };
7450
7446
  type: "toolCall";
7447
+ } | {
7448
+ type: "thinking";
7449
+ thinking: string;
7450
+ thinkingSignature?: string;
7451
+ redacted?: boolean;
7451
7452
  } | {
7452
7453
  addedToolNames?: string[];
7453
7454
  arguments: Record<string, any>;
7454
7455
  callID: string;
7455
7456
  name: string;
7456
7457
  namespace?: string;
7457
- result: {
7458
- content: ({
7458
+ partial?: {
7459
+ content?: ({
7459
7460
  type: "text";
7460
7461
  text: string;
7461
7462
  textSignature?: string;
@@ -7465,9 +7466,8 @@ declare const LLMEnded: Schema.Struct<{
7465
7466
  mimeType: string;
7466
7467
  })[];
7467
7468
  details?: any;
7468
- isError: true;
7469
7469
  };
7470
- status: "aborted";
7470
+ status: "running";
7471
7471
  thoughtSignature?: string;
7472
7472
  time: {
7473
7473
  start: number;
@@ -7673,19 +7673,14 @@ declare const LLMFailed: Schema.Struct<{
7673
7673
  type: "image";
7674
7674
  data: string;
7675
7675
  mimeType: string;
7676
- } | {
7677
- type: "thinking";
7678
- thinking: string;
7679
- thinkingSignature?: string;
7680
- redacted?: boolean;
7681
7676
  } | {
7682
7677
  addedToolNames?: string[];
7683
7678
  arguments: Record<string, any>;
7684
7679
  callID: string;
7685
7680
  name: string;
7686
7681
  namespace?: string;
7687
- partial?: {
7688
- content?: ({
7682
+ result: {
7683
+ content: ({
7689
7684
  type: "text";
7690
7685
  text: string;
7691
7686
  textSignature?: string;
@@ -7695,8 +7690,9 @@ declare const LLMFailed: Schema.Struct<{
7695
7690
  mimeType: string;
7696
7691
  })[];
7697
7692
  details?: any;
7693
+ isError: false;
7698
7694
  };
7699
- status: "running";
7695
+ status: "completed";
7700
7696
  thoughtSignature?: string;
7701
7697
  time: {
7702
7698
  start: number;
@@ -7720,9 +7716,9 @@ declare const LLMFailed: Schema.Struct<{
7720
7716
  mimeType: string;
7721
7717
  })[];
7722
7718
  details?: any;
7723
- isError: false;
7719
+ isError: true;
7724
7720
  };
7725
- status: "completed";
7721
+ status: "error";
7726
7722
  thoughtSignature?: string;
7727
7723
  time: {
7728
7724
  start: number;
@@ -7748,7 +7744,7 @@ declare const LLMFailed: Schema.Struct<{
7748
7744
  details?: any;
7749
7745
  isError: true;
7750
7746
  };
7751
- status: "error";
7747
+ status: "skipped";
7752
7748
  thoughtSignature?: string;
7753
7749
  time: {
7754
7750
  start: number;
@@ -7774,21 +7770,26 @@ declare const LLMFailed: Schema.Struct<{
7774
7770
  details?: any;
7775
7771
  isError: true;
7776
7772
  };
7777
- status: "skipped";
7773
+ status: "aborted";
7778
7774
  thoughtSignature?: string;
7779
7775
  time: {
7780
7776
  start: number;
7781
7777
  end: number;
7782
7778
  };
7783
7779
  type: "toolCall";
7780
+ } | {
7781
+ type: "thinking";
7782
+ thinking: string;
7783
+ thinkingSignature?: string;
7784
+ redacted?: boolean;
7784
7785
  } | {
7785
7786
  addedToolNames?: string[];
7786
7787
  arguments: Record<string, any>;
7787
7788
  callID: string;
7788
7789
  name: string;
7789
7790
  namespace?: string;
7790
- result: {
7791
- content: ({
7791
+ partial?: {
7792
+ content?: ({
7792
7793
  type: "text";
7793
7794
  text: string;
7794
7795
  textSignature?: string;
@@ -7798,9 +7799,8 @@ declare const LLMFailed: Schema.Struct<{
7798
7799
  mimeType: string;
7799
7800
  })[];
7800
7801
  details?: any;
7801
- isError: true;
7802
7802
  };
7803
- status: "aborted";
7803
+ status: "running";
7804
7804
  thoughtSignature?: string;
7805
7805
  time: {
7806
7806
  start: number;
@@ -7975,19 +7975,14 @@ declare const LLMFailed: Schema.Struct<{
7975
7975
  type: "image";
7976
7976
  data: string;
7977
7977
  mimeType: string;
7978
- } | {
7979
- type: "thinking";
7980
- thinking: string;
7981
- thinkingSignature?: string;
7982
- redacted?: boolean;
7983
7978
  } | {
7984
7979
  addedToolNames?: string[];
7985
7980
  arguments: Record<string, any>;
7986
7981
  callID: string;
7987
7982
  name: string;
7988
7983
  namespace?: string;
7989
- partial?: {
7990
- content?: ({
7984
+ result: {
7985
+ content: ({
7991
7986
  type: "text";
7992
7987
  text: string;
7993
7988
  textSignature?: string;
@@ -7997,8 +7992,9 @@ declare const LLMFailed: Schema.Struct<{
7997
7992
  mimeType: string;
7998
7993
  })[];
7999
7994
  details?: any;
7995
+ isError: false;
8000
7996
  };
8001
- status: "running";
7997
+ status: "completed";
8002
7998
  thoughtSignature?: string;
8003
7999
  time: {
8004
8000
  start: number;
@@ -8022,9 +8018,9 @@ declare const LLMFailed: Schema.Struct<{
8022
8018
  mimeType: string;
8023
8019
  })[];
8024
8020
  details?: any;
8025
- isError: false;
8021
+ isError: true;
8026
8022
  };
8027
- status: "completed";
8023
+ status: "error";
8028
8024
  thoughtSignature?: string;
8029
8025
  time: {
8030
8026
  start: number;
@@ -8050,7 +8046,7 @@ declare const LLMFailed: Schema.Struct<{
8050
8046
  details?: any;
8051
8047
  isError: true;
8052
8048
  };
8053
- status: "error";
8049
+ status: "skipped";
8054
8050
  thoughtSignature?: string;
8055
8051
  time: {
8056
8052
  start: number;
@@ -8076,21 +8072,26 @@ declare const LLMFailed: Schema.Struct<{
8076
8072
  details?: any;
8077
8073
  isError: true;
8078
8074
  };
8079
- status: "skipped";
8075
+ status: "aborted";
8080
8076
  thoughtSignature?: string;
8081
8077
  time: {
8082
8078
  start: number;
8083
8079
  end: number;
8084
8080
  };
8085
8081
  type: "toolCall";
8082
+ } | {
8083
+ type: "thinking";
8084
+ thinking: string;
8085
+ thinkingSignature?: string;
8086
+ redacted?: boolean;
8086
8087
  } | {
8087
8088
  addedToolNames?: string[];
8088
8089
  arguments: Record<string, any>;
8089
8090
  callID: string;
8090
8091
  name: string;
8091
8092
  namespace?: string;
8092
- result: {
8093
- content: ({
8093
+ partial?: {
8094
+ content?: ({
8094
8095
  type: "text";
8095
8096
  text: string;
8096
8097
  textSignature?: string;
@@ -8100,9 +8101,8 @@ declare const LLMFailed: Schema.Struct<{
8100
8101
  mimeType: string;
8101
8102
  })[];
8102
8103
  details?: any;
8103
- isError: true;
8104
8104
  };
8105
- status: "aborted";
8105
+ status: "running";
8106
8106
  thoughtSignature?: string;
8107
8107
  time: {
8108
8108
  start: number;
@@ -8296,19 +8296,14 @@ declare const LLMFailed: Schema.Struct<{
8296
8296
  type: "image";
8297
8297
  data: string;
8298
8298
  mimeType: string;
8299
- } | {
8300
- type: "thinking";
8301
- thinking: string;
8302
- thinkingSignature?: string;
8303
- redacted?: boolean;
8304
8299
  } | {
8305
8300
  addedToolNames?: string[];
8306
8301
  arguments: Record<string, any>;
8307
8302
  callID: string;
8308
8303
  name: string;
8309
8304
  namespace?: string;
8310
- partial?: {
8311
- content?: ({
8305
+ result: {
8306
+ content: ({
8312
8307
  type: "text";
8313
8308
  text: string;
8314
8309
  textSignature?: string;
@@ -8318,8 +8313,9 @@ declare const LLMFailed: Schema.Struct<{
8318
8313
  mimeType: string;
8319
8314
  })[];
8320
8315
  details?: any;
8316
+ isError: false;
8321
8317
  };
8322
- status: "running";
8318
+ status: "completed";
8323
8319
  thoughtSignature?: string;
8324
8320
  time: {
8325
8321
  start: number;
@@ -8343,9 +8339,9 @@ declare const LLMFailed: Schema.Struct<{
8343
8339
  mimeType: string;
8344
8340
  })[];
8345
8341
  details?: any;
8346
- isError: false;
8342
+ isError: true;
8347
8343
  };
8348
- status: "completed";
8344
+ status: "error";
8349
8345
  thoughtSignature?: string;
8350
8346
  time: {
8351
8347
  start: number;
@@ -8371,7 +8367,7 @@ declare const LLMFailed: Schema.Struct<{
8371
8367
  details?: any;
8372
8368
  isError: true;
8373
8369
  };
8374
- status: "error";
8370
+ status: "skipped";
8375
8371
  thoughtSignature?: string;
8376
8372
  time: {
8377
8373
  start: number;
@@ -8397,21 +8393,26 @@ declare const LLMFailed: Schema.Struct<{
8397
8393
  details?: any;
8398
8394
  isError: true;
8399
8395
  };
8400
- status: "skipped";
8396
+ status: "aborted";
8401
8397
  thoughtSignature?: string;
8402
8398
  time: {
8403
8399
  start: number;
8404
8400
  end: number;
8405
8401
  };
8406
8402
  type: "toolCall";
8403
+ } | {
8404
+ type: "thinking";
8405
+ thinking: string;
8406
+ thinkingSignature?: string;
8407
+ redacted?: boolean;
8407
8408
  } | {
8408
8409
  addedToolNames?: string[];
8409
8410
  arguments: Record<string, any>;
8410
8411
  callID: string;
8411
8412
  name: string;
8412
8413
  namespace?: string;
8413
- result: {
8414
- content: ({
8414
+ partial?: {
8415
+ content?: ({
8415
8416
  type: "text";
8416
8417
  text: string;
8417
8418
  textSignature?: string;
@@ -8421,9 +8422,8 @@ declare const LLMFailed: Schema.Struct<{
8421
8422
  mimeType: string;
8422
8423
  })[];
8423
8424
  details?: any;
8424
- isError: true;
8425
8425
  };
8426
- status: "aborted";
8426
+ status: "running";
8427
8427
  thoughtSignature?: string;
8428
8428
  time: {
8429
8429
  start: number;
@@ -8598,19 +8598,14 @@ declare const LLMFailed: Schema.Struct<{
8598
8598
  type: "image";
8599
8599
  data: string;
8600
8600
  mimeType: string;
8601
- } | {
8602
- type: "thinking";
8603
- thinking: string;
8604
- thinkingSignature?: string;
8605
- redacted?: boolean;
8606
8601
  } | {
8607
8602
  addedToolNames?: string[];
8608
8603
  arguments: Record<string, any>;
8609
8604
  callID: string;
8610
8605
  name: string;
8611
8606
  namespace?: string;
8612
- partial?: {
8613
- content?: ({
8607
+ result: {
8608
+ content: ({
8614
8609
  type: "text";
8615
8610
  text: string;
8616
8611
  textSignature?: string;
@@ -8620,8 +8615,9 @@ declare const LLMFailed: Schema.Struct<{
8620
8615
  mimeType: string;
8621
8616
  })[];
8622
8617
  details?: any;
8618
+ isError: false;
8623
8619
  };
8624
- status: "running";
8620
+ status: "completed";
8625
8621
  thoughtSignature?: string;
8626
8622
  time: {
8627
8623
  start: number;
@@ -8645,9 +8641,9 @@ declare const LLMFailed: Schema.Struct<{
8645
8641
  mimeType: string;
8646
8642
  })[];
8647
8643
  details?: any;
8648
- isError: false;
8644
+ isError: true;
8649
8645
  };
8650
- status: "completed";
8646
+ status: "error";
8651
8647
  thoughtSignature?: string;
8652
8648
  time: {
8653
8649
  start: number;
@@ -8673,7 +8669,7 @@ declare const LLMFailed: Schema.Struct<{
8673
8669
  details?: any;
8674
8670
  isError: true;
8675
8671
  };
8676
- status: "error";
8672
+ status: "skipped";
8677
8673
  thoughtSignature?: string;
8678
8674
  time: {
8679
8675
  start: number;
@@ -8699,21 +8695,26 @@ declare const LLMFailed: Schema.Struct<{
8699
8695
  details?: any;
8700
8696
  isError: true;
8701
8697
  };
8702
- status: "skipped";
8698
+ status: "aborted";
8703
8699
  thoughtSignature?: string;
8704
8700
  time: {
8705
8701
  start: number;
8706
8702
  end: number;
8707
8703
  };
8708
8704
  type: "toolCall";
8705
+ } | {
8706
+ type: "thinking";
8707
+ thinking: string;
8708
+ thinkingSignature?: string;
8709
+ redacted?: boolean;
8709
8710
  } | {
8710
8711
  addedToolNames?: string[];
8711
8712
  arguments: Record<string, any>;
8712
8713
  callID: string;
8713
8714
  name: string;
8714
8715
  namespace?: string;
8715
- result: {
8716
- content: ({
8716
+ partial?: {
8717
+ content?: ({
8717
8718
  type: "text";
8718
8719
  text: string;
8719
8720
  textSignature?: string;
@@ -8723,9 +8724,8 @@ declare const LLMFailed: Schema.Struct<{
8723
8724
  mimeType: string;
8724
8725
  })[];
8725
8726
  details?: any;
8726
- isError: true;
8727
8727
  };
8728
- status: "aborted";
8728
+ status: "running";
8729
8729
  thoughtSignature?: string;
8730
8730
  time: {
8731
8731
  start: number;
@@ -10473,19 +10473,14 @@ declare const Definitions: readonly [Schema.Struct<{
10473
10473
  type: "image";
10474
10474
  data: string;
10475
10475
  mimeType: string;
10476
- } | {
10477
- type: "thinking";
10478
- thinking: string;
10479
- thinkingSignature?: string;
10480
- redacted?: boolean;
10481
10476
  } | {
10482
10477
  addedToolNames?: string[];
10483
10478
  arguments: Record<string, any>;
10484
10479
  callID: string;
10485
10480
  name: string;
10486
10481
  namespace?: string;
10487
- partial?: {
10488
- content?: ({
10482
+ result: {
10483
+ content: ({
10489
10484
  type: "text";
10490
10485
  text: string;
10491
10486
  textSignature?: string;
@@ -10495,8 +10490,9 @@ declare const Definitions: readonly [Schema.Struct<{
10495
10490
  mimeType: string;
10496
10491
  })[];
10497
10492
  details?: any;
10493
+ isError: false;
10498
10494
  };
10499
- status: "running";
10495
+ status: "completed";
10500
10496
  thoughtSignature?: string;
10501
10497
  time: {
10502
10498
  start: number;
@@ -10520,9 +10516,9 @@ declare const Definitions: readonly [Schema.Struct<{
10520
10516
  mimeType: string;
10521
10517
  })[];
10522
10518
  details?: any;
10523
- isError: false;
10519
+ isError: true;
10524
10520
  };
10525
- status: "completed";
10521
+ status: "error";
10526
10522
  thoughtSignature?: string;
10527
10523
  time: {
10528
10524
  start: number;
@@ -10548,7 +10544,7 @@ declare const Definitions: readonly [Schema.Struct<{
10548
10544
  details?: any;
10549
10545
  isError: true;
10550
10546
  };
10551
- status: "error";
10547
+ status: "skipped";
10552
10548
  thoughtSignature?: string;
10553
10549
  time: {
10554
10550
  start: number;
@@ -10574,21 +10570,26 @@ declare const Definitions: readonly [Schema.Struct<{
10574
10570
  details?: any;
10575
10571
  isError: true;
10576
10572
  };
10577
- status: "skipped";
10573
+ status: "aborted";
10578
10574
  thoughtSignature?: string;
10579
10575
  time: {
10580
10576
  start: number;
10581
10577
  end: number;
10582
10578
  };
10583
10579
  type: "toolCall";
10580
+ } | {
10581
+ type: "thinking";
10582
+ thinking: string;
10583
+ thinkingSignature?: string;
10584
+ redacted?: boolean;
10584
10585
  } | {
10585
10586
  addedToolNames?: string[];
10586
10587
  arguments: Record<string, any>;
10587
10588
  callID: string;
10588
10589
  name: string;
10589
10590
  namespace?: string;
10590
- result: {
10591
- content: ({
10591
+ partial?: {
10592
+ content?: ({
10592
10593
  type: "text";
10593
10594
  text: string;
10594
10595
  textSignature?: string;
@@ -10598,9 +10599,8 @@ declare const Definitions: readonly [Schema.Struct<{
10598
10599
  mimeType: string;
10599
10600
  })[];
10600
10601
  details?: any;
10601
- isError: true;
10602
10602
  };
10603
- status: "aborted";
10603
+ status: "running";
10604
10604
  thoughtSignature?: string;
10605
10605
  time: {
10606
10606
  start: number;
@@ -10775,19 +10775,14 @@ declare const Definitions: readonly [Schema.Struct<{
10775
10775
  type: "image";
10776
10776
  data: string;
10777
10777
  mimeType: string;
10778
- } | {
10779
- type: "thinking";
10780
- thinking: string;
10781
- thinkingSignature?: string;
10782
- redacted?: boolean;
10783
10778
  } | {
10784
10779
  addedToolNames?: string[];
10785
10780
  arguments: Record<string, any>;
10786
10781
  callID: string;
10787
10782
  name: string;
10788
10783
  namespace?: string;
10789
- partial?: {
10790
- content?: ({
10784
+ result: {
10785
+ content: ({
10791
10786
  type: "text";
10792
10787
  text: string;
10793
10788
  textSignature?: string;
@@ -10797,8 +10792,9 @@ declare const Definitions: readonly [Schema.Struct<{
10797
10792
  mimeType: string;
10798
10793
  })[];
10799
10794
  details?: any;
10795
+ isError: false;
10800
10796
  };
10801
- status: "running";
10797
+ status: "completed";
10802
10798
  thoughtSignature?: string;
10803
10799
  time: {
10804
10800
  start: number;
@@ -10822,9 +10818,9 @@ declare const Definitions: readonly [Schema.Struct<{
10822
10818
  mimeType: string;
10823
10819
  })[];
10824
10820
  details?: any;
10825
- isError: false;
10821
+ isError: true;
10826
10822
  };
10827
- status: "completed";
10823
+ status: "error";
10828
10824
  thoughtSignature?: string;
10829
10825
  time: {
10830
10826
  start: number;
@@ -10850,7 +10846,7 @@ declare const Definitions: readonly [Schema.Struct<{
10850
10846
  details?: any;
10851
10847
  isError: true;
10852
10848
  };
10853
- status: "error";
10849
+ status: "skipped";
10854
10850
  thoughtSignature?: string;
10855
10851
  time: {
10856
10852
  start: number;
@@ -10876,21 +10872,26 @@ declare const Definitions: readonly [Schema.Struct<{
10876
10872
  details?: any;
10877
10873
  isError: true;
10878
10874
  };
10879
- status: "skipped";
10875
+ status: "aborted";
10880
10876
  thoughtSignature?: string;
10881
10877
  time: {
10882
10878
  start: number;
10883
10879
  end: number;
10884
10880
  };
10885
10881
  type: "toolCall";
10882
+ } | {
10883
+ type: "thinking";
10884
+ thinking: string;
10885
+ thinkingSignature?: string;
10886
+ redacted?: boolean;
10886
10887
  } | {
10887
10888
  addedToolNames?: string[];
10888
10889
  arguments: Record<string, any>;
10889
10890
  callID: string;
10890
10891
  name: string;
10891
10892
  namespace?: string;
10892
- result: {
10893
- content: ({
10893
+ partial?: {
10894
+ content?: ({
10894
10895
  type: "text";
10895
10896
  text: string;
10896
10897
  textSignature?: string;
@@ -10900,9 +10901,8 @@ declare const Definitions: readonly [Schema.Struct<{
10900
10901
  mimeType: string;
10901
10902
  })[];
10902
10903
  details?: any;
10903
- isError: true;
10904
10904
  };
10905
- status: "aborted";
10905
+ status: "running";
10906
10906
  thoughtSignature?: string;
10907
10907
  time: {
10908
10908
  start: number;
@@ -11095,19 +11095,14 @@ declare const Definitions: readonly [Schema.Struct<{
11095
11095
  type: "image";
11096
11096
  data: string;
11097
11097
  mimeType: string;
11098
- } | {
11099
- type: "thinking";
11100
- thinking: string;
11101
- thinkingSignature?: string;
11102
- redacted?: boolean;
11103
11098
  } | {
11104
11099
  addedToolNames?: string[];
11105
11100
  arguments: Record<string, any>;
11106
11101
  callID: string;
11107
11102
  name: string;
11108
11103
  namespace?: string;
11109
- partial?: {
11110
- content?: ({
11104
+ result: {
11105
+ content: ({
11111
11106
  type: "text";
11112
11107
  text: string;
11113
11108
  textSignature?: string;
@@ -11117,8 +11112,9 @@ declare const Definitions: readonly [Schema.Struct<{
11117
11112
  mimeType: string;
11118
11113
  })[];
11119
11114
  details?: any;
11115
+ isError: false;
11120
11116
  };
11121
- status: "running";
11117
+ status: "completed";
11122
11118
  thoughtSignature?: string;
11123
11119
  time: {
11124
11120
  start: number;
@@ -11142,9 +11138,9 @@ declare const Definitions: readonly [Schema.Struct<{
11142
11138
  mimeType: string;
11143
11139
  })[];
11144
11140
  details?: any;
11145
- isError: false;
11141
+ isError: true;
11146
11142
  };
11147
- status: "completed";
11143
+ status: "error";
11148
11144
  thoughtSignature?: string;
11149
11145
  time: {
11150
11146
  start: number;
@@ -11170,7 +11166,7 @@ declare const Definitions: readonly [Schema.Struct<{
11170
11166
  details?: any;
11171
11167
  isError: true;
11172
11168
  };
11173
- status: "error";
11169
+ status: "skipped";
11174
11170
  thoughtSignature?: string;
11175
11171
  time: {
11176
11172
  start: number;
@@ -11196,21 +11192,26 @@ declare const Definitions: readonly [Schema.Struct<{
11196
11192
  details?: any;
11197
11193
  isError: true;
11198
11194
  };
11199
- status: "skipped";
11195
+ status: "aborted";
11200
11196
  thoughtSignature?: string;
11201
11197
  time: {
11202
11198
  start: number;
11203
11199
  end: number;
11204
11200
  };
11205
11201
  type: "toolCall";
11202
+ } | {
11203
+ type: "thinking";
11204
+ thinking: string;
11205
+ thinkingSignature?: string;
11206
+ redacted?: boolean;
11206
11207
  } | {
11207
11208
  addedToolNames?: string[];
11208
11209
  arguments: Record<string, any>;
11209
11210
  callID: string;
11210
11211
  name: string;
11211
11212
  namespace?: string;
11212
- result: {
11213
- content: ({
11213
+ partial?: {
11214
+ content?: ({
11214
11215
  type: "text";
11215
11216
  text: string;
11216
11217
  textSignature?: string;
@@ -11220,9 +11221,8 @@ declare const Definitions: readonly [Schema.Struct<{
11220
11221
  mimeType: string;
11221
11222
  })[];
11222
11223
  details?: any;
11223
- isError: true;
11224
11224
  };
11225
- status: "aborted";
11225
+ status: "running";
11226
11226
  thoughtSignature?: string;
11227
11227
  time: {
11228
11228
  start: number;
@@ -11397,19 +11397,14 @@ declare const Definitions: readonly [Schema.Struct<{
11397
11397
  type: "image";
11398
11398
  data: string;
11399
11399
  mimeType: string;
11400
- } | {
11401
- type: "thinking";
11402
- thinking: string;
11403
- thinkingSignature?: string;
11404
- redacted?: boolean;
11405
11400
  } | {
11406
11401
  addedToolNames?: string[];
11407
11402
  arguments: Record<string, any>;
11408
11403
  callID: string;
11409
11404
  name: string;
11410
11405
  namespace?: string;
11411
- partial?: {
11412
- content?: ({
11406
+ result: {
11407
+ content: ({
11413
11408
  type: "text";
11414
11409
  text: string;
11415
11410
  textSignature?: string;
@@ -11419,8 +11414,9 @@ declare const Definitions: readonly [Schema.Struct<{
11419
11414
  mimeType: string;
11420
11415
  })[];
11421
11416
  details?: any;
11417
+ isError: false;
11422
11418
  };
11423
- status: "running";
11419
+ status: "completed";
11424
11420
  thoughtSignature?: string;
11425
11421
  time: {
11426
11422
  start: number;
@@ -11444,9 +11440,9 @@ declare const Definitions: readonly [Schema.Struct<{
11444
11440
  mimeType: string;
11445
11441
  })[];
11446
11442
  details?: any;
11447
- isError: false;
11443
+ isError: true;
11448
11444
  };
11449
- status: "completed";
11445
+ status: "error";
11450
11446
  thoughtSignature?: string;
11451
11447
  time: {
11452
11448
  start: number;
@@ -11472,7 +11468,7 @@ declare const Definitions: readonly [Schema.Struct<{
11472
11468
  details?: any;
11473
11469
  isError: true;
11474
11470
  };
11475
- status: "error";
11471
+ status: "skipped";
11476
11472
  thoughtSignature?: string;
11477
11473
  time: {
11478
11474
  start: number;
@@ -11498,21 +11494,26 @@ declare const Definitions: readonly [Schema.Struct<{
11498
11494
  details?: any;
11499
11495
  isError: true;
11500
11496
  };
11501
- status: "skipped";
11497
+ status: "aborted";
11502
11498
  thoughtSignature?: string;
11503
11499
  time: {
11504
11500
  start: number;
11505
11501
  end: number;
11506
11502
  };
11507
11503
  type: "toolCall";
11504
+ } | {
11505
+ type: "thinking";
11506
+ thinking: string;
11507
+ thinkingSignature?: string;
11508
+ redacted?: boolean;
11508
11509
  } | {
11509
11510
  addedToolNames?: string[];
11510
11511
  arguments: Record<string, any>;
11511
11512
  callID: string;
11512
11513
  name: string;
11513
11514
  namespace?: string;
11514
- result: {
11515
- content: ({
11515
+ partial?: {
11516
+ content?: ({
11516
11517
  type: "text";
11517
11518
  text: string;
11518
11519
  textSignature?: string;
@@ -11522,9 +11523,8 @@ declare const Definitions: readonly [Schema.Struct<{
11522
11523
  mimeType: string;
11523
11524
  })[];
11524
11525
  details?: any;
11525
- isError: true;
11526
11526
  };
11527
- status: "aborted";
11527
+ status: "running";
11528
11528
  thoughtSignature?: string;
11529
11529
  time: {
11530
11530
  start: number;
@@ -12005,19 +12005,14 @@ declare const Definitions: readonly [Schema.Struct<{
12005
12005
  type: "image";
12006
12006
  data: string;
12007
12007
  mimeType: string;
12008
- } | {
12009
- type: "thinking";
12010
- thinking: string;
12011
- thinkingSignature?: string;
12012
- redacted?: boolean;
12013
12008
  } | {
12014
12009
  addedToolNames?: string[];
12015
12010
  arguments: Record<string, any>;
12016
12011
  callID: string;
12017
12012
  name: string;
12018
12013
  namespace?: string;
12019
- partial?: {
12020
- content?: ({
12014
+ result: {
12015
+ content: ({
12021
12016
  type: "text";
12022
12017
  text: string;
12023
12018
  textSignature?: string;
@@ -12027,8 +12022,9 @@ declare const Definitions: readonly [Schema.Struct<{
12027
12022
  mimeType: string;
12028
12023
  })[];
12029
12024
  details?: any;
12025
+ isError: false;
12030
12026
  };
12031
- status: "running";
12027
+ status: "completed";
12032
12028
  thoughtSignature?: string;
12033
12029
  time: {
12034
12030
  start: number;
@@ -12052,9 +12048,9 @@ declare const Definitions: readonly [Schema.Struct<{
12052
12048
  mimeType: string;
12053
12049
  })[];
12054
12050
  details?: any;
12055
- isError: false;
12051
+ isError: true;
12056
12052
  };
12057
- status: "completed";
12053
+ status: "error";
12058
12054
  thoughtSignature?: string;
12059
12055
  time: {
12060
12056
  start: number;
@@ -12080,7 +12076,7 @@ declare const Definitions: readonly [Schema.Struct<{
12080
12076
  details?: any;
12081
12077
  isError: true;
12082
12078
  };
12083
- status: "error";
12079
+ status: "skipped";
12084
12080
  thoughtSignature?: string;
12085
12081
  time: {
12086
12082
  start: number;
@@ -12106,21 +12102,26 @@ declare const Definitions: readonly [Schema.Struct<{
12106
12102
  details?: any;
12107
12103
  isError: true;
12108
12104
  };
12109
- status: "skipped";
12105
+ status: "aborted";
12110
12106
  thoughtSignature?: string;
12111
12107
  time: {
12112
12108
  start: number;
12113
12109
  end: number;
12114
12110
  };
12115
12111
  type: "toolCall";
12112
+ } | {
12113
+ type: "thinking";
12114
+ thinking: string;
12115
+ thinkingSignature?: string;
12116
+ redacted?: boolean;
12116
12117
  } | {
12117
12118
  addedToolNames?: string[];
12118
12119
  arguments: Record<string, any>;
12119
12120
  callID: string;
12120
12121
  name: string;
12121
12122
  namespace?: string;
12122
- result: {
12123
- content: ({
12123
+ partial?: {
12124
+ content?: ({
12124
12125
  type: "text";
12125
12126
  text: string;
12126
12127
  textSignature?: string;
@@ -12130,9 +12131,8 @@ declare const Definitions: readonly [Schema.Struct<{
12130
12131
  mimeType: string;
12131
12132
  })[];
12132
12133
  details?: any;
12133
- isError: true;
12134
12134
  };
12135
- status: "aborted";
12135
+ status: "running";
12136
12136
  thoughtSignature?: string;
12137
12137
  time: {
12138
12138
  start: number;
@@ -12307,19 +12307,14 @@ declare const Definitions: readonly [Schema.Struct<{
12307
12307
  type: "image";
12308
12308
  data: string;
12309
12309
  mimeType: string;
12310
- } | {
12311
- type: "thinking";
12312
- thinking: string;
12313
- thinkingSignature?: string;
12314
- redacted?: boolean;
12315
12310
  } | {
12316
12311
  addedToolNames?: string[];
12317
12312
  arguments: Record<string, any>;
12318
12313
  callID: string;
12319
12314
  name: string;
12320
12315
  namespace?: string;
12321
- partial?: {
12322
- content?: ({
12316
+ result: {
12317
+ content: ({
12323
12318
  type: "text";
12324
12319
  text: string;
12325
12320
  textSignature?: string;
@@ -12329,8 +12324,9 @@ declare const Definitions: readonly [Schema.Struct<{
12329
12324
  mimeType: string;
12330
12325
  })[];
12331
12326
  details?: any;
12327
+ isError: false;
12332
12328
  };
12333
- status: "running";
12329
+ status: "completed";
12334
12330
  thoughtSignature?: string;
12335
12331
  time: {
12336
12332
  start: number;
@@ -12354,9 +12350,9 @@ declare const Definitions: readonly [Schema.Struct<{
12354
12350
  mimeType: string;
12355
12351
  })[];
12356
12352
  details?: any;
12357
- isError: false;
12353
+ isError: true;
12358
12354
  };
12359
- status: "completed";
12355
+ status: "error";
12360
12356
  thoughtSignature?: string;
12361
12357
  time: {
12362
12358
  start: number;
@@ -12382,7 +12378,7 @@ declare const Definitions: readonly [Schema.Struct<{
12382
12378
  details?: any;
12383
12379
  isError: true;
12384
12380
  };
12385
- status: "error";
12381
+ status: "skipped";
12386
12382
  thoughtSignature?: string;
12387
12383
  time: {
12388
12384
  start: number;
@@ -12408,21 +12404,26 @@ declare const Definitions: readonly [Schema.Struct<{
12408
12404
  details?: any;
12409
12405
  isError: true;
12410
12406
  };
12411
- status: "skipped";
12407
+ status: "aborted";
12412
12408
  thoughtSignature?: string;
12413
12409
  time: {
12414
12410
  start: number;
12415
12411
  end: number;
12416
12412
  };
12417
12413
  type: "toolCall";
12414
+ } | {
12415
+ type: "thinking";
12416
+ thinking: string;
12417
+ thinkingSignature?: string;
12418
+ redacted?: boolean;
12418
12419
  } | {
12419
12420
  addedToolNames?: string[];
12420
12421
  arguments: Record<string, any>;
12421
12422
  callID: string;
12422
12423
  name: string;
12423
12424
  namespace?: string;
12424
- result: {
12425
- content: ({
12425
+ partial?: {
12426
+ content?: ({
12426
12427
  type: "text";
12427
12428
  text: string;
12428
12429
  textSignature?: string;
@@ -12432,9 +12433,8 @@ declare const Definitions: readonly [Schema.Struct<{
12432
12433
  mimeType: string;
12433
12434
  })[];
12434
12435
  details?: any;
12435
- isError: true;
12436
12436
  };
12437
- status: "aborted";
12437
+ status: "running";
12438
12438
  thoughtSignature?: string;
12439
12439
  time: {
12440
12440
  start: number;
@@ -12628,19 +12628,14 @@ declare const Definitions: readonly [Schema.Struct<{
12628
12628
  type: "image";
12629
12629
  data: string;
12630
12630
  mimeType: string;
12631
- } | {
12632
- type: "thinking";
12633
- thinking: string;
12634
- thinkingSignature?: string;
12635
- redacted?: boolean;
12636
12631
  } | {
12637
12632
  addedToolNames?: string[];
12638
12633
  arguments: Record<string, any>;
12639
12634
  callID: string;
12640
12635
  name: string;
12641
12636
  namespace?: string;
12642
- partial?: {
12643
- content?: ({
12637
+ result: {
12638
+ content: ({
12644
12639
  type: "text";
12645
12640
  text: string;
12646
12641
  textSignature?: string;
@@ -12650,8 +12645,9 @@ declare const Definitions: readonly [Schema.Struct<{
12650
12645
  mimeType: string;
12651
12646
  })[];
12652
12647
  details?: any;
12648
+ isError: false;
12653
12649
  };
12654
- status: "running";
12650
+ status: "completed";
12655
12651
  thoughtSignature?: string;
12656
12652
  time: {
12657
12653
  start: number;
@@ -12675,9 +12671,9 @@ declare const Definitions: readonly [Schema.Struct<{
12675
12671
  mimeType: string;
12676
12672
  })[];
12677
12673
  details?: any;
12678
- isError: false;
12674
+ isError: true;
12679
12675
  };
12680
- status: "completed";
12676
+ status: "error";
12681
12677
  thoughtSignature?: string;
12682
12678
  time: {
12683
12679
  start: number;
@@ -12703,7 +12699,7 @@ declare const Definitions: readonly [Schema.Struct<{
12703
12699
  details?: any;
12704
12700
  isError: true;
12705
12701
  };
12706
- status: "error";
12702
+ status: "skipped";
12707
12703
  thoughtSignature?: string;
12708
12704
  time: {
12709
12705
  start: number;
@@ -12729,21 +12725,26 @@ declare const Definitions: readonly [Schema.Struct<{
12729
12725
  details?: any;
12730
12726
  isError: true;
12731
12727
  };
12732
- status: "skipped";
12728
+ status: "aborted";
12733
12729
  thoughtSignature?: string;
12734
12730
  time: {
12735
12731
  start: number;
12736
12732
  end: number;
12737
12733
  };
12738
12734
  type: "toolCall";
12735
+ } | {
12736
+ type: "thinking";
12737
+ thinking: string;
12738
+ thinkingSignature?: string;
12739
+ redacted?: boolean;
12739
12740
  } | {
12740
12741
  addedToolNames?: string[];
12741
12742
  arguments: Record<string, any>;
12742
12743
  callID: string;
12743
12744
  name: string;
12744
12745
  namespace?: string;
12745
- result: {
12746
- content: ({
12746
+ partial?: {
12747
+ content?: ({
12747
12748
  type: "text";
12748
12749
  text: string;
12749
12750
  textSignature?: string;
@@ -12753,9 +12754,8 @@ declare const Definitions: readonly [Schema.Struct<{
12753
12754
  mimeType: string;
12754
12755
  })[];
12755
12756
  details?: any;
12756
- isError: true;
12757
12757
  };
12758
- status: "aborted";
12758
+ status: "running";
12759
12759
  thoughtSignature?: string;
12760
12760
  time: {
12761
12761
  start: number;
@@ -12930,19 +12930,14 @@ declare const Definitions: readonly [Schema.Struct<{
12930
12930
  type: "image";
12931
12931
  data: string;
12932
12932
  mimeType: string;
12933
- } | {
12934
- type: "thinking";
12935
- thinking: string;
12936
- thinkingSignature?: string;
12937
- redacted?: boolean;
12938
12933
  } | {
12939
12934
  addedToolNames?: string[];
12940
12935
  arguments: Record<string, any>;
12941
12936
  callID: string;
12942
12937
  name: string;
12943
12938
  namespace?: string;
12944
- partial?: {
12945
- content?: ({
12939
+ result: {
12940
+ content: ({
12946
12941
  type: "text";
12947
12942
  text: string;
12948
12943
  textSignature?: string;
@@ -12952,8 +12947,9 @@ declare const Definitions: readonly [Schema.Struct<{
12952
12947
  mimeType: string;
12953
12948
  })[];
12954
12949
  details?: any;
12950
+ isError: false;
12955
12951
  };
12956
- status: "running";
12952
+ status: "completed";
12957
12953
  thoughtSignature?: string;
12958
12954
  time: {
12959
12955
  start: number;
@@ -12977,9 +12973,9 @@ declare const Definitions: readonly [Schema.Struct<{
12977
12973
  mimeType: string;
12978
12974
  })[];
12979
12975
  details?: any;
12980
- isError: false;
12976
+ isError: true;
12981
12977
  };
12982
- status: "completed";
12978
+ status: "error";
12983
12979
  thoughtSignature?: string;
12984
12980
  time: {
12985
12981
  start: number;
@@ -13005,7 +13001,7 @@ declare const Definitions: readonly [Schema.Struct<{
13005
13001
  details?: any;
13006
13002
  isError: true;
13007
13003
  };
13008
- status: "error";
13004
+ status: "skipped";
13009
13005
  thoughtSignature?: string;
13010
13006
  time: {
13011
13007
  start: number;
@@ -13031,21 +13027,26 @@ declare const Definitions: readonly [Schema.Struct<{
13031
13027
  details?: any;
13032
13028
  isError: true;
13033
13029
  };
13034
- status: "skipped";
13030
+ status: "aborted";
13035
13031
  thoughtSignature?: string;
13036
13032
  time: {
13037
13033
  start: number;
13038
13034
  end: number;
13039
13035
  };
13040
13036
  type: "toolCall";
13037
+ } | {
13038
+ type: "thinking";
13039
+ thinking: string;
13040
+ thinkingSignature?: string;
13041
+ redacted?: boolean;
13041
13042
  } | {
13042
13043
  addedToolNames?: string[];
13043
13044
  arguments: Record<string, any>;
13044
13045
  callID: string;
13045
13046
  name: string;
13046
13047
  namespace?: string;
13047
- result: {
13048
- content: ({
13048
+ partial?: {
13049
+ content?: ({
13049
13050
  type: "text";
13050
13051
  text: string;
13051
13052
  textSignature?: string;
@@ -13055,9 +13056,8 @@ declare const Definitions: readonly [Schema.Struct<{
13055
13056
  mimeType: string;
13056
13057
  })[];
13057
13058
  details?: any;
13058
- isError: true;
13059
13059
  };
13060
- status: "aborted";
13060
+ status: "running";
13061
13061
  thoughtSignature?: string;
13062
13062
  time: {
13063
13063
  start: number;
@@ -13260,19 +13260,14 @@ declare const Definitions: readonly [Schema.Struct<{
13260
13260
  type: "image";
13261
13261
  data: string;
13262
13262
  mimeType: string;
13263
- } | {
13264
- type: "thinking";
13265
- thinking: string;
13266
- thinkingSignature?: string;
13267
- redacted?: boolean;
13268
13263
  } | {
13269
13264
  addedToolNames?: string[];
13270
13265
  arguments: Record<string, any>;
13271
13266
  callID: string;
13272
13267
  name: string;
13273
13268
  namespace?: string;
13274
- partial?: {
13275
- content?: ({
13269
+ result: {
13270
+ content: ({
13276
13271
  type: "text";
13277
13272
  text: string;
13278
13273
  textSignature?: string;
@@ -13282,8 +13277,9 @@ declare const Definitions: readonly [Schema.Struct<{
13282
13277
  mimeType: string;
13283
13278
  })[];
13284
13279
  details?: any;
13280
+ isError: false;
13285
13281
  };
13286
- status: "running";
13282
+ status: "completed";
13287
13283
  thoughtSignature?: string;
13288
13284
  time: {
13289
13285
  start: number;
@@ -13307,9 +13303,9 @@ declare const Definitions: readonly [Schema.Struct<{
13307
13303
  mimeType: string;
13308
13304
  })[];
13309
13305
  details?: any;
13310
- isError: false;
13306
+ isError: true;
13311
13307
  };
13312
- status: "completed";
13308
+ status: "error";
13313
13309
  thoughtSignature?: string;
13314
13310
  time: {
13315
13311
  start: number;
@@ -13335,7 +13331,7 @@ declare const Definitions: readonly [Schema.Struct<{
13335
13331
  details?: any;
13336
13332
  isError: true;
13337
13333
  };
13338
- status: "error";
13334
+ status: "skipped";
13339
13335
  thoughtSignature?: string;
13340
13336
  time: {
13341
13337
  start: number;
@@ -13361,21 +13357,26 @@ declare const Definitions: readonly [Schema.Struct<{
13361
13357
  details?: any;
13362
13358
  isError: true;
13363
13359
  };
13364
- status: "skipped";
13360
+ status: "aborted";
13365
13361
  thoughtSignature?: string;
13366
13362
  time: {
13367
13363
  start: number;
13368
13364
  end: number;
13369
13365
  };
13370
13366
  type: "toolCall";
13367
+ } | {
13368
+ type: "thinking";
13369
+ thinking: string;
13370
+ thinkingSignature?: string;
13371
+ redacted?: boolean;
13371
13372
  } | {
13372
13373
  addedToolNames?: string[];
13373
13374
  arguments: Record<string, any>;
13374
13375
  callID: string;
13375
13376
  name: string;
13376
13377
  namespace?: string;
13377
- result: {
13378
- content: ({
13378
+ partial?: {
13379
+ content?: ({
13379
13380
  type: "text";
13380
13381
  text: string;
13381
13382
  textSignature?: string;
@@ -13385,9 +13386,8 @@ declare const Definitions: readonly [Schema.Struct<{
13385
13386
  mimeType: string;
13386
13387
  })[];
13387
13388
  details?: any;
13388
- isError: true;
13389
13389
  };
13390
- status: "aborted";
13390
+ status: "running";
13391
13391
  thoughtSignature?: string;
13392
13392
  time: {
13393
13393
  start: number;
@@ -13562,19 +13562,14 @@ declare const Definitions: readonly [Schema.Struct<{
13562
13562
  type: "image";
13563
13563
  data: string;
13564
13564
  mimeType: string;
13565
- } | {
13566
- type: "thinking";
13567
- thinking: string;
13568
- thinkingSignature?: string;
13569
- redacted?: boolean;
13570
13565
  } | {
13571
13566
  addedToolNames?: string[];
13572
13567
  arguments: Record<string, any>;
13573
13568
  callID: string;
13574
13569
  name: string;
13575
13570
  namespace?: string;
13576
- partial?: {
13577
- content?: ({
13571
+ result: {
13572
+ content: ({
13578
13573
  type: "text";
13579
13574
  text: string;
13580
13575
  textSignature?: string;
@@ -13584,8 +13579,9 @@ declare const Definitions: readonly [Schema.Struct<{
13584
13579
  mimeType: string;
13585
13580
  })[];
13586
13581
  details?: any;
13582
+ isError: false;
13587
13583
  };
13588
- status: "running";
13584
+ status: "completed";
13589
13585
  thoughtSignature?: string;
13590
13586
  time: {
13591
13587
  start: number;
@@ -13609,9 +13605,9 @@ declare const Definitions: readonly [Schema.Struct<{
13609
13605
  mimeType: string;
13610
13606
  })[];
13611
13607
  details?: any;
13612
- isError: false;
13608
+ isError: true;
13613
13609
  };
13614
- status: "completed";
13610
+ status: "error";
13615
13611
  thoughtSignature?: string;
13616
13612
  time: {
13617
13613
  start: number;
@@ -13637,7 +13633,7 @@ declare const Definitions: readonly [Schema.Struct<{
13637
13633
  details?: any;
13638
13634
  isError: true;
13639
13635
  };
13640
- status: "error";
13636
+ status: "skipped";
13641
13637
  thoughtSignature?: string;
13642
13638
  time: {
13643
13639
  start: number;
@@ -13663,21 +13659,26 @@ declare const Definitions: readonly [Schema.Struct<{
13663
13659
  details?: any;
13664
13660
  isError: true;
13665
13661
  };
13666
- status: "skipped";
13662
+ status: "aborted";
13667
13663
  thoughtSignature?: string;
13668
13664
  time: {
13669
13665
  start: number;
13670
13666
  end: number;
13671
13667
  };
13672
13668
  type: "toolCall";
13669
+ } | {
13670
+ type: "thinking";
13671
+ thinking: string;
13672
+ thinkingSignature?: string;
13673
+ redacted?: boolean;
13673
13674
  } | {
13674
13675
  addedToolNames?: string[];
13675
13676
  arguments: Record<string, any>;
13676
13677
  callID: string;
13677
13678
  name: string;
13678
13679
  namespace?: string;
13679
- result: {
13680
- content: ({
13680
+ partial?: {
13681
+ content?: ({
13681
13682
  type: "text";
13682
13683
  text: string;
13683
13684
  textSignature?: string;
@@ -13687,9 +13688,8 @@ declare const Definitions: readonly [Schema.Struct<{
13687
13688
  mimeType: string;
13688
13689
  })[];
13689
13690
  details?: any;
13690
- isError: true;
13691
13691
  };
13692
- status: "aborted";
13692
+ status: "running";
13693
13693
  thoughtSignature?: string;
13694
13694
  time: {
13695
13695
  start: number;
@@ -13883,19 +13883,14 @@ declare const Definitions: readonly [Schema.Struct<{
13883
13883
  type: "image";
13884
13884
  data: string;
13885
13885
  mimeType: string;
13886
- } | {
13887
- type: "thinking";
13888
- thinking: string;
13889
- thinkingSignature?: string;
13890
- redacted?: boolean;
13891
13886
  } | {
13892
13887
  addedToolNames?: string[];
13893
13888
  arguments: Record<string, any>;
13894
13889
  callID: string;
13895
13890
  name: string;
13896
13891
  namespace?: string;
13897
- partial?: {
13898
- content?: ({
13892
+ result: {
13893
+ content: ({
13899
13894
  type: "text";
13900
13895
  text: string;
13901
13896
  textSignature?: string;
@@ -13905,8 +13900,9 @@ declare const Definitions: readonly [Schema.Struct<{
13905
13900
  mimeType: string;
13906
13901
  })[];
13907
13902
  details?: any;
13903
+ isError: false;
13908
13904
  };
13909
- status: "running";
13905
+ status: "completed";
13910
13906
  thoughtSignature?: string;
13911
13907
  time: {
13912
13908
  start: number;
@@ -13930,9 +13926,9 @@ declare const Definitions: readonly [Schema.Struct<{
13930
13926
  mimeType: string;
13931
13927
  })[];
13932
13928
  details?: any;
13933
- isError: false;
13929
+ isError: true;
13934
13930
  };
13935
- status: "completed";
13931
+ status: "error";
13936
13932
  thoughtSignature?: string;
13937
13933
  time: {
13938
13934
  start: number;
@@ -13958,7 +13954,7 @@ declare const Definitions: readonly [Schema.Struct<{
13958
13954
  details?: any;
13959
13955
  isError: true;
13960
13956
  };
13961
- status: "error";
13957
+ status: "skipped";
13962
13958
  thoughtSignature?: string;
13963
13959
  time: {
13964
13960
  start: number;
@@ -13984,21 +13980,26 @@ declare const Definitions: readonly [Schema.Struct<{
13984
13980
  details?: any;
13985
13981
  isError: true;
13986
13982
  };
13987
- status: "skipped";
13983
+ status: "aborted";
13988
13984
  thoughtSignature?: string;
13989
13985
  time: {
13990
13986
  start: number;
13991
13987
  end: number;
13992
13988
  };
13993
13989
  type: "toolCall";
13990
+ } | {
13991
+ type: "thinking";
13992
+ thinking: string;
13993
+ thinkingSignature?: string;
13994
+ redacted?: boolean;
13994
13995
  } | {
13995
13996
  addedToolNames?: string[];
13996
13997
  arguments: Record<string, any>;
13997
13998
  callID: string;
13998
13999
  name: string;
13999
14000
  namespace?: string;
14000
- result: {
14001
- content: ({
14001
+ partial?: {
14002
+ content?: ({
14002
14003
  type: "text";
14003
14004
  text: string;
14004
14005
  textSignature?: string;
@@ -14008,9 +14009,8 @@ declare const Definitions: readonly [Schema.Struct<{
14008
14009
  mimeType: string;
14009
14010
  })[];
14010
14011
  details?: any;
14011
- isError: true;
14012
14012
  };
14013
- status: "aborted";
14013
+ status: "running";
14014
14014
  thoughtSignature?: string;
14015
14015
  time: {
14016
14016
  start: number;
@@ -14185,19 +14185,14 @@ declare const Definitions: readonly [Schema.Struct<{
14185
14185
  type: "image";
14186
14186
  data: string;
14187
14187
  mimeType: string;
14188
- } | {
14189
- type: "thinking";
14190
- thinking: string;
14191
- thinkingSignature?: string;
14192
- redacted?: boolean;
14193
14188
  } | {
14194
14189
  addedToolNames?: string[];
14195
14190
  arguments: Record<string, any>;
14196
14191
  callID: string;
14197
14192
  name: string;
14198
14193
  namespace?: string;
14199
- partial?: {
14200
- content?: ({
14194
+ result: {
14195
+ content: ({
14201
14196
  type: "text";
14202
14197
  text: string;
14203
14198
  textSignature?: string;
@@ -14207,8 +14202,9 @@ declare const Definitions: readonly [Schema.Struct<{
14207
14202
  mimeType: string;
14208
14203
  })[];
14209
14204
  details?: any;
14205
+ isError: false;
14210
14206
  };
14211
- status: "running";
14207
+ status: "completed";
14212
14208
  thoughtSignature?: string;
14213
14209
  time: {
14214
14210
  start: number;
@@ -14232,9 +14228,9 @@ declare const Definitions: readonly [Schema.Struct<{
14232
14228
  mimeType: string;
14233
14229
  })[];
14234
14230
  details?: any;
14235
- isError: false;
14231
+ isError: true;
14236
14232
  };
14237
- status: "completed";
14233
+ status: "error";
14238
14234
  thoughtSignature?: string;
14239
14235
  time: {
14240
14236
  start: number;
@@ -14260,7 +14256,7 @@ declare const Definitions: readonly [Schema.Struct<{
14260
14256
  details?: any;
14261
14257
  isError: true;
14262
14258
  };
14263
- status: "error";
14259
+ status: "skipped";
14264
14260
  thoughtSignature?: string;
14265
14261
  time: {
14266
14262
  start: number;
@@ -14286,21 +14282,26 @@ declare const Definitions: readonly [Schema.Struct<{
14286
14282
  details?: any;
14287
14283
  isError: true;
14288
14284
  };
14289
- status: "skipped";
14285
+ status: "aborted";
14290
14286
  thoughtSignature?: string;
14291
14287
  time: {
14292
14288
  start: number;
14293
14289
  end: number;
14294
14290
  };
14295
14291
  type: "toolCall";
14292
+ } | {
14293
+ type: "thinking";
14294
+ thinking: string;
14295
+ thinkingSignature?: string;
14296
+ redacted?: boolean;
14296
14297
  } | {
14297
14298
  addedToolNames?: string[];
14298
14299
  arguments: Record<string, any>;
14299
14300
  callID: string;
14300
14301
  name: string;
14301
14302
  namespace?: string;
14302
- result: {
14303
- content: ({
14303
+ partial?: {
14304
+ content?: ({
14304
14305
  type: "text";
14305
14306
  text: string;
14306
14307
  textSignature?: string;
@@ -14310,9 +14311,8 @@ declare const Definitions: readonly [Schema.Struct<{
14310
14311
  mimeType: string;
14311
14312
  })[];
14312
14313
  details?: any;
14313
- isError: true;
14314
14314
  };
14315
- status: "aborted";
14315
+ status: "running";
14316
14316
  thoughtSignature?: string;
14317
14317
  time: {
14318
14318
  start: number;
@@ -15821,19 +15821,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15821
15821
  type: "image";
15822
15822
  data: string;
15823
15823
  mimeType: string;
15824
- } | {
15825
- type: "thinking";
15826
- thinking: string;
15827
- thinkingSignature?: string;
15828
- redacted?: boolean;
15829
15824
  } | {
15830
15825
  addedToolNames?: string[];
15831
15826
  arguments: Record<string, any>;
15832
15827
  callID: string;
15833
15828
  name: string;
15834
15829
  namespace?: string;
15835
- partial?: {
15836
- content?: ({
15830
+ result: {
15831
+ content: ({
15837
15832
  type: "text";
15838
15833
  text: string;
15839
15834
  textSignature?: string;
@@ -15843,8 +15838,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15843
15838
  mimeType: string;
15844
15839
  })[];
15845
15840
  details?: any;
15841
+ isError: false;
15846
15842
  };
15847
- status: "running";
15843
+ status: "completed";
15848
15844
  thoughtSignature?: string;
15849
15845
  time: {
15850
15846
  start: number;
@@ -15868,9 +15864,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15868
15864
  mimeType: string;
15869
15865
  })[];
15870
15866
  details?: any;
15871
- isError: false;
15867
+ isError: true;
15872
15868
  };
15873
- status: "completed";
15869
+ status: "error";
15874
15870
  thoughtSignature?: string;
15875
15871
  time: {
15876
15872
  start: number;
@@ -15896,7 +15892,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15896
15892
  details?: any;
15897
15893
  isError: true;
15898
15894
  };
15899
- status: "error";
15895
+ status: "skipped";
15900
15896
  thoughtSignature?: string;
15901
15897
  time: {
15902
15898
  start: number;
@@ -15922,21 +15918,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15922
15918
  details?: any;
15923
15919
  isError: true;
15924
15920
  };
15925
- status: "skipped";
15921
+ status: "aborted";
15926
15922
  thoughtSignature?: string;
15927
15923
  time: {
15928
15924
  start: number;
15929
15925
  end: number;
15930
15926
  };
15931
15927
  type: "toolCall";
15928
+ } | {
15929
+ type: "thinking";
15930
+ thinking: string;
15931
+ thinkingSignature?: string;
15932
+ redacted?: boolean;
15932
15933
  } | {
15933
15934
  addedToolNames?: string[];
15934
15935
  arguments: Record<string, any>;
15935
15936
  callID: string;
15936
15937
  name: string;
15937
15938
  namespace?: string;
15938
- result: {
15939
- content: ({
15939
+ partial?: {
15940
+ content?: ({
15940
15941
  type: "text";
15941
15942
  text: string;
15942
15943
  textSignature?: string;
@@ -15946,9 +15947,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15946
15947
  mimeType: string;
15947
15948
  })[];
15948
15949
  details?: any;
15949
- isError: true;
15950
15950
  };
15951
- status: "aborted";
15951
+ status: "running";
15952
15952
  thoughtSignature?: string;
15953
15953
  time: {
15954
15954
  start: number;
@@ -16123,19 +16123,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16123
16123
  type: "image";
16124
16124
  data: string;
16125
16125
  mimeType: string;
16126
- } | {
16127
- type: "thinking";
16128
- thinking: string;
16129
- thinkingSignature?: string;
16130
- redacted?: boolean;
16131
16126
  } | {
16132
16127
  addedToolNames?: string[];
16133
16128
  arguments: Record<string, any>;
16134
16129
  callID: string;
16135
16130
  name: string;
16136
16131
  namespace?: string;
16137
- partial?: {
16138
- content?: ({
16132
+ result: {
16133
+ content: ({
16139
16134
  type: "text";
16140
16135
  text: string;
16141
16136
  textSignature?: string;
@@ -16145,8 +16140,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16145
16140
  mimeType: string;
16146
16141
  })[];
16147
16142
  details?: any;
16143
+ isError: false;
16148
16144
  };
16149
- status: "running";
16145
+ status: "completed";
16150
16146
  thoughtSignature?: string;
16151
16147
  time: {
16152
16148
  start: number;
@@ -16170,9 +16166,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16170
16166
  mimeType: string;
16171
16167
  })[];
16172
16168
  details?: any;
16173
- isError: false;
16169
+ isError: true;
16174
16170
  };
16175
- status: "completed";
16171
+ status: "error";
16176
16172
  thoughtSignature?: string;
16177
16173
  time: {
16178
16174
  start: number;
@@ -16198,7 +16194,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16198
16194
  details?: any;
16199
16195
  isError: true;
16200
16196
  };
16201
- status: "error";
16197
+ status: "skipped";
16202
16198
  thoughtSignature?: string;
16203
16199
  time: {
16204
16200
  start: number;
@@ -16224,21 +16220,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16224
16220
  details?: any;
16225
16221
  isError: true;
16226
16222
  };
16227
- status: "skipped";
16223
+ status: "aborted";
16228
16224
  thoughtSignature?: string;
16229
16225
  time: {
16230
16226
  start: number;
16231
16227
  end: number;
16232
16228
  };
16233
16229
  type: "toolCall";
16230
+ } | {
16231
+ type: "thinking";
16232
+ thinking: string;
16233
+ thinkingSignature?: string;
16234
+ redacted?: boolean;
16234
16235
  } | {
16235
16236
  addedToolNames?: string[];
16236
16237
  arguments: Record<string, any>;
16237
16238
  callID: string;
16238
16239
  name: string;
16239
16240
  namespace?: string;
16240
- result: {
16241
- content: ({
16241
+ partial?: {
16242
+ content?: ({
16242
16243
  type: "text";
16243
16244
  text: string;
16244
16245
  textSignature?: string;
@@ -16248,9 +16249,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16248
16249
  mimeType: string;
16249
16250
  })[];
16250
16251
  details?: any;
16251
- isError: true;
16252
16252
  };
16253
- status: "aborted";
16253
+ status: "running";
16254
16254
  thoughtSignature?: string;
16255
16255
  time: {
16256
16256
  start: number;
@@ -16443,19 +16443,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16443
16443
  type: "image";
16444
16444
  data: string;
16445
16445
  mimeType: string;
16446
- } | {
16447
- type: "thinking";
16448
- thinking: string;
16449
- thinkingSignature?: string;
16450
- redacted?: boolean;
16451
16446
  } | {
16452
16447
  addedToolNames?: string[];
16453
16448
  arguments: Record<string, any>;
16454
16449
  callID: string;
16455
16450
  name: string;
16456
16451
  namespace?: string;
16457
- partial?: {
16458
- content?: ({
16452
+ result: {
16453
+ content: ({
16459
16454
  type: "text";
16460
16455
  text: string;
16461
16456
  textSignature?: string;
@@ -16465,8 +16460,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16465
16460
  mimeType: string;
16466
16461
  })[];
16467
16462
  details?: any;
16463
+ isError: false;
16468
16464
  };
16469
- status: "running";
16465
+ status: "completed";
16470
16466
  thoughtSignature?: string;
16471
16467
  time: {
16472
16468
  start: number;
@@ -16490,9 +16486,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16490
16486
  mimeType: string;
16491
16487
  })[];
16492
16488
  details?: any;
16493
- isError: false;
16489
+ isError: true;
16494
16490
  };
16495
- status: "completed";
16491
+ status: "error";
16496
16492
  thoughtSignature?: string;
16497
16493
  time: {
16498
16494
  start: number;
@@ -16518,7 +16514,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16518
16514
  details?: any;
16519
16515
  isError: true;
16520
16516
  };
16521
- status: "error";
16517
+ status: "skipped";
16522
16518
  thoughtSignature?: string;
16523
16519
  time: {
16524
16520
  start: number;
@@ -16544,21 +16540,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16544
16540
  details?: any;
16545
16541
  isError: true;
16546
16542
  };
16547
- status: "skipped";
16543
+ status: "aborted";
16548
16544
  thoughtSignature?: string;
16549
16545
  time: {
16550
16546
  start: number;
16551
16547
  end: number;
16552
16548
  };
16553
16549
  type: "toolCall";
16550
+ } | {
16551
+ type: "thinking";
16552
+ thinking: string;
16553
+ thinkingSignature?: string;
16554
+ redacted?: boolean;
16554
16555
  } | {
16555
16556
  addedToolNames?: string[];
16556
16557
  arguments: Record<string, any>;
16557
16558
  callID: string;
16558
16559
  name: string;
16559
16560
  namespace?: string;
16560
- result: {
16561
- content: ({
16561
+ partial?: {
16562
+ content?: ({
16562
16563
  type: "text";
16563
16564
  text: string;
16564
16565
  textSignature?: string;
@@ -16568,9 +16569,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16568
16569
  mimeType: string;
16569
16570
  })[];
16570
16571
  details?: any;
16571
- isError: true;
16572
16572
  };
16573
- status: "aborted";
16573
+ status: "running";
16574
16574
  thoughtSignature?: string;
16575
16575
  time: {
16576
16576
  start: number;
@@ -16745,19 +16745,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16745
16745
  type: "image";
16746
16746
  data: string;
16747
16747
  mimeType: string;
16748
- } | {
16749
- type: "thinking";
16750
- thinking: string;
16751
- thinkingSignature?: string;
16752
- redacted?: boolean;
16753
16748
  } | {
16754
16749
  addedToolNames?: string[];
16755
16750
  arguments: Record<string, any>;
16756
16751
  callID: string;
16757
16752
  name: string;
16758
16753
  namespace?: string;
16759
- partial?: {
16760
- content?: ({
16754
+ result: {
16755
+ content: ({
16761
16756
  type: "text";
16762
16757
  text: string;
16763
16758
  textSignature?: string;
@@ -16767,8 +16762,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16767
16762
  mimeType: string;
16768
16763
  })[];
16769
16764
  details?: any;
16765
+ isError: false;
16770
16766
  };
16771
- status: "running";
16767
+ status: "completed";
16772
16768
  thoughtSignature?: string;
16773
16769
  time: {
16774
16770
  start: number;
@@ -16792,9 +16788,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16792
16788
  mimeType: string;
16793
16789
  })[];
16794
16790
  details?: any;
16795
- isError: false;
16791
+ isError: true;
16796
16792
  };
16797
- status: "completed";
16793
+ status: "error";
16798
16794
  thoughtSignature?: string;
16799
16795
  time: {
16800
16796
  start: number;
@@ -16820,7 +16816,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16820
16816
  details?: any;
16821
16817
  isError: true;
16822
16818
  };
16823
- status: "error";
16819
+ status: "skipped";
16824
16820
  thoughtSignature?: string;
16825
16821
  time: {
16826
16822
  start: number;
@@ -16846,21 +16842,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16846
16842
  details?: any;
16847
16843
  isError: true;
16848
16844
  };
16849
- status: "skipped";
16845
+ status: "aborted";
16850
16846
  thoughtSignature?: string;
16851
16847
  time: {
16852
16848
  start: number;
16853
16849
  end: number;
16854
16850
  };
16855
16851
  type: "toolCall";
16852
+ } | {
16853
+ type: "thinking";
16854
+ thinking: string;
16855
+ thinkingSignature?: string;
16856
+ redacted?: boolean;
16856
16857
  } | {
16857
16858
  addedToolNames?: string[];
16858
16859
  arguments: Record<string, any>;
16859
16860
  callID: string;
16860
16861
  name: string;
16861
16862
  namespace?: string;
16862
- result: {
16863
- content: ({
16863
+ partial?: {
16864
+ content?: ({
16864
16865
  type: "text";
16865
16866
  text: string;
16866
16867
  textSignature?: string;
@@ -16870,9 +16871,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16870
16871
  mimeType: string;
16871
16872
  })[];
16872
16873
  details?: any;
16873
- isError: true;
16874
16874
  };
16875
- status: "aborted";
16875
+ status: "running";
16876
16876
  thoughtSignature?: string;
16877
16877
  time: {
16878
16878
  start: number;
@@ -17353,19 +17353,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17353
17353
  type: "image";
17354
17354
  data: string;
17355
17355
  mimeType: string;
17356
- } | {
17357
- type: "thinking";
17358
- thinking: string;
17359
- thinkingSignature?: string;
17360
- redacted?: boolean;
17361
17356
  } | {
17362
17357
  addedToolNames?: string[];
17363
17358
  arguments: Record<string, any>;
17364
17359
  callID: string;
17365
17360
  name: string;
17366
17361
  namespace?: string;
17367
- partial?: {
17368
- content?: ({
17362
+ result: {
17363
+ content: ({
17369
17364
  type: "text";
17370
17365
  text: string;
17371
17366
  textSignature?: string;
@@ -17375,8 +17370,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17375
17370
  mimeType: string;
17376
17371
  })[];
17377
17372
  details?: any;
17373
+ isError: false;
17378
17374
  };
17379
- status: "running";
17375
+ status: "completed";
17380
17376
  thoughtSignature?: string;
17381
17377
  time: {
17382
17378
  start: number;
@@ -17400,9 +17396,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17400
17396
  mimeType: string;
17401
17397
  })[];
17402
17398
  details?: any;
17403
- isError: false;
17399
+ isError: true;
17404
17400
  };
17405
- status: "completed";
17401
+ status: "error";
17406
17402
  thoughtSignature?: string;
17407
17403
  time: {
17408
17404
  start: number;
@@ -17428,7 +17424,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17428
17424
  details?: any;
17429
17425
  isError: true;
17430
17426
  };
17431
- status: "error";
17427
+ status: "skipped";
17432
17428
  thoughtSignature?: string;
17433
17429
  time: {
17434
17430
  start: number;
@@ -17454,21 +17450,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17454
17450
  details?: any;
17455
17451
  isError: true;
17456
17452
  };
17457
- status: "skipped";
17453
+ status: "aborted";
17458
17454
  thoughtSignature?: string;
17459
17455
  time: {
17460
17456
  start: number;
17461
17457
  end: number;
17462
17458
  };
17463
17459
  type: "toolCall";
17460
+ } | {
17461
+ type: "thinking";
17462
+ thinking: string;
17463
+ thinkingSignature?: string;
17464
+ redacted?: boolean;
17464
17465
  } | {
17465
17466
  addedToolNames?: string[];
17466
17467
  arguments: Record<string, any>;
17467
17468
  callID: string;
17468
17469
  name: string;
17469
17470
  namespace?: string;
17470
- result: {
17471
- content: ({
17471
+ partial?: {
17472
+ content?: ({
17472
17473
  type: "text";
17473
17474
  text: string;
17474
17475
  textSignature?: string;
@@ -17478,9 +17479,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17478
17479
  mimeType: string;
17479
17480
  })[];
17480
17481
  details?: any;
17481
- isError: true;
17482
17482
  };
17483
- status: "aborted";
17483
+ status: "running";
17484
17484
  thoughtSignature?: string;
17485
17485
  time: {
17486
17486
  start: number;
@@ -17655,19 +17655,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17655
17655
  type: "image";
17656
17656
  data: string;
17657
17657
  mimeType: string;
17658
- } | {
17659
- type: "thinking";
17660
- thinking: string;
17661
- thinkingSignature?: string;
17662
- redacted?: boolean;
17663
17658
  } | {
17664
17659
  addedToolNames?: string[];
17665
17660
  arguments: Record<string, any>;
17666
17661
  callID: string;
17667
17662
  name: string;
17668
17663
  namespace?: string;
17669
- partial?: {
17670
- content?: ({
17664
+ result: {
17665
+ content: ({
17671
17666
  type: "text";
17672
17667
  text: string;
17673
17668
  textSignature?: string;
@@ -17677,8 +17672,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17677
17672
  mimeType: string;
17678
17673
  })[];
17679
17674
  details?: any;
17675
+ isError: false;
17680
17676
  };
17681
- status: "running";
17677
+ status: "completed";
17682
17678
  thoughtSignature?: string;
17683
17679
  time: {
17684
17680
  start: number;
@@ -17702,9 +17698,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17702
17698
  mimeType: string;
17703
17699
  })[];
17704
17700
  details?: any;
17705
- isError: false;
17701
+ isError: true;
17706
17702
  };
17707
- status: "completed";
17703
+ status: "error";
17708
17704
  thoughtSignature?: string;
17709
17705
  time: {
17710
17706
  start: number;
@@ -17730,7 +17726,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17730
17726
  details?: any;
17731
17727
  isError: true;
17732
17728
  };
17733
- status: "error";
17729
+ status: "skipped";
17734
17730
  thoughtSignature?: string;
17735
17731
  time: {
17736
17732
  start: number;
@@ -17756,21 +17752,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17756
17752
  details?: any;
17757
17753
  isError: true;
17758
17754
  };
17759
- status: "skipped";
17755
+ status: "aborted";
17760
17756
  thoughtSignature?: string;
17761
17757
  time: {
17762
17758
  start: number;
17763
17759
  end: number;
17764
17760
  };
17765
17761
  type: "toolCall";
17762
+ } | {
17763
+ type: "thinking";
17764
+ thinking: string;
17765
+ thinkingSignature?: string;
17766
+ redacted?: boolean;
17766
17767
  } | {
17767
17768
  addedToolNames?: string[];
17768
17769
  arguments: Record<string, any>;
17769
17770
  callID: string;
17770
17771
  name: string;
17771
17772
  namespace?: string;
17772
- result: {
17773
- content: ({
17773
+ partial?: {
17774
+ content?: ({
17774
17775
  type: "text";
17775
17776
  text: string;
17776
17777
  textSignature?: string;
@@ -17780,9 +17781,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17780
17781
  mimeType: string;
17781
17782
  })[];
17782
17783
  details?: any;
17783
- isError: true;
17784
17784
  };
17785
- status: "aborted";
17785
+ status: "running";
17786
17786
  thoughtSignature?: string;
17787
17787
  time: {
17788
17788
  start: number;
@@ -17976,19 +17976,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17976
17976
  type: "image";
17977
17977
  data: string;
17978
17978
  mimeType: string;
17979
- } | {
17980
- type: "thinking";
17981
- thinking: string;
17982
- thinkingSignature?: string;
17983
- redacted?: boolean;
17984
17979
  } | {
17985
17980
  addedToolNames?: string[];
17986
17981
  arguments: Record<string, any>;
17987
17982
  callID: string;
17988
17983
  name: string;
17989
17984
  namespace?: string;
17990
- partial?: {
17991
- content?: ({
17985
+ result: {
17986
+ content: ({
17992
17987
  type: "text";
17993
17988
  text: string;
17994
17989
  textSignature?: string;
@@ -17998,8 +17993,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17998
17993
  mimeType: string;
17999
17994
  })[];
18000
17995
  details?: any;
17996
+ isError: false;
18001
17997
  };
18002
- status: "running";
17998
+ status: "completed";
18003
17999
  thoughtSignature?: string;
18004
18000
  time: {
18005
18001
  start: number;
@@ -18023,9 +18019,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18023
18019
  mimeType: string;
18024
18020
  })[];
18025
18021
  details?: any;
18026
- isError: false;
18022
+ isError: true;
18027
18023
  };
18028
- status: "completed";
18024
+ status: "error";
18029
18025
  thoughtSignature?: string;
18030
18026
  time: {
18031
18027
  start: number;
@@ -18051,7 +18047,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18051
18047
  details?: any;
18052
18048
  isError: true;
18053
18049
  };
18054
- status: "error";
18050
+ status: "skipped";
18055
18051
  thoughtSignature?: string;
18056
18052
  time: {
18057
18053
  start: number;
@@ -18077,21 +18073,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18077
18073
  details?: any;
18078
18074
  isError: true;
18079
18075
  };
18080
- status: "skipped";
18076
+ status: "aborted";
18081
18077
  thoughtSignature?: string;
18082
18078
  time: {
18083
18079
  start: number;
18084
18080
  end: number;
18085
18081
  };
18086
18082
  type: "toolCall";
18083
+ } | {
18084
+ type: "thinking";
18085
+ thinking: string;
18086
+ thinkingSignature?: string;
18087
+ redacted?: boolean;
18087
18088
  } | {
18088
18089
  addedToolNames?: string[];
18089
18090
  arguments: Record<string, any>;
18090
18091
  callID: string;
18091
18092
  name: string;
18092
18093
  namespace?: string;
18093
- result: {
18094
- content: ({
18094
+ partial?: {
18095
+ content?: ({
18095
18096
  type: "text";
18096
18097
  text: string;
18097
18098
  textSignature?: string;
@@ -18101,9 +18102,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18101
18102
  mimeType: string;
18102
18103
  })[];
18103
18104
  details?: any;
18104
- isError: true;
18105
18105
  };
18106
- status: "aborted";
18106
+ status: "running";
18107
18107
  thoughtSignature?: string;
18108
18108
  time: {
18109
18109
  start: number;
@@ -18278,19 +18278,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18278
18278
  type: "image";
18279
18279
  data: string;
18280
18280
  mimeType: string;
18281
- } | {
18282
- type: "thinking";
18283
- thinking: string;
18284
- thinkingSignature?: string;
18285
- redacted?: boolean;
18286
18281
  } | {
18287
18282
  addedToolNames?: string[];
18288
18283
  arguments: Record<string, any>;
18289
18284
  callID: string;
18290
18285
  name: string;
18291
18286
  namespace?: string;
18292
- partial?: {
18293
- content?: ({
18287
+ result: {
18288
+ content: ({
18294
18289
  type: "text";
18295
18290
  text: string;
18296
18291
  textSignature?: string;
@@ -18300,8 +18295,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18300
18295
  mimeType: string;
18301
18296
  })[];
18302
18297
  details?: any;
18298
+ isError: false;
18303
18299
  };
18304
- status: "running";
18300
+ status: "completed";
18305
18301
  thoughtSignature?: string;
18306
18302
  time: {
18307
18303
  start: number;
@@ -18325,9 +18321,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18325
18321
  mimeType: string;
18326
18322
  })[];
18327
18323
  details?: any;
18328
- isError: false;
18324
+ isError: true;
18329
18325
  };
18330
- status: "completed";
18326
+ status: "error";
18331
18327
  thoughtSignature?: string;
18332
18328
  time: {
18333
18329
  start: number;
@@ -18353,7 +18349,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18353
18349
  details?: any;
18354
18350
  isError: true;
18355
18351
  };
18356
- status: "error";
18352
+ status: "skipped";
18357
18353
  thoughtSignature?: string;
18358
18354
  time: {
18359
18355
  start: number;
@@ -18379,21 +18375,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18379
18375
  details?: any;
18380
18376
  isError: true;
18381
18377
  };
18382
- status: "skipped";
18378
+ status: "aborted";
18383
18379
  thoughtSignature?: string;
18384
18380
  time: {
18385
18381
  start: number;
18386
18382
  end: number;
18387
18383
  };
18388
18384
  type: "toolCall";
18385
+ } | {
18386
+ type: "thinking";
18387
+ thinking: string;
18388
+ thinkingSignature?: string;
18389
+ redacted?: boolean;
18389
18390
  } | {
18390
18391
  addedToolNames?: string[];
18391
18392
  arguments: Record<string, any>;
18392
18393
  callID: string;
18393
18394
  name: string;
18394
18395
  namespace?: string;
18395
- result: {
18396
- content: ({
18396
+ partial?: {
18397
+ content?: ({
18397
18398
  type: "text";
18398
18399
  text: string;
18399
18400
  textSignature?: string;
@@ -18403,9 +18404,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18403
18404
  mimeType: string;
18404
18405
  })[];
18405
18406
  details?: any;
18406
- isError: true;
18407
18407
  };
18408
- status: "aborted";
18408
+ status: "running";
18409
18409
  thoughtSignature?: string;
18410
18410
  time: {
18411
18411
  start: number;
@@ -18608,19 +18608,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18608
18608
  type: "image";
18609
18609
  data: string;
18610
18610
  mimeType: string;
18611
- } | {
18612
- type: "thinking";
18613
- thinking: string;
18614
- thinkingSignature?: string;
18615
- redacted?: boolean;
18616
18611
  } | {
18617
18612
  addedToolNames?: string[];
18618
18613
  arguments: Record<string, any>;
18619
18614
  callID: string;
18620
18615
  name: string;
18621
18616
  namespace?: string;
18622
- partial?: {
18623
- content?: ({
18617
+ result: {
18618
+ content: ({
18624
18619
  type: "text";
18625
18620
  text: string;
18626
18621
  textSignature?: string;
@@ -18630,8 +18625,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18630
18625
  mimeType: string;
18631
18626
  })[];
18632
18627
  details?: any;
18628
+ isError: false;
18633
18629
  };
18634
- status: "running";
18630
+ status: "completed";
18635
18631
  thoughtSignature?: string;
18636
18632
  time: {
18637
18633
  start: number;
@@ -18655,9 +18651,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18655
18651
  mimeType: string;
18656
18652
  })[];
18657
18653
  details?: any;
18658
- isError: false;
18654
+ isError: true;
18659
18655
  };
18660
- status: "completed";
18656
+ status: "error";
18661
18657
  thoughtSignature?: string;
18662
18658
  time: {
18663
18659
  start: number;
@@ -18683,7 +18679,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18683
18679
  details?: any;
18684
18680
  isError: true;
18685
18681
  };
18686
- status: "error";
18682
+ status: "skipped";
18687
18683
  thoughtSignature?: string;
18688
18684
  time: {
18689
18685
  start: number;
@@ -18709,21 +18705,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18709
18705
  details?: any;
18710
18706
  isError: true;
18711
18707
  };
18712
- status: "skipped";
18708
+ status: "aborted";
18713
18709
  thoughtSignature?: string;
18714
18710
  time: {
18715
18711
  start: number;
18716
18712
  end: number;
18717
18713
  };
18718
18714
  type: "toolCall";
18715
+ } | {
18716
+ type: "thinking";
18717
+ thinking: string;
18718
+ thinkingSignature?: string;
18719
+ redacted?: boolean;
18719
18720
  } | {
18720
18721
  addedToolNames?: string[];
18721
18722
  arguments: Record<string, any>;
18722
18723
  callID: string;
18723
18724
  name: string;
18724
18725
  namespace?: string;
18725
- result: {
18726
- content: ({
18726
+ partial?: {
18727
+ content?: ({
18727
18728
  type: "text";
18728
18729
  text: string;
18729
18730
  textSignature?: string;
@@ -18733,9 +18734,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18733
18734
  mimeType: string;
18734
18735
  })[];
18735
18736
  details?: any;
18736
- isError: true;
18737
18737
  };
18738
- status: "aborted";
18738
+ status: "running";
18739
18739
  thoughtSignature?: string;
18740
18740
  time: {
18741
18741
  start: number;
@@ -18910,19 +18910,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18910
18910
  type: "image";
18911
18911
  data: string;
18912
18912
  mimeType: string;
18913
- } | {
18914
- type: "thinking";
18915
- thinking: string;
18916
- thinkingSignature?: string;
18917
- redacted?: boolean;
18918
18913
  } | {
18919
18914
  addedToolNames?: string[];
18920
18915
  arguments: Record<string, any>;
18921
18916
  callID: string;
18922
18917
  name: string;
18923
18918
  namespace?: string;
18924
- partial?: {
18925
- content?: ({
18919
+ result: {
18920
+ content: ({
18926
18921
  type: "text";
18927
18922
  text: string;
18928
18923
  textSignature?: string;
@@ -18932,8 +18927,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18932
18927
  mimeType: string;
18933
18928
  })[];
18934
18929
  details?: any;
18930
+ isError: false;
18935
18931
  };
18936
- status: "running";
18932
+ status: "completed";
18937
18933
  thoughtSignature?: string;
18938
18934
  time: {
18939
18935
  start: number;
@@ -18957,9 +18953,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18957
18953
  mimeType: string;
18958
18954
  })[];
18959
18955
  details?: any;
18960
- isError: false;
18956
+ isError: true;
18961
18957
  };
18962
- status: "completed";
18958
+ status: "error";
18963
18959
  thoughtSignature?: string;
18964
18960
  time: {
18965
18961
  start: number;
@@ -18985,7 +18981,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18985
18981
  details?: any;
18986
18982
  isError: true;
18987
18983
  };
18988
- status: "error";
18984
+ status: "skipped";
18989
18985
  thoughtSignature?: string;
18990
18986
  time: {
18991
18987
  start: number;
@@ -19011,21 +19007,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19011
19007
  details?: any;
19012
19008
  isError: true;
19013
19009
  };
19014
- status: "skipped";
19010
+ status: "aborted";
19015
19011
  thoughtSignature?: string;
19016
19012
  time: {
19017
19013
  start: number;
19018
19014
  end: number;
19019
19015
  };
19020
19016
  type: "toolCall";
19017
+ } | {
19018
+ type: "thinking";
19019
+ thinking: string;
19020
+ thinkingSignature?: string;
19021
+ redacted?: boolean;
19021
19022
  } | {
19022
19023
  addedToolNames?: string[];
19023
19024
  arguments: Record<string, any>;
19024
19025
  callID: string;
19025
19026
  name: string;
19026
19027
  namespace?: string;
19027
- result: {
19028
- content: ({
19028
+ partial?: {
19029
+ content?: ({
19029
19030
  type: "text";
19030
19031
  text: string;
19031
19032
  textSignature?: string;
@@ -19035,9 +19036,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19035
19036
  mimeType: string;
19036
19037
  })[];
19037
19038
  details?: any;
19038
- isError: true;
19039
19039
  };
19040
- status: "aborted";
19040
+ status: "running";
19041
19041
  thoughtSignature?: string;
19042
19042
  time: {
19043
19043
  start: number;
@@ -19231,19 +19231,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19231
19231
  type: "image";
19232
19232
  data: string;
19233
19233
  mimeType: string;
19234
- } | {
19235
- type: "thinking";
19236
- thinking: string;
19237
- thinkingSignature?: string;
19238
- redacted?: boolean;
19239
19234
  } | {
19240
19235
  addedToolNames?: string[];
19241
19236
  arguments: Record<string, any>;
19242
19237
  callID: string;
19243
19238
  name: string;
19244
19239
  namespace?: string;
19245
- partial?: {
19246
- content?: ({
19240
+ result: {
19241
+ content: ({
19247
19242
  type: "text";
19248
19243
  text: string;
19249
19244
  textSignature?: string;
@@ -19253,8 +19248,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19253
19248
  mimeType: string;
19254
19249
  })[];
19255
19250
  details?: any;
19251
+ isError: false;
19256
19252
  };
19257
- status: "running";
19253
+ status: "completed";
19258
19254
  thoughtSignature?: string;
19259
19255
  time: {
19260
19256
  start: number;
@@ -19278,9 +19274,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19278
19274
  mimeType: string;
19279
19275
  })[];
19280
19276
  details?: any;
19281
- isError: false;
19277
+ isError: true;
19282
19278
  };
19283
- status: "completed";
19279
+ status: "error";
19284
19280
  thoughtSignature?: string;
19285
19281
  time: {
19286
19282
  start: number;
@@ -19306,7 +19302,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19306
19302
  details?: any;
19307
19303
  isError: true;
19308
19304
  };
19309
- status: "error";
19305
+ status: "skipped";
19310
19306
  thoughtSignature?: string;
19311
19307
  time: {
19312
19308
  start: number;
@@ -19332,21 +19328,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19332
19328
  details?: any;
19333
19329
  isError: true;
19334
19330
  };
19335
- status: "skipped";
19331
+ status: "aborted";
19336
19332
  thoughtSignature?: string;
19337
19333
  time: {
19338
19334
  start: number;
19339
19335
  end: number;
19340
19336
  };
19341
19337
  type: "toolCall";
19338
+ } | {
19339
+ type: "thinking";
19340
+ thinking: string;
19341
+ thinkingSignature?: string;
19342
+ redacted?: boolean;
19342
19343
  } | {
19343
19344
  addedToolNames?: string[];
19344
19345
  arguments: Record<string, any>;
19345
19346
  callID: string;
19346
19347
  name: string;
19347
19348
  namespace?: string;
19348
- result: {
19349
- content: ({
19349
+ partial?: {
19350
+ content?: ({
19350
19351
  type: "text";
19351
19352
  text: string;
19352
19353
  textSignature?: string;
@@ -19356,9 +19357,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19356
19357
  mimeType: string;
19357
19358
  })[];
19358
19359
  details?: any;
19359
- isError: true;
19360
19360
  };
19361
- status: "aborted";
19361
+ status: "running";
19362
19362
  thoughtSignature?: string;
19363
19363
  time: {
19364
19364
  start: number;
@@ -19533,19 +19533,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19533
19533
  type: "image";
19534
19534
  data: string;
19535
19535
  mimeType: string;
19536
- } | {
19537
- type: "thinking";
19538
- thinking: string;
19539
- thinkingSignature?: string;
19540
- redacted?: boolean;
19541
19536
  } | {
19542
19537
  addedToolNames?: string[];
19543
19538
  arguments: Record<string, any>;
19544
19539
  callID: string;
19545
19540
  name: string;
19546
19541
  namespace?: string;
19547
- partial?: {
19548
- content?: ({
19542
+ result: {
19543
+ content: ({
19549
19544
  type: "text";
19550
19545
  text: string;
19551
19546
  textSignature?: string;
@@ -19555,8 +19550,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19555
19550
  mimeType: string;
19556
19551
  })[];
19557
19552
  details?: any;
19553
+ isError: false;
19558
19554
  };
19559
- status: "running";
19555
+ status: "completed";
19560
19556
  thoughtSignature?: string;
19561
19557
  time: {
19562
19558
  start: number;
@@ -19580,9 +19576,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19580
19576
  mimeType: string;
19581
19577
  })[];
19582
19578
  details?: any;
19583
- isError: false;
19579
+ isError: true;
19584
19580
  };
19585
- status: "completed";
19581
+ status: "error";
19586
19582
  thoughtSignature?: string;
19587
19583
  time: {
19588
19584
  start: number;
@@ -19608,7 +19604,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19608
19604
  details?: any;
19609
19605
  isError: true;
19610
19606
  };
19611
- status: "error";
19607
+ status: "skipped";
19612
19608
  thoughtSignature?: string;
19613
19609
  time: {
19614
19610
  start: number;
@@ -19634,21 +19630,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19634
19630
  details?: any;
19635
19631
  isError: true;
19636
19632
  };
19637
- status: "skipped";
19633
+ status: "aborted";
19638
19634
  thoughtSignature?: string;
19639
19635
  time: {
19640
19636
  start: number;
19641
19637
  end: number;
19642
19638
  };
19643
19639
  type: "toolCall";
19640
+ } | {
19641
+ type: "thinking";
19642
+ thinking: string;
19643
+ thinkingSignature?: string;
19644
+ redacted?: boolean;
19644
19645
  } | {
19645
19646
  addedToolNames?: string[];
19646
19647
  arguments: Record<string, any>;
19647
19648
  callID: string;
19648
19649
  name: string;
19649
19650
  namespace?: string;
19650
- result: {
19651
- content: ({
19651
+ partial?: {
19652
+ content?: ({
19652
19653
  type: "text";
19653
19654
  text: string;
19654
19655
  textSignature?: string;
@@ -19658,9 +19659,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19658
19659
  mimeType: string;
19659
19660
  })[];
19660
19661
  details?: any;
19661
- isError: true;
19662
19662
  };
19663
- status: "aborted";
19663
+ status: "running";
19664
19664
  thoughtSignature?: string;
19665
19665
  time: {
19666
19666
  start: number;
@@ -20848,19 +20848,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20848
20848
  type: "image";
20849
20849
  data: string;
20850
20850
  mimeType: string;
20851
- } | {
20852
- type: "thinking";
20853
- thinking: string;
20854
- thinkingSignature?: string;
20855
- redacted?: boolean;
20856
20851
  } | {
20857
20852
  addedToolNames?: string[];
20858
20853
  arguments: Record<string, any>;
20859
20854
  callID: string;
20860
20855
  name: string;
20861
20856
  namespace?: string;
20862
- partial?: {
20863
- content?: ({
20857
+ result: {
20858
+ content: ({
20864
20859
  type: "text";
20865
20860
  text: string;
20866
20861
  textSignature?: string;
@@ -20870,8 +20865,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20870
20865
  mimeType: string;
20871
20866
  })[];
20872
20867
  details?: any;
20868
+ isError: false;
20873
20869
  };
20874
- status: "running";
20870
+ status: "completed";
20875
20871
  thoughtSignature?: string;
20876
20872
  time: {
20877
20873
  start: number;
@@ -20895,9 +20891,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20895
20891
  mimeType: string;
20896
20892
  })[];
20897
20893
  details?: any;
20898
- isError: false;
20894
+ isError: true;
20899
20895
  };
20900
- status: "completed";
20896
+ status: "error";
20901
20897
  thoughtSignature?: string;
20902
20898
  time: {
20903
20899
  start: number;
@@ -20923,7 +20919,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20923
20919
  details?: any;
20924
20920
  isError: true;
20925
20921
  };
20926
- status: "error";
20922
+ status: "skipped";
20927
20923
  thoughtSignature?: string;
20928
20924
  time: {
20929
20925
  start: number;
@@ -20949,21 +20945,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20949
20945
  details?: any;
20950
20946
  isError: true;
20951
20947
  };
20952
- status: "skipped";
20948
+ status: "aborted";
20953
20949
  thoughtSignature?: string;
20954
20950
  time: {
20955
20951
  start: number;
20956
20952
  end: number;
20957
20953
  };
20958
20954
  type: "toolCall";
20955
+ } | {
20956
+ type: "thinking";
20957
+ thinking: string;
20958
+ thinkingSignature?: string;
20959
+ redacted?: boolean;
20959
20960
  } | {
20960
20961
  addedToolNames?: string[];
20961
20962
  arguments: Record<string, any>;
20962
20963
  callID: string;
20963
20964
  name: string;
20964
20965
  namespace?: string;
20965
- result: {
20966
- content: ({
20966
+ partial?: {
20967
+ content?: ({
20967
20968
  type: "text";
20968
20969
  text: string;
20969
20970
  textSignature?: string;
@@ -20973,9 +20974,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20973
20974
  mimeType: string;
20974
20975
  })[];
20975
20976
  details?: any;
20976
- isError: true;
20977
20977
  };
20978
- status: "aborted";
20978
+ status: "running";
20979
20979
  thoughtSignature?: string;
20980
20980
  time: {
20981
20981
  start: number;
@@ -21150,19 +21150,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21150
21150
  type: "image";
21151
21151
  data: string;
21152
21152
  mimeType: string;
21153
- } | {
21154
- type: "thinking";
21155
- thinking: string;
21156
- thinkingSignature?: string;
21157
- redacted?: boolean;
21158
21153
  } | {
21159
21154
  addedToolNames?: string[];
21160
21155
  arguments: Record<string, any>;
21161
21156
  callID: string;
21162
21157
  name: string;
21163
21158
  namespace?: string;
21164
- partial?: {
21165
- content?: ({
21159
+ result: {
21160
+ content: ({
21166
21161
  type: "text";
21167
21162
  text: string;
21168
21163
  textSignature?: string;
@@ -21172,8 +21167,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21172
21167
  mimeType: string;
21173
21168
  })[];
21174
21169
  details?: any;
21170
+ isError: false;
21175
21171
  };
21176
- status: "running";
21172
+ status: "completed";
21177
21173
  thoughtSignature?: string;
21178
21174
  time: {
21179
21175
  start: number;
@@ -21197,9 +21193,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21197
21193
  mimeType: string;
21198
21194
  })[];
21199
21195
  details?: any;
21200
- isError: false;
21196
+ isError: true;
21201
21197
  };
21202
- status: "completed";
21198
+ status: "error";
21203
21199
  thoughtSignature?: string;
21204
21200
  time: {
21205
21201
  start: number;
@@ -21225,7 +21221,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21225
21221
  details?: any;
21226
21222
  isError: true;
21227
21223
  };
21228
- status: "error";
21224
+ status: "skipped";
21229
21225
  thoughtSignature?: string;
21230
21226
  time: {
21231
21227
  start: number;
@@ -21251,21 +21247,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21251
21247
  details?: any;
21252
21248
  isError: true;
21253
21249
  };
21254
- status: "skipped";
21250
+ status: "aborted";
21255
21251
  thoughtSignature?: string;
21256
21252
  time: {
21257
21253
  start: number;
21258
21254
  end: number;
21259
21255
  };
21260
21256
  type: "toolCall";
21257
+ } | {
21258
+ type: "thinking";
21259
+ thinking: string;
21260
+ thinkingSignature?: string;
21261
+ redacted?: boolean;
21261
21262
  } | {
21262
21263
  addedToolNames?: string[];
21263
21264
  arguments: Record<string, any>;
21264
21265
  callID: string;
21265
21266
  name: string;
21266
21267
  namespace?: string;
21267
- result: {
21268
- content: ({
21268
+ partial?: {
21269
+ content?: ({
21269
21270
  type: "text";
21270
21271
  text: string;
21271
21272
  textSignature?: string;
@@ -21275,9 +21276,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21275
21276
  mimeType: string;
21276
21277
  })[];
21277
21278
  details?: any;
21278
- isError: true;
21279
21279
  };
21280
- status: "aborted";
21280
+ status: "running";
21281
21281
  thoughtSignature?: string;
21282
21282
  time: {
21283
21283
  start: number;
@@ -21470,19 +21470,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21470
21470
  type: "image";
21471
21471
  data: string;
21472
21472
  mimeType: string;
21473
- } | {
21474
- type: "thinking";
21475
- thinking: string;
21476
- thinkingSignature?: string;
21477
- redacted?: boolean;
21478
21473
  } | {
21479
21474
  addedToolNames?: string[];
21480
21475
  arguments: Record<string, any>;
21481
21476
  callID: string;
21482
21477
  name: string;
21483
21478
  namespace?: string;
21484
- partial?: {
21485
- content?: ({
21479
+ result: {
21480
+ content: ({
21486
21481
  type: "text";
21487
21482
  text: string;
21488
21483
  textSignature?: string;
@@ -21492,8 +21487,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21492
21487
  mimeType: string;
21493
21488
  })[];
21494
21489
  details?: any;
21490
+ isError: false;
21495
21491
  };
21496
- status: "running";
21492
+ status: "completed";
21497
21493
  thoughtSignature?: string;
21498
21494
  time: {
21499
21495
  start: number;
@@ -21517,9 +21513,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21517
21513
  mimeType: string;
21518
21514
  })[];
21519
21515
  details?: any;
21520
- isError: false;
21516
+ isError: true;
21521
21517
  };
21522
- status: "completed";
21518
+ status: "error";
21523
21519
  thoughtSignature?: string;
21524
21520
  time: {
21525
21521
  start: number;
@@ -21545,7 +21541,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21545
21541
  details?: any;
21546
21542
  isError: true;
21547
21543
  };
21548
- status: "error";
21544
+ status: "skipped";
21549
21545
  thoughtSignature?: string;
21550
21546
  time: {
21551
21547
  start: number;
@@ -21571,21 +21567,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21571
21567
  details?: any;
21572
21568
  isError: true;
21573
21569
  };
21574
- status: "skipped";
21570
+ status: "aborted";
21575
21571
  thoughtSignature?: string;
21576
21572
  time: {
21577
21573
  start: number;
21578
21574
  end: number;
21579
21575
  };
21580
21576
  type: "toolCall";
21577
+ } | {
21578
+ type: "thinking";
21579
+ thinking: string;
21580
+ thinkingSignature?: string;
21581
+ redacted?: boolean;
21581
21582
  } | {
21582
21583
  addedToolNames?: string[];
21583
21584
  arguments: Record<string, any>;
21584
21585
  callID: string;
21585
21586
  name: string;
21586
21587
  namespace?: string;
21587
- result: {
21588
- content: ({
21588
+ partial?: {
21589
+ content?: ({
21589
21590
  type: "text";
21590
21591
  text: string;
21591
21592
  textSignature?: string;
@@ -21595,9 +21596,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21595
21596
  mimeType: string;
21596
21597
  })[];
21597
21598
  details?: any;
21598
- isError: true;
21599
21599
  };
21600
- status: "aborted";
21600
+ status: "running";
21601
21601
  thoughtSignature?: string;
21602
21602
  time: {
21603
21603
  start: number;
@@ -21772,19 +21772,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21772
21772
  type: "image";
21773
21773
  data: string;
21774
21774
  mimeType: string;
21775
- } | {
21776
- type: "thinking";
21777
- thinking: string;
21778
- thinkingSignature?: string;
21779
- redacted?: boolean;
21780
21775
  } | {
21781
21776
  addedToolNames?: string[];
21782
21777
  arguments: Record<string, any>;
21783
21778
  callID: string;
21784
21779
  name: string;
21785
21780
  namespace?: string;
21786
- partial?: {
21787
- content?: ({
21781
+ result: {
21782
+ content: ({
21788
21783
  type: "text";
21789
21784
  text: string;
21790
21785
  textSignature?: string;
@@ -21794,8 +21789,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21794
21789
  mimeType: string;
21795
21790
  })[];
21796
21791
  details?: any;
21792
+ isError: false;
21797
21793
  };
21798
- status: "running";
21794
+ status: "completed";
21799
21795
  thoughtSignature?: string;
21800
21796
  time: {
21801
21797
  start: number;
@@ -21819,9 +21815,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21819
21815
  mimeType: string;
21820
21816
  })[];
21821
21817
  details?: any;
21822
- isError: false;
21818
+ isError: true;
21823
21819
  };
21824
- status: "completed";
21820
+ status: "error";
21825
21821
  thoughtSignature?: string;
21826
21822
  time: {
21827
21823
  start: number;
@@ -21847,7 +21843,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21847
21843
  details?: any;
21848
21844
  isError: true;
21849
21845
  };
21850
- status: "error";
21846
+ status: "skipped";
21851
21847
  thoughtSignature?: string;
21852
21848
  time: {
21853
21849
  start: number;
@@ -21873,21 +21869,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21873
21869
  details?: any;
21874
21870
  isError: true;
21875
21871
  };
21876
- status: "skipped";
21872
+ status: "aborted";
21877
21873
  thoughtSignature?: string;
21878
21874
  time: {
21879
21875
  start: number;
21880
21876
  end: number;
21881
21877
  };
21882
21878
  type: "toolCall";
21879
+ } | {
21880
+ type: "thinking";
21881
+ thinking: string;
21882
+ thinkingSignature?: string;
21883
+ redacted?: boolean;
21883
21884
  } | {
21884
21885
  addedToolNames?: string[];
21885
21886
  arguments: Record<string, any>;
21886
21887
  callID: string;
21887
21888
  name: string;
21888
21889
  namespace?: string;
21889
- result: {
21890
- content: ({
21890
+ partial?: {
21891
+ content?: ({
21891
21892
  type: "text";
21892
21893
  text: string;
21893
21894
  textSignature?: string;
@@ -21897,9 +21898,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21897
21898
  mimeType: string;
21898
21899
  })[];
21899
21900
  details?: any;
21900
- isError: true;
21901
21901
  };
21902
- status: "aborted";
21902
+ status: "running";
21903
21903
  thoughtSignature?: string;
21904
21904
  time: {
21905
21905
  start: number;
@@ -22102,19 +22102,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22102
22102
  type: "image";
22103
22103
  data: string;
22104
22104
  mimeType: string;
22105
- } | {
22106
- type: "thinking";
22107
- thinking: string;
22108
- thinkingSignature?: string;
22109
- redacted?: boolean;
22110
22105
  } | {
22111
22106
  addedToolNames?: string[];
22112
22107
  arguments: Record<string, any>;
22113
22108
  callID: string;
22114
22109
  name: string;
22115
22110
  namespace?: string;
22116
- partial?: {
22117
- content?: ({
22111
+ result: {
22112
+ content: ({
22118
22113
  type: "text";
22119
22114
  text: string;
22120
22115
  textSignature?: string;
@@ -22124,8 +22119,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22124
22119
  mimeType: string;
22125
22120
  })[];
22126
22121
  details?: any;
22122
+ isError: false;
22127
22123
  };
22128
- status: "running";
22124
+ status: "completed";
22129
22125
  thoughtSignature?: string;
22130
22126
  time: {
22131
22127
  start: number;
@@ -22149,9 +22145,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22149
22145
  mimeType: string;
22150
22146
  })[];
22151
22147
  details?: any;
22152
- isError: false;
22148
+ isError: true;
22153
22149
  };
22154
- status: "completed";
22150
+ status: "error";
22155
22151
  thoughtSignature?: string;
22156
22152
  time: {
22157
22153
  start: number;
@@ -22177,7 +22173,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22177
22173
  details?: any;
22178
22174
  isError: true;
22179
22175
  };
22180
- status: "error";
22176
+ status: "skipped";
22181
22177
  thoughtSignature?: string;
22182
22178
  time: {
22183
22179
  start: number;
@@ -22203,21 +22199,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22203
22199
  details?: any;
22204
22200
  isError: true;
22205
22201
  };
22206
- status: "skipped";
22202
+ status: "aborted";
22207
22203
  thoughtSignature?: string;
22208
22204
  time: {
22209
22205
  start: number;
22210
22206
  end: number;
22211
22207
  };
22212
22208
  type: "toolCall";
22209
+ } | {
22210
+ type: "thinking";
22211
+ thinking: string;
22212
+ thinkingSignature?: string;
22213
+ redacted?: boolean;
22213
22214
  } | {
22214
22215
  addedToolNames?: string[];
22215
22216
  arguments: Record<string, any>;
22216
22217
  callID: string;
22217
22218
  name: string;
22218
22219
  namespace?: string;
22219
- result: {
22220
- content: ({
22220
+ partial?: {
22221
+ content?: ({
22221
22222
  type: "text";
22222
22223
  text: string;
22223
22224
  textSignature?: string;
@@ -22227,9 +22228,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22227
22228
  mimeType: string;
22228
22229
  })[];
22229
22230
  details?: any;
22230
- isError: true;
22231
22231
  };
22232
- status: "aborted";
22232
+ status: "running";
22233
22233
  thoughtSignature?: string;
22234
22234
  time: {
22235
22235
  start: number;
@@ -22404,19 +22404,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22404
22404
  type: "image";
22405
22405
  data: string;
22406
22406
  mimeType: string;
22407
- } | {
22408
- type: "thinking";
22409
- thinking: string;
22410
- thinkingSignature?: string;
22411
- redacted?: boolean;
22412
22407
  } | {
22413
22408
  addedToolNames?: string[];
22414
22409
  arguments: Record<string, any>;
22415
22410
  callID: string;
22416
22411
  name: string;
22417
22412
  namespace?: string;
22418
- partial?: {
22419
- content?: ({
22413
+ result: {
22414
+ content: ({
22420
22415
  type: "text";
22421
22416
  text: string;
22422
22417
  textSignature?: string;
@@ -22426,8 +22421,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22426
22421
  mimeType: string;
22427
22422
  })[];
22428
22423
  details?: any;
22424
+ isError: false;
22429
22425
  };
22430
- status: "running";
22426
+ status: "completed";
22431
22427
  thoughtSignature?: string;
22432
22428
  time: {
22433
22429
  start: number;
@@ -22451,9 +22447,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22451
22447
  mimeType: string;
22452
22448
  })[];
22453
22449
  details?: any;
22454
- isError: false;
22450
+ isError: true;
22455
22451
  };
22456
- status: "completed";
22452
+ status: "error";
22457
22453
  thoughtSignature?: string;
22458
22454
  time: {
22459
22455
  start: number;
@@ -22479,7 +22475,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22479
22475
  details?: any;
22480
22476
  isError: true;
22481
22477
  };
22482
- status: "error";
22478
+ status: "skipped";
22483
22479
  thoughtSignature?: string;
22484
22480
  time: {
22485
22481
  start: number;
@@ -22505,21 +22501,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22505
22501
  details?: any;
22506
22502
  isError: true;
22507
22503
  };
22508
- status: "skipped";
22504
+ status: "aborted";
22509
22505
  thoughtSignature?: string;
22510
22506
  time: {
22511
22507
  start: number;
22512
22508
  end: number;
22513
22509
  };
22514
22510
  type: "toolCall";
22511
+ } | {
22512
+ type: "thinking";
22513
+ thinking: string;
22514
+ thinkingSignature?: string;
22515
+ redacted?: boolean;
22515
22516
  } | {
22516
22517
  addedToolNames?: string[];
22517
22518
  arguments: Record<string, any>;
22518
22519
  callID: string;
22519
22520
  name: string;
22520
22521
  namespace?: string;
22521
- result: {
22522
- content: ({
22522
+ partial?: {
22523
+ content?: ({
22523
22524
  type: "text";
22524
22525
  text: string;
22525
22526
  textSignature?: string;
@@ -22529,9 +22530,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22529
22530
  mimeType: string;
22530
22531
  })[];
22531
22532
  details?: any;
22532
- isError: true;
22533
22533
  };
22534
- status: "aborted";
22534
+ status: "running";
22535
22535
  thoughtSignature?: string;
22536
22536
  time: {
22537
22537
  start: number;
@@ -22725,19 +22725,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22725
22725
  type: "image";
22726
22726
  data: string;
22727
22727
  mimeType: string;
22728
- } | {
22729
- type: "thinking";
22730
- thinking: string;
22731
- thinkingSignature?: string;
22732
- redacted?: boolean;
22733
22728
  } | {
22734
22729
  addedToolNames?: string[];
22735
22730
  arguments: Record<string, any>;
22736
22731
  callID: string;
22737
22732
  name: string;
22738
22733
  namespace?: string;
22739
- partial?: {
22740
- content?: ({
22734
+ result: {
22735
+ content: ({
22741
22736
  type: "text";
22742
22737
  text: string;
22743
22738
  textSignature?: string;
@@ -22747,8 +22742,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22747
22742
  mimeType: string;
22748
22743
  })[];
22749
22744
  details?: any;
22745
+ isError: false;
22750
22746
  };
22751
- status: "running";
22747
+ status: "completed";
22752
22748
  thoughtSignature?: string;
22753
22749
  time: {
22754
22750
  start: number;
@@ -22772,9 +22768,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22772
22768
  mimeType: string;
22773
22769
  })[];
22774
22770
  details?: any;
22775
- isError: false;
22771
+ isError: true;
22776
22772
  };
22777
- status: "completed";
22773
+ status: "error";
22778
22774
  thoughtSignature?: string;
22779
22775
  time: {
22780
22776
  start: number;
@@ -22800,7 +22796,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22800
22796
  details?: any;
22801
22797
  isError: true;
22802
22798
  };
22803
- status: "error";
22799
+ status: "skipped";
22804
22800
  thoughtSignature?: string;
22805
22801
  time: {
22806
22802
  start: number;
@@ -22826,21 +22822,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22826
22822
  details?: any;
22827
22823
  isError: true;
22828
22824
  };
22829
- status: "skipped";
22825
+ status: "aborted";
22830
22826
  thoughtSignature?: string;
22831
22827
  time: {
22832
22828
  start: number;
22833
22829
  end: number;
22834
22830
  };
22835
22831
  type: "toolCall";
22832
+ } | {
22833
+ type: "thinking";
22834
+ thinking: string;
22835
+ thinkingSignature?: string;
22836
+ redacted?: boolean;
22836
22837
  } | {
22837
22838
  addedToolNames?: string[];
22838
22839
  arguments: Record<string, any>;
22839
22840
  callID: string;
22840
22841
  name: string;
22841
22842
  namespace?: string;
22842
- result: {
22843
- content: ({
22843
+ partial?: {
22844
+ content?: ({
22844
22845
  type: "text";
22845
22846
  text: string;
22846
22847
  textSignature?: string;
@@ -22850,9 +22851,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22850
22851
  mimeType: string;
22851
22852
  })[];
22852
22853
  details?: any;
22853
- isError: true;
22854
22854
  };
22855
- status: "aborted";
22855
+ status: "running";
22856
22856
  thoughtSignature?: string;
22857
22857
  time: {
22858
22858
  start: number;
@@ -23027,19 +23027,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23027
23027
  type: "image";
23028
23028
  data: string;
23029
23029
  mimeType: string;
23030
- } | {
23031
- type: "thinking";
23032
- thinking: string;
23033
- thinkingSignature?: string;
23034
- redacted?: boolean;
23035
23030
  } | {
23036
23031
  addedToolNames?: string[];
23037
23032
  arguments: Record<string, any>;
23038
23033
  callID: string;
23039
23034
  name: string;
23040
23035
  namespace?: string;
23041
- partial?: {
23042
- content?: ({
23036
+ result: {
23037
+ content: ({
23043
23038
  type: "text";
23044
23039
  text: string;
23045
23040
  textSignature?: string;
@@ -23049,8 +23044,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23049
23044
  mimeType: string;
23050
23045
  })[];
23051
23046
  details?: any;
23047
+ isError: false;
23052
23048
  };
23053
- status: "running";
23049
+ status: "completed";
23054
23050
  thoughtSignature?: string;
23055
23051
  time: {
23056
23052
  start: number;
@@ -23074,9 +23070,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23074
23070
  mimeType: string;
23075
23071
  })[];
23076
23072
  details?: any;
23077
- isError: false;
23073
+ isError: true;
23078
23074
  };
23079
- status: "completed";
23075
+ status: "error";
23080
23076
  thoughtSignature?: string;
23081
23077
  time: {
23082
23078
  start: number;
@@ -23102,7 +23098,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23102
23098
  details?: any;
23103
23099
  isError: true;
23104
23100
  };
23105
- status: "error";
23101
+ status: "skipped";
23106
23102
  thoughtSignature?: string;
23107
23103
  time: {
23108
23104
  start: number;
@@ -23128,21 +23124,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23128
23124
  details?: any;
23129
23125
  isError: true;
23130
23126
  };
23131
- status: "skipped";
23127
+ status: "aborted";
23132
23128
  thoughtSignature?: string;
23133
23129
  time: {
23134
23130
  start: number;
23135
23131
  end: number;
23136
23132
  };
23137
23133
  type: "toolCall";
23134
+ } | {
23135
+ type: "thinking";
23136
+ thinking: string;
23137
+ thinkingSignature?: string;
23138
+ redacted?: boolean;
23138
23139
  } | {
23139
23140
  addedToolNames?: string[];
23140
23141
  arguments: Record<string, any>;
23141
23142
  callID: string;
23142
23143
  name: string;
23143
23144
  namespace?: string;
23144
- result: {
23145
- content: ({
23145
+ partial?: {
23146
+ content?: ({
23146
23147
  type: "text";
23147
23148
  text: string;
23148
23149
  textSignature?: string;
@@ -23152,9 +23153,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23152
23153
  mimeType: string;
23153
23154
  })[];
23154
23155
  details?: any;
23155
- isError: true;
23156
23156
  };
23157
- status: "aborted";
23157
+ status: "running";
23158
23158
  thoughtSignature?: string;
23159
23159
  time: {
23160
23160
  start: number;
@@ -23357,19 +23357,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23357
23357
  type: "image";
23358
23358
  data: string;
23359
23359
  mimeType: string;
23360
- } | {
23361
- type: "thinking";
23362
- thinking: string;
23363
- thinkingSignature?: string;
23364
- redacted?: boolean;
23365
23360
  } | {
23366
23361
  addedToolNames?: string[];
23367
23362
  arguments: Record<string, any>;
23368
23363
  callID: string;
23369
23364
  name: string;
23370
23365
  namespace?: string;
23371
- partial?: {
23372
- content?: ({
23366
+ result: {
23367
+ content: ({
23373
23368
  type: "text";
23374
23369
  text: string;
23375
23370
  textSignature?: string;
@@ -23379,8 +23374,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23379
23374
  mimeType: string;
23380
23375
  })[];
23381
23376
  details?: any;
23377
+ isError: false;
23382
23378
  };
23383
- status: "running";
23379
+ status: "completed";
23384
23380
  thoughtSignature?: string;
23385
23381
  time: {
23386
23382
  start: number;
@@ -23404,9 +23400,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23404
23400
  mimeType: string;
23405
23401
  })[];
23406
23402
  details?: any;
23407
- isError: false;
23403
+ isError: true;
23408
23404
  };
23409
- status: "completed";
23405
+ status: "error";
23410
23406
  thoughtSignature?: string;
23411
23407
  time: {
23412
23408
  start: number;
@@ -23432,7 +23428,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23432
23428
  details?: any;
23433
23429
  isError: true;
23434
23430
  };
23435
- status: "error";
23431
+ status: "skipped";
23436
23432
  thoughtSignature?: string;
23437
23433
  time: {
23438
23434
  start: number;
@@ -23458,21 +23454,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23458
23454
  details?: any;
23459
23455
  isError: true;
23460
23456
  };
23461
- status: "skipped";
23457
+ status: "aborted";
23462
23458
  thoughtSignature?: string;
23463
23459
  time: {
23464
23460
  start: number;
23465
23461
  end: number;
23466
23462
  };
23467
23463
  type: "toolCall";
23464
+ } | {
23465
+ type: "thinking";
23466
+ thinking: string;
23467
+ thinkingSignature?: string;
23468
+ redacted?: boolean;
23468
23469
  } | {
23469
23470
  addedToolNames?: string[];
23470
23471
  arguments: Record<string, any>;
23471
23472
  callID: string;
23472
23473
  name: string;
23473
23474
  namespace?: string;
23474
- result: {
23475
- content: ({
23475
+ partial?: {
23476
+ content?: ({
23476
23477
  type: "text";
23477
23478
  text: string;
23478
23479
  textSignature?: string;
@@ -23482,9 +23483,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23482
23483
  mimeType: string;
23483
23484
  })[];
23484
23485
  details?: any;
23485
- isError: true;
23486
23486
  };
23487
- status: "aborted";
23487
+ status: "running";
23488
23488
  thoughtSignature?: string;
23489
23489
  time: {
23490
23490
  start: number;
@@ -23659,19 +23659,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23659
23659
  type: "image";
23660
23660
  data: string;
23661
23661
  mimeType: string;
23662
- } | {
23663
- type: "thinking";
23664
- thinking: string;
23665
- thinkingSignature?: string;
23666
- redacted?: boolean;
23667
23662
  } | {
23668
23663
  addedToolNames?: string[];
23669
23664
  arguments: Record<string, any>;
23670
23665
  callID: string;
23671
23666
  name: string;
23672
23667
  namespace?: string;
23673
- partial?: {
23674
- content?: ({
23668
+ result: {
23669
+ content: ({
23675
23670
  type: "text";
23676
23671
  text: string;
23677
23672
  textSignature?: string;
@@ -23681,8 +23676,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23681
23676
  mimeType: string;
23682
23677
  })[];
23683
23678
  details?: any;
23679
+ isError: false;
23684
23680
  };
23685
- status: "running";
23681
+ status: "completed";
23686
23682
  thoughtSignature?: string;
23687
23683
  time: {
23688
23684
  start: number;
@@ -23706,9 +23702,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23706
23702
  mimeType: string;
23707
23703
  })[];
23708
23704
  details?: any;
23709
- isError: false;
23705
+ isError: true;
23710
23706
  };
23711
- status: "completed";
23707
+ status: "error";
23712
23708
  thoughtSignature?: string;
23713
23709
  time: {
23714
23710
  start: number;
@@ -23734,7 +23730,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23734
23730
  details?: any;
23735
23731
  isError: true;
23736
23732
  };
23737
- status: "error";
23733
+ status: "skipped";
23738
23734
  thoughtSignature?: string;
23739
23735
  time: {
23740
23736
  start: number;
@@ -23760,21 +23756,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23760
23756
  details?: any;
23761
23757
  isError: true;
23762
23758
  };
23763
- status: "skipped";
23759
+ status: "aborted";
23764
23760
  thoughtSignature?: string;
23765
23761
  time: {
23766
23762
  start: number;
23767
23763
  end: number;
23768
23764
  };
23769
23765
  type: "toolCall";
23766
+ } | {
23767
+ type: "thinking";
23768
+ thinking: string;
23769
+ thinkingSignature?: string;
23770
+ redacted?: boolean;
23770
23771
  } | {
23771
23772
  addedToolNames?: string[];
23772
23773
  arguments: Record<string, any>;
23773
23774
  callID: string;
23774
23775
  name: string;
23775
23776
  namespace?: string;
23776
- result: {
23777
- content: ({
23777
+ partial?: {
23778
+ content?: ({
23778
23779
  type: "text";
23779
23780
  text: string;
23780
23781
  textSignature?: string;
@@ -23784,9 +23785,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23784
23785
  mimeType: string;
23785
23786
  })[];
23786
23787
  details?: any;
23787
- isError: true;
23788
23788
  };
23789
- status: "aborted";
23789
+ status: "running";
23790
23790
  thoughtSignature?: string;
23791
23791
  time: {
23792
23792
  start: number;
@@ -23980,19 +23980,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23980
23980
  type: "image";
23981
23981
  data: string;
23982
23982
  mimeType: string;
23983
- } | {
23984
- type: "thinking";
23985
- thinking: string;
23986
- thinkingSignature?: string;
23987
- redacted?: boolean;
23988
23983
  } | {
23989
23984
  addedToolNames?: string[];
23990
23985
  arguments: Record<string, any>;
23991
23986
  callID: string;
23992
23987
  name: string;
23993
23988
  namespace?: string;
23994
- partial?: {
23995
- content?: ({
23989
+ result: {
23990
+ content: ({
23996
23991
  type: "text";
23997
23992
  text: string;
23998
23993
  textSignature?: string;
@@ -24002,8 +23997,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24002
23997
  mimeType: string;
24003
23998
  })[];
24004
23999
  details?: any;
24000
+ isError: false;
24005
24001
  };
24006
- status: "running";
24002
+ status: "completed";
24007
24003
  thoughtSignature?: string;
24008
24004
  time: {
24009
24005
  start: number;
@@ -24027,9 +24023,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24027
24023
  mimeType: string;
24028
24024
  })[];
24029
24025
  details?: any;
24030
- isError: false;
24026
+ isError: true;
24031
24027
  };
24032
- status: "completed";
24028
+ status: "error";
24033
24029
  thoughtSignature?: string;
24034
24030
  time: {
24035
24031
  start: number;
@@ -24055,7 +24051,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24055
24051
  details?: any;
24056
24052
  isError: true;
24057
24053
  };
24058
- status: "error";
24054
+ status: "skipped";
24059
24055
  thoughtSignature?: string;
24060
24056
  time: {
24061
24057
  start: number;
@@ -24081,21 +24077,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24081
24077
  details?: any;
24082
24078
  isError: true;
24083
24079
  };
24084
- status: "skipped";
24080
+ status: "aborted";
24085
24081
  thoughtSignature?: string;
24086
24082
  time: {
24087
24083
  start: number;
24088
24084
  end: number;
24089
24085
  };
24090
24086
  type: "toolCall";
24087
+ } | {
24088
+ type: "thinking";
24089
+ thinking: string;
24090
+ thinkingSignature?: string;
24091
+ redacted?: boolean;
24091
24092
  } | {
24092
24093
  addedToolNames?: string[];
24093
24094
  arguments: Record<string, any>;
24094
24095
  callID: string;
24095
24096
  name: string;
24096
24097
  namespace?: string;
24097
- result: {
24098
- content: ({
24098
+ partial?: {
24099
+ content?: ({
24099
24100
  type: "text";
24100
24101
  text: string;
24101
24102
  textSignature?: string;
@@ -24105,9 +24106,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24105
24106
  mimeType: string;
24106
24107
  })[];
24107
24108
  details?: any;
24108
- isError: true;
24109
24109
  };
24110
- status: "aborted";
24110
+ status: "running";
24111
24111
  thoughtSignature?: string;
24112
24112
  time: {
24113
24113
  start: number;
@@ -24282,19 +24282,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24282
24282
  type: "image";
24283
24283
  data: string;
24284
24284
  mimeType: string;
24285
- } | {
24286
- type: "thinking";
24287
- thinking: string;
24288
- thinkingSignature?: string;
24289
- redacted?: boolean;
24290
24285
  } | {
24291
24286
  addedToolNames?: string[];
24292
24287
  arguments: Record<string, any>;
24293
24288
  callID: string;
24294
24289
  name: string;
24295
24290
  namespace?: string;
24296
- partial?: {
24297
- content?: ({
24291
+ result: {
24292
+ content: ({
24298
24293
  type: "text";
24299
24294
  text: string;
24300
24295
  textSignature?: string;
@@ -24304,8 +24299,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24304
24299
  mimeType: string;
24305
24300
  })[];
24306
24301
  details?: any;
24302
+ isError: false;
24307
24303
  };
24308
- status: "running";
24304
+ status: "completed";
24309
24305
  thoughtSignature?: string;
24310
24306
  time: {
24311
24307
  start: number;
@@ -24329,9 +24325,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24329
24325
  mimeType: string;
24330
24326
  })[];
24331
24327
  details?: any;
24332
- isError: false;
24328
+ isError: true;
24333
24329
  };
24334
- status: "completed";
24330
+ status: "error";
24335
24331
  thoughtSignature?: string;
24336
24332
  time: {
24337
24333
  start: number;
@@ -24357,7 +24353,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24357
24353
  details?: any;
24358
24354
  isError: true;
24359
24355
  };
24360
- status: "error";
24356
+ status: "skipped";
24361
24357
  thoughtSignature?: string;
24362
24358
  time: {
24363
24359
  start: number;
@@ -24383,21 +24379,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24383
24379
  details?: any;
24384
24380
  isError: true;
24385
24381
  };
24386
- status: "skipped";
24382
+ status: "aborted";
24387
24383
  thoughtSignature?: string;
24388
24384
  time: {
24389
24385
  start: number;
24390
24386
  end: number;
24391
24387
  };
24392
24388
  type: "toolCall";
24389
+ } | {
24390
+ type: "thinking";
24391
+ thinking: string;
24392
+ thinkingSignature?: string;
24393
+ redacted?: boolean;
24393
24394
  } | {
24394
24395
  addedToolNames?: string[];
24395
24396
  arguments: Record<string, any>;
24396
24397
  callID: string;
24397
24398
  name: string;
24398
24399
  namespace?: string;
24399
- result: {
24400
- content: ({
24400
+ partial?: {
24401
+ content?: ({
24401
24402
  type: "text";
24402
24403
  text: string;
24403
24404
  textSignature?: string;
@@ -24407,9 +24408,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24407
24408
  mimeType: string;
24408
24409
  })[];
24409
24410
  details?: any;
24410
- isError: true;
24411
24411
  };
24412
- status: "aborted";
24412
+ status: "running";
24413
24413
  thoughtSignature?: string;
24414
24414
  time: {
24415
24415
  start: number;