@codeworksh/harness 0.3.0-canary.31.1.g9fbaa8dc → 0.3.0-canary.32.1.g414f2b97

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 +820 -820
  2. package/package.json +3 -3
package/effect.d.mts CHANGED
@@ -2717,21 +2717,6 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2717
2717
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2718
2718
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2719
2719
  declare const encodeMessage: (message: {
2720
- messageId: string;
2721
- role: "user";
2722
- time: {
2723
- created: number;
2724
- };
2725
- parts: ({
2726
- type: "text";
2727
- text: string;
2728
- textSignature?: string;
2729
- } | {
2730
- type: "image";
2731
- data: string;
2732
- mimeType: string;
2733
- })[];
2734
- } | {
2735
2720
  role: "assistant";
2736
2721
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2737
2722
  provider: {
@@ -2881,14 +2866,19 @@ declare const encodeMessage: (message: {
2881
2866
  type: "image";
2882
2867
  data: string;
2883
2868
  mimeType: string;
2869
+ } | {
2870
+ type: "thinking";
2871
+ thinking: string;
2872
+ thinkingSignature?: string;
2873
+ redacted?: boolean;
2884
2874
  } | {
2885
2875
  addedToolNames?: string[];
2886
2876
  arguments: Record<string, any>;
2887
2877
  callID: string;
2888
2878
  name: string;
2889
2879
  namespace?: string;
2890
- result: {
2891
- content: ({
2880
+ partial?: {
2881
+ content?: ({
2892
2882
  type: "text";
2893
2883
  text: string;
2894
2884
  textSignature?: string;
@@ -2898,9 +2888,8 @@ declare const encodeMessage: (message: {
2898
2888
  mimeType: string;
2899
2889
  })[];
2900
2890
  details?: any;
2901
- isError: false;
2902
2891
  };
2903
- status: "completed";
2892
+ status: "running";
2904
2893
  thoughtSignature?: string;
2905
2894
  time: {
2906
2895
  start: number;
@@ -2924,9 +2913,9 @@ declare const encodeMessage: (message: {
2924
2913
  mimeType: string;
2925
2914
  })[];
2926
2915
  details?: any;
2927
- isError: true;
2916
+ isError: false;
2928
2917
  };
2929
- status: "error";
2918
+ status: "completed";
2930
2919
  thoughtSignature?: string;
2931
2920
  time: {
2932
2921
  start: number;
@@ -2952,7 +2941,7 @@ declare const encodeMessage: (message: {
2952
2941
  details?: any;
2953
2942
  isError: true;
2954
2943
  };
2955
- status: "skipped";
2944
+ status: "error";
2956
2945
  thoughtSignature?: string;
2957
2946
  time: {
2958
2947
  start: number;
@@ -2978,26 +2967,21 @@ declare const encodeMessage: (message: {
2978
2967
  details?: any;
2979
2968
  isError: true;
2980
2969
  };
2981
- status: "aborted";
2970
+ status: "skipped";
2982
2971
  thoughtSignature?: string;
2983
2972
  time: {
2984
2973
  start: number;
2985
2974
  end: number;
2986
2975
  };
2987
2976
  type: "toolCall";
2988
- } | {
2989
- type: "thinking";
2990
- thinking: string;
2991
- thinkingSignature?: string;
2992
- redacted?: boolean;
2993
2977
  } | {
2994
2978
  addedToolNames?: string[];
2995
2979
  arguments: Record<string, any>;
2996
2980
  callID: string;
2997
2981
  name: string;
2998
2982
  namespace?: string;
2999
- partial?: {
3000
- content?: ({
2983
+ result: {
2984
+ content: ({
3001
2985
  type: "text";
3002
2986
  text: string;
3003
2987
  textSignature?: string;
@@ -3007,8 +2991,9 @@ declare const encodeMessage: (message: {
3007
2991
  mimeType: string;
3008
2992
  })[];
3009
2993
  details?: any;
2994
+ isError: true;
3010
2995
  };
3011
- status: "running";
2996
+ status: "aborted";
3012
2997
  thoughtSignature?: string;
3013
2998
  time: {
3014
2999
  start: number;
@@ -3033,8 +3018,7 @@ declare const encodeMessage: (message: {
3033
3018
  responseId?: string;
3034
3019
  responseModel?: string;
3035
3020
  messageId: string;
3036
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3037
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3021
+ } | {
3038
3022
  messageId: string;
3039
3023
  role: "user";
3040
3024
  time: {
@@ -3049,8 +3033,8 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3049
3033
  data: string;
3050
3034
  mimeType: string;
3051
3035
  })[];
3052
- }, ContextDecodeError, never>;
3053
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3036
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3037
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3054
3038
  messageId: string;
3055
3039
  role: "user";
3056
3040
  time: {
@@ -3065,7 +3049,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3065
3049
  data: string;
3066
3050
  mimeType: string;
3067
3051
  })[];
3068
- } | {
3052
+ }, ContextDecodeError, never>;
3053
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3069
3054
  role: "assistant";
3070
3055
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3071
3056
  provider: {
@@ -3215,14 +3200,19 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3215
3200
  type: "image";
3216
3201
  data: string;
3217
3202
  mimeType: string;
3203
+ } | {
3204
+ type: "thinking";
3205
+ thinking: string;
3206
+ thinkingSignature?: string;
3207
+ redacted?: boolean;
3218
3208
  } | {
3219
3209
  addedToolNames?: string[];
3220
3210
  arguments: Record<string, any>;
3221
3211
  callID: string;
3222
3212
  name: string;
3223
3213
  namespace?: string;
3224
- result: {
3225
- content: ({
3214
+ partial?: {
3215
+ content?: ({
3226
3216
  type: "text";
3227
3217
  text: string;
3228
3218
  textSignature?: string;
@@ -3232,9 +3222,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3232
3222
  mimeType: string;
3233
3223
  })[];
3234
3224
  details?: any;
3235
- isError: false;
3236
3225
  };
3237
- status: "completed";
3226
+ status: "running";
3238
3227
  thoughtSignature?: string;
3239
3228
  time: {
3240
3229
  start: number;
@@ -3258,9 +3247,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3258
3247
  mimeType: string;
3259
3248
  })[];
3260
3249
  details?: any;
3261
- isError: true;
3250
+ isError: false;
3262
3251
  };
3263
- status: "error";
3252
+ status: "completed";
3264
3253
  thoughtSignature?: string;
3265
3254
  time: {
3266
3255
  start: number;
@@ -3286,7 +3275,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3286
3275
  details?: any;
3287
3276
  isError: true;
3288
3277
  };
3289
- status: "skipped";
3278
+ status: "error";
3290
3279
  thoughtSignature?: string;
3291
3280
  time: {
3292
3281
  start: number;
@@ -3312,26 +3301,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3312
3301
  details?: any;
3313
3302
  isError: true;
3314
3303
  };
3315
- status: "aborted";
3304
+ status: "skipped";
3316
3305
  thoughtSignature?: string;
3317
3306
  time: {
3318
3307
  start: number;
3319
3308
  end: number;
3320
3309
  };
3321
3310
  type: "toolCall";
3322
- } | {
3323
- type: "thinking";
3324
- thinking: string;
3325
- thinkingSignature?: string;
3326
- redacted?: boolean;
3327
3311
  } | {
3328
3312
  addedToolNames?: string[];
3329
3313
  arguments: Record<string, any>;
3330
3314
  callID: string;
3331
3315
  name: string;
3332
3316
  namespace?: string;
3333
- partial?: {
3334
- content?: ({
3317
+ result: {
3318
+ content: ({
3335
3319
  type: "text";
3336
3320
  text: string;
3337
3321
  textSignature?: string;
@@ -3341,8 +3325,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3341
3325
  mimeType: string;
3342
3326
  })[];
3343
3327
  details?: any;
3328
+ isError: true;
3344
3329
  };
3345
- status: "running";
3330
+ status: "aborted";
3346
3331
  thoughtSignature?: string;
3347
3332
  time: {
3348
3333
  start: number;
@@ -3367,6 +3352,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3367
3352
  responseId?: string;
3368
3353
  responseModel?: string;
3369
3354
  messageId: string;
3355
+ } | {
3356
+ messageId: string;
3357
+ role: "user";
3358
+ time: {
3359
+ created: number;
3360
+ };
3361
+ parts: ({
3362
+ type: "text";
3363
+ text: string;
3364
+ textSignature?: string;
3365
+ } | {
3366
+ type: "image";
3367
+ data: string;
3368
+ mimeType: string;
3369
+ })[];
3370
3370
  }, ContextDecodeError, never>;
3371
3371
  declare namespace context_d_exports {
3372
3372
  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 };
@@ -4848,14 +4848,19 @@ declare const LLMStarted: Schema.Struct<{
4848
4848
  type: "image";
4849
4849
  data: string;
4850
4850
  mimeType: string;
4851
+ } | {
4852
+ type: "thinking";
4853
+ thinking: string;
4854
+ thinkingSignature?: string;
4855
+ redacted?: boolean;
4851
4856
  } | {
4852
4857
  addedToolNames?: string[];
4853
4858
  arguments: Record<string, any>;
4854
4859
  callID: string;
4855
4860
  name: string;
4856
4861
  namespace?: string;
4857
- result: {
4858
- content: ({
4862
+ partial?: {
4863
+ content?: ({
4859
4864
  type: "text";
4860
4865
  text: string;
4861
4866
  textSignature?: string;
@@ -4865,9 +4870,8 @@ declare const LLMStarted: Schema.Struct<{
4865
4870
  mimeType: string;
4866
4871
  })[];
4867
4872
  details?: any;
4868
- isError: false;
4869
4873
  };
4870
- status: "completed";
4874
+ status: "running";
4871
4875
  thoughtSignature?: string;
4872
4876
  time: {
4873
4877
  start: number;
@@ -4891,9 +4895,9 @@ declare const LLMStarted: Schema.Struct<{
4891
4895
  mimeType: string;
4892
4896
  })[];
4893
4897
  details?: any;
4894
- isError: true;
4898
+ isError: false;
4895
4899
  };
4896
- status: "error";
4900
+ status: "completed";
4897
4901
  thoughtSignature?: string;
4898
4902
  time: {
4899
4903
  start: number;
@@ -4919,7 +4923,7 @@ declare const LLMStarted: Schema.Struct<{
4919
4923
  details?: any;
4920
4924
  isError: true;
4921
4925
  };
4922
- status: "skipped";
4926
+ status: "error";
4923
4927
  thoughtSignature?: string;
4924
4928
  time: {
4925
4929
  start: number;
@@ -4945,26 +4949,21 @@ declare const LLMStarted: Schema.Struct<{
4945
4949
  details?: any;
4946
4950
  isError: true;
4947
4951
  };
4948
- status: "aborted";
4952
+ status: "skipped";
4949
4953
  thoughtSignature?: string;
4950
4954
  time: {
4951
4955
  start: number;
4952
4956
  end: number;
4953
4957
  };
4954
4958
  type: "toolCall";
4955
- } | {
4956
- type: "thinking";
4957
- thinking: string;
4958
- thinkingSignature?: string;
4959
- redacted?: boolean;
4960
4959
  } | {
4961
4960
  addedToolNames?: string[];
4962
4961
  arguments: Record<string, any>;
4963
4962
  callID: string;
4964
4963
  name: string;
4965
4964
  namespace?: string;
4966
- partial?: {
4967
- content?: ({
4965
+ result: {
4966
+ content: ({
4968
4967
  type: "text";
4969
4968
  text: string;
4970
4969
  textSignature?: string;
@@ -4974,8 +4973,9 @@ declare const LLMStarted: Schema.Struct<{
4974
4973
  mimeType: string;
4975
4974
  })[];
4976
4975
  details?: any;
4976
+ isError: true;
4977
4977
  };
4978
- status: "running";
4978
+ status: "aborted";
4979
4979
  thoughtSignature?: string;
4980
4980
  time: {
4981
4981
  start: number;
@@ -5150,14 +5150,19 @@ declare const LLMStarted: Schema.Struct<{
5150
5150
  type: "image";
5151
5151
  data: string;
5152
5152
  mimeType: string;
5153
+ } | {
5154
+ type: "thinking";
5155
+ thinking: string;
5156
+ thinkingSignature?: string;
5157
+ redacted?: boolean;
5153
5158
  } | {
5154
5159
  addedToolNames?: string[];
5155
5160
  arguments: Record<string, any>;
5156
5161
  callID: string;
5157
5162
  name: string;
5158
5163
  namespace?: string;
5159
- result: {
5160
- content: ({
5164
+ partial?: {
5165
+ content?: ({
5161
5166
  type: "text";
5162
5167
  text: string;
5163
5168
  textSignature?: string;
@@ -5167,9 +5172,8 @@ declare const LLMStarted: Schema.Struct<{
5167
5172
  mimeType: string;
5168
5173
  })[];
5169
5174
  details?: any;
5170
- isError: false;
5171
5175
  };
5172
- status: "completed";
5176
+ status: "running";
5173
5177
  thoughtSignature?: string;
5174
5178
  time: {
5175
5179
  start: number;
@@ -5193,9 +5197,9 @@ declare const LLMStarted: Schema.Struct<{
5193
5197
  mimeType: string;
5194
5198
  })[];
5195
5199
  details?: any;
5196
- isError: true;
5200
+ isError: false;
5197
5201
  };
5198
- status: "error";
5202
+ status: "completed";
5199
5203
  thoughtSignature?: string;
5200
5204
  time: {
5201
5205
  start: number;
@@ -5221,7 +5225,7 @@ declare const LLMStarted: Schema.Struct<{
5221
5225
  details?: any;
5222
5226
  isError: true;
5223
5227
  };
5224
- status: "skipped";
5228
+ status: "error";
5225
5229
  thoughtSignature?: string;
5226
5230
  time: {
5227
5231
  start: number;
@@ -5247,26 +5251,21 @@ declare const LLMStarted: Schema.Struct<{
5247
5251
  details?: any;
5248
5252
  isError: true;
5249
5253
  };
5250
- status: "aborted";
5254
+ status: "skipped";
5251
5255
  thoughtSignature?: string;
5252
5256
  time: {
5253
5257
  start: number;
5254
5258
  end: number;
5255
5259
  };
5256
5260
  type: "toolCall";
5257
- } | {
5258
- type: "thinking";
5259
- thinking: string;
5260
- thinkingSignature?: string;
5261
- redacted?: boolean;
5262
5261
  } | {
5263
5262
  addedToolNames?: string[];
5264
5263
  arguments: Record<string, any>;
5265
5264
  callID: string;
5266
5265
  name: string;
5267
5266
  namespace?: string;
5268
- partial?: {
5269
- content?: ({
5267
+ result: {
5268
+ content: ({
5270
5269
  type: "text";
5271
5270
  text: string;
5272
5271
  textSignature?: string;
@@ -5276,8 +5275,9 @@ declare const LLMStarted: Schema.Struct<{
5276
5275
  mimeType: string;
5277
5276
  })[];
5278
5277
  details?: any;
5278
+ isError: true;
5279
5279
  };
5280
- status: "running";
5280
+ status: "aborted";
5281
5281
  thoughtSignature?: string;
5282
5282
  time: {
5283
5283
  start: number;
@@ -5470,14 +5470,19 @@ declare const LLMStarted: Schema.Struct<{
5470
5470
  type: "image";
5471
5471
  data: string;
5472
5472
  mimeType: string;
5473
+ } | {
5474
+ type: "thinking";
5475
+ thinking: string;
5476
+ thinkingSignature?: string;
5477
+ redacted?: boolean;
5473
5478
  } | {
5474
5479
  addedToolNames?: string[];
5475
5480
  arguments: Record<string, any>;
5476
5481
  callID: string;
5477
5482
  name: string;
5478
5483
  namespace?: string;
5479
- result: {
5480
- content: ({
5484
+ partial?: {
5485
+ content?: ({
5481
5486
  type: "text";
5482
5487
  text: string;
5483
5488
  textSignature?: string;
@@ -5487,9 +5492,8 @@ declare const LLMStarted: Schema.Struct<{
5487
5492
  mimeType: string;
5488
5493
  })[];
5489
5494
  details?: any;
5490
- isError: false;
5491
5495
  };
5492
- status: "completed";
5496
+ status: "running";
5493
5497
  thoughtSignature?: string;
5494
5498
  time: {
5495
5499
  start: number;
@@ -5513,9 +5517,9 @@ declare const LLMStarted: Schema.Struct<{
5513
5517
  mimeType: string;
5514
5518
  })[];
5515
5519
  details?: any;
5516
- isError: true;
5520
+ isError: false;
5517
5521
  };
5518
- status: "error";
5522
+ status: "completed";
5519
5523
  thoughtSignature?: string;
5520
5524
  time: {
5521
5525
  start: number;
@@ -5541,7 +5545,7 @@ declare const LLMStarted: Schema.Struct<{
5541
5545
  details?: any;
5542
5546
  isError: true;
5543
5547
  };
5544
- status: "skipped";
5548
+ status: "error";
5545
5549
  thoughtSignature?: string;
5546
5550
  time: {
5547
5551
  start: number;
@@ -5567,26 +5571,21 @@ declare const LLMStarted: Schema.Struct<{
5567
5571
  details?: any;
5568
5572
  isError: true;
5569
5573
  };
5570
- status: "aborted";
5574
+ status: "skipped";
5571
5575
  thoughtSignature?: string;
5572
5576
  time: {
5573
5577
  start: number;
5574
5578
  end: number;
5575
5579
  };
5576
5580
  type: "toolCall";
5577
- } | {
5578
- type: "thinking";
5579
- thinking: string;
5580
- thinkingSignature?: string;
5581
- redacted?: boolean;
5582
5581
  } | {
5583
5582
  addedToolNames?: string[];
5584
5583
  arguments: Record<string, any>;
5585
5584
  callID: string;
5586
5585
  name: string;
5587
5586
  namespace?: string;
5588
- partial?: {
5589
- content?: ({
5587
+ result: {
5588
+ content: ({
5590
5589
  type: "text";
5591
5590
  text: string;
5592
5591
  textSignature?: string;
@@ -5596,8 +5595,9 @@ declare const LLMStarted: Schema.Struct<{
5596
5595
  mimeType: string;
5597
5596
  })[];
5598
5597
  details?: any;
5598
+ isError: true;
5599
5599
  };
5600
- status: "running";
5600
+ status: "aborted";
5601
5601
  thoughtSignature?: string;
5602
5602
  time: {
5603
5603
  start: number;
@@ -5772,14 +5772,19 @@ declare const LLMStarted: Schema.Struct<{
5772
5772
  type: "image";
5773
5773
  data: string;
5774
5774
  mimeType: string;
5775
+ } | {
5776
+ type: "thinking";
5777
+ thinking: string;
5778
+ thinkingSignature?: string;
5779
+ redacted?: boolean;
5775
5780
  } | {
5776
5781
  addedToolNames?: string[];
5777
5782
  arguments: Record<string, any>;
5778
5783
  callID: string;
5779
5784
  name: string;
5780
5785
  namespace?: string;
5781
- result: {
5782
- content: ({
5786
+ partial?: {
5787
+ content?: ({
5783
5788
  type: "text";
5784
5789
  text: string;
5785
5790
  textSignature?: string;
@@ -5789,9 +5794,8 @@ declare const LLMStarted: Schema.Struct<{
5789
5794
  mimeType: string;
5790
5795
  })[];
5791
5796
  details?: any;
5792
- isError: false;
5793
5797
  };
5794
- status: "completed";
5798
+ status: "running";
5795
5799
  thoughtSignature?: string;
5796
5800
  time: {
5797
5801
  start: number;
@@ -5815,9 +5819,9 @@ declare const LLMStarted: Schema.Struct<{
5815
5819
  mimeType: string;
5816
5820
  })[];
5817
5821
  details?: any;
5818
- isError: true;
5822
+ isError: false;
5819
5823
  };
5820
- status: "error";
5824
+ status: "completed";
5821
5825
  thoughtSignature?: string;
5822
5826
  time: {
5823
5827
  start: number;
@@ -5843,7 +5847,7 @@ declare const LLMStarted: Schema.Struct<{
5843
5847
  details?: any;
5844
5848
  isError: true;
5845
5849
  };
5846
- status: "skipped";
5850
+ status: "error";
5847
5851
  thoughtSignature?: string;
5848
5852
  time: {
5849
5853
  start: number;
@@ -5869,26 +5873,21 @@ declare const LLMStarted: Schema.Struct<{
5869
5873
  details?: any;
5870
5874
  isError: true;
5871
5875
  };
5872
- status: "aborted";
5876
+ status: "skipped";
5873
5877
  thoughtSignature?: string;
5874
5878
  time: {
5875
5879
  start: number;
5876
5880
  end: number;
5877
5881
  };
5878
5882
  type: "toolCall";
5879
- } | {
5880
- type: "thinking";
5881
- thinking: string;
5882
- thinkingSignature?: string;
5883
- redacted?: boolean;
5884
5883
  } | {
5885
5884
  addedToolNames?: string[];
5886
5885
  arguments: Record<string, any>;
5887
5886
  callID: string;
5888
5887
  name: string;
5889
5888
  namespace?: string;
5890
- partial?: {
5891
- content?: ({
5889
+ result: {
5890
+ content: ({
5892
5891
  type: "text";
5893
5892
  text: string;
5894
5893
  textSignature?: string;
@@ -5898,8 +5897,9 @@ declare const LLMStarted: Schema.Struct<{
5898
5897
  mimeType: string;
5899
5898
  })[];
5900
5899
  details?: any;
5900
+ isError: true;
5901
5901
  };
5902
- status: "running";
5902
+ status: "aborted";
5903
5903
  thoughtSignature?: string;
5904
5904
  time: {
5905
5905
  start: number;
@@ -6395,14 +6395,19 @@ declare const LLMEnded: Schema.Struct<{
6395
6395
  type: "image";
6396
6396
  data: string;
6397
6397
  mimeType: string;
6398
+ } | {
6399
+ type: "thinking";
6400
+ thinking: string;
6401
+ thinkingSignature?: string;
6402
+ redacted?: boolean;
6398
6403
  } | {
6399
6404
  addedToolNames?: string[];
6400
6405
  arguments: Record<string, any>;
6401
6406
  callID: string;
6402
6407
  name: string;
6403
6408
  namespace?: string;
6404
- result: {
6405
- content: ({
6409
+ partial?: {
6410
+ content?: ({
6406
6411
  type: "text";
6407
6412
  text: string;
6408
6413
  textSignature?: string;
@@ -6412,9 +6417,8 @@ declare const LLMEnded: Schema.Struct<{
6412
6417
  mimeType: string;
6413
6418
  })[];
6414
6419
  details?: any;
6415
- isError: false;
6416
6420
  };
6417
- status: "completed";
6421
+ status: "running";
6418
6422
  thoughtSignature?: string;
6419
6423
  time: {
6420
6424
  start: number;
@@ -6438,9 +6442,9 @@ declare const LLMEnded: Schema.Struct<{
6438
6442
  mimeType: string;
6439
6443
  })[];
6440
6444
  details?: any;
6441
- isError: true;
6445
+ isError: false;
6442
6446
  };
6443
- status: "error";
6447
+ status: "completed";
6444
6448
  thoughtSignature?: string;
6445
6449
  time: {
6446
6450
  start: number;
@@ -6466,7 +6470,7 @@ declare const LLMEnded: Schema.Struct<{
6466
6470
  details?: any;
6467
6471
  isError: true;
6468
6472
  };
6469
- status: "skipped";
6473
+ status: "error";
6470
6474
  thoughtSignature?: string;
6471
6475
  time: {
6472
6476
  start: number;
@@ -6492,26 +6496,21 @@ declare const LLMEnded: Schema.Struct<{
6492
6496
  details?: any;
6493
6497
  isError: true;
6494
6498
  };
6495
- status: "aborted";
6499
+ status: "skipped";
6496
6500
  thoughtSignature?: string;
6497
6501
  time: {
6498
6502
  start: number;
6499
6503
  end: number;
6500
6504
  };
6501
6505
  type: "toolCall";
6502
- } | {
6503
- type: "thinking";
6504
- thinking: string;
6505
- thinkingSignature?: string;
6506
- redacted?: boolean;
6507
6506
  } | {
6508
6507
  addedToolNames?: string[];
6509
6508
  arguments: Record<string, any>;
6510
6509
  callID: string;
6511
6510
  name: string;
6512
6511
  namespace?: string;
6513
- partial?: {
6514
- content?: ({
6512
+ result: {
6513
+ content: ({
6515
6514
  type: "text";
6516
6515
  text: string;
6517
6516
  textSignature?: string;
@@ -6521,8 +6520,9 @@ declare const LLMEnded: Schema.Struct<{
6521
6520
  mimeType: string;
6522
6521
  })[];
6523
6522
  details?: any;
6523
+ isError: true;
6524
6524
  };
6525
- status: "running";
6525
+ status: "aborted";
6526
6526
  thoughtSignature?: string;
6527
6527
  time: {
6528
6528
  start: number;
@@ -6697,14 +6697,19 @@ declare const LLMEnded: Schema.Struct<{
6697
6697
  type: "image";
6698
6698
  data: string;
6699
6699
  mimeType: string;
6700
+ } | {
6701
+ type: "thinking";
6702
+ thinking: string;
6703
+ thinkingSignature?: string;
6704
+ redacted?: boolean;
6700
6705
  } | {
6701
6706
  addedToolNames?: string[];
6702
6707
  arguments: Record<string, any>;
6703
6708
  callID: string;
6704
6709
  name: string;
6705
6710
  namespace?: string;
6706
- result: {
6707
- content: ({
6711
+ partial?: {
6712
+ content?: ({
6708
6713
  type: "text";
6709
6714
  text: string;
6710
6715
  textSignature?: string;
@@ -6714,9 +6719,8 @@ declare const LLMEnded: Schema.Struct<{
6714
6719
  mimeType: string;
6715
6720
  })[];
6716
6721
  details?: any;
6717
- isError: false;
6718
6722
  };
6719
- status: "completed";
6723
+ status: "running";
6720
6724
  thoughtSignature?: string;
6721
6725
  time: {
6722
6726
  start: number;
@@ -6740,9 +6744,9 @@ declare const LLMEnded: Schema.Struct<{
6740
6744
  mimeType: string;
6741
6745
  })[];
6742
6746
  details?: any;
6743
- isError: true;
6747
+ isError: false;
6744
6748
  };
6745
- status: "error";
6749
+ status: "completed";
6746
6750
  thoughtSignature?: string;
6747
6751
  time: {
6748
6752
  start: number;
@@ -6768,7 +6772,7 @@ declare const LLMEnded: Schema.Struct<{
6768
6772
  details?: any;
6769
6773
  isError: true;
6770
6774
  };
6771
- status: "skipped";
6775
+ status: "error";
6772
6776
  thoughtSignature?: string;
6773
6777
  time: {
6774
6778
  start: number;
@@ -6794,26 +6798,21 @@ declare const LLMEnded: Schema.Struct<{
6794
6798
  details?: any;
6795
6799
  isError: true;
6796
6800
  };
6797
- status: "aborted";
6801
+ status: "skipped";
6798
6802
  thoughtSignature?: string;
6799
6803
  time: {
6800
6804
  start: number;
6801
6805
  end: number;
6802
6806
  };
6803
6807
  type: "toolCall";
6804
- } | {
6805
- type: "thinking";
6806
- thinking: string;
6807
- thinkingSignature?: string;
6808
- redacted?: boolean;
6809
6808
  } | {
6810
6809
  addedToolNames?: string[];
6811
6810
  arguments: Record<string, any>;
6812
6811
  callID: string;
6813
6812
  name: string;
6814
6813
  namespace?: string;
6815
- partial?: {
6816
- content?: ({
6814
+ result: {
6815
+ content: ({
6817
6816
  type: "text";
6818
6817
  text: string;
6819
6818
  textSignature?: string;
@@ -6823,8 +6822,9 @@ declare const LLMEnded: Schema.Struct<{
6823
6822
  mimeType: string;
6824
6823
  })[];
6825
6824
  details?: any;
6825
+ isError: true;
6826
6826
  };
6827
- status: "running";
6827
+ status: "aborted";
6828
6828
  thoughtSignature?: string;
6829
6829
  time: {
6830
6830
  start: number;
@@ -7018,14 +7018,19 @@ declare const LLMEnded: Schema.Struct<{
7018
7018
  type: "image";
7019
7019
  data: string;
7020
7020
  mimeType: string;
7021
+ } | {
7022
+ type: "thinking";
7023
+ thinking: string;
7024
+ thinkingSignature?: string;
7025
+ redacted?: boolean;
7021
7026
  } | {
7022
7027
  addedToolNames?: string[];
7023
7028
  arguments: Record<string, any>;
7024
7029
  callID: string;
7025
7030
  name: string;
7026
7031
  namespace?: string;
7027
- result: {
7028
- content: ({
7032
+ partial?: {
7033
+ content?: ({
7029
7034
  type: "text";
7030
7035
  text: string;
7031
7036
  textSignature?: string;
@@ -7035,9 +7040,8 @@ declare const LLMEnded: Schema.Struct<{
7035
7040
  mimeType: string;
7036
7041
  })[];
7037
7042
  details?: any;
7038
- isError: false;
7039
7043
  };
7040
- status: "completed";
7044
+ status: "running";
7041
7045
  thoughtSignature?: string;
7042
7046
  time: {
7043
7047
  start: number;
@@ -7061,9 +7065,9 @@ declare const LLMEnded: Schema.Struct<{
7061
7065
  mimeType: string;
7062
7066
  })[];
7063
7067
  details?: any;
7064
- isError: true;
7068
+ isError: false;
7065
7069
  };
7066
- status: "error";
7070
+ status: "completed";
7067
7071
  thoughtSignature?: string;
7068
7072
  time: {
7069
7073
  start: number;
@@ -7089,7 +7093,7 @@ declare const LLMEnded: Schema.Struct<{
7089
7093
  details?: any;
7090
7094
  isError: true;
7091
7095
  };
7092
- status: "skipped";
7096
+ status: "error";
7093
7097
  thoughtSignature?: string;
7094
7098
  time: {
7095
7099
  start: number;
@@ -7115,26 +7119,21 @@ declare const LLMEnded: Schema.Struct<{
7115
7119
  details?: any;
7116
7120
  isError: true;
7117
7121
  };
7118
- status: "aborted";
7122
+ status: "skipped";
7119
7123
  thoughtSignature?: string;
7120
7124
  time: {
7121
7125
  start: number;
7122
7126
  end: number;
7123
7127
  };
7124
7128
  type: "toolCall";
7125
- } | {
7126
- type: "thinking";
7127
- thinking: string;
7128
- thinkingSignature?: string;
7129
- redacted?: boolean;
7130
7129
  } | {
7131
7130
  addedToolNames?: string[];
7132
7131
  arguments: Record<string, any>;
7133
7132
  callID: string;
7134
7133
  name: string;
7135
7134
  namespace?: string;
7136
- partial?: {
7137
- content?: ({
7135
+ result: {
7136
+ content: ({
7138
7137
  type: "text";
7139
7138
  text: string;
7140
7139
  textSignature?: string;
@@ -7144,8 +7143,9 @@ declare const LLMEnded: Schema.Struct<{
7144
7143
  mimeType: string;
7145
7144
  })[];
7146
7145
  details?: any;
7146
+ isError: true;
7147
7147
  };
7148
- status: "running";
7148
+ status: "aborted";
7149
7149
  thoughtSignature?: string;
7150
7150
  time: {
7151
7151
  start: number;
@@ -7320,14 +7320,19 @@ declare const LLMEnded: Schema.Struct<{
7320
7320
  type: "image";
7321
7321
  data: string;
7322
7322
  mimeType: string;
7323
+ } | {
7324
+ type: "thinking";
7325
+ thinking: string;
7326
+ thinkingSignature?: string;
7327
+ redacted?: boolean;
7323
7328
  } | {
7324
7329
  addedToolNames?: string[];
7325
7330
  arguments: Record<string, any>;
7326
7331
  callID: string;
7327
7332
  name: string;
7328
7333
  namespace?: string;
7329
- result: {
7330
- content: ({
7334
+ partial?: {
7335
+ content?: ({
7331
7336
  type: "text";
7332
7337
  text: string;
7333
7338
  textSignature?: string;
@@ -7337,9 +7342,8 @@ declare const LLMEnded: Schema.Struct<{
7337
7342
  mimeType: string;
7338
7343
  })[];
7339
7344
  details?: any;
7340
- isError: false;
7341
7345
  };
7342
- status: "completed";
7346
+ status: "running";
7343
7347
  thoughtSignature?: string;
7344
7348
  time: {
7345
7349
  start: number;
@@ -7363,9 +7367,9 @@ declare const LLMEnded: Schema.Struct<{
7363
7367
  mimeType: string;
7364
7368
  })[];
7365
7369
  details?: any;
7366
- isError: true;
7370
+ isError: false;
7367
7371
  };
7368
- status: "error";
7372
+ status: "completed";
7369
7373
  thoughtSignature?: string;
7370
7374
  time: {
7371
7375
  start: number;
@@ -7391,7 +7395,7 @@ declare const LLMEnded: Schema.Struct<{
7391
7395
  details?: any;
7392
7396
  isError: true;
7393
7397
  };
7394
- status: "skipped";
7398
+ status: "error";
7395
7399
  thoughtSignature?: string;
7396
7400
  time: {
7397
7401
  start: number;
@@ -7417,26 +7421,21 @@ declare const LLMEnded: Schema.Struct<{
7417
7421
  details?: any;
7418
7422
  isError: true;
7419
7423
  };
7420
- status: "aborted";
7424
+ status: "skipped";
7421
7425
  thoughtSignature?: string;
7422
7426
  time: {
7423
7427
  start: number;
7424
7428
  end: number;
7425
7429
  };
7426
7430
  type: "toolCall";
7427
- } | {
7428
- type: "thinking";
7429
- thinking: string;
7430
- thinkingSignature?: string;
7431
- redacted?: boolean;
7432
7431
  } | {
7433
7432
  addedToolNames?: string[];
7434
7433
  arguments: Record<string, any>;
7435
7434
  callID: string;
7436
7435
  name: string;
7437
7436
  namespace?: string;
7438
- partial?: {
7439
- content?: ({
7437
+ result: {
7438
+ content: ({
7440
7439
  type: "text";
7441
7440
  text: string;
7442
7441
  textSignature?: string;
@@ -7446,8 +7445,9 @@ declare const LLMEnded: Schema.Struct<{
7446
7445
  mimeType: string;
7447
7446
  })[];
7448
7447
  details?: any;
7448
+ isError: true;
7449
7449
  };
7450
- status: "running";
7450
+ status: "aborted";
7451
7451
  thoughtSignature?: string;
7452
7452
  time: {
7453
7453
  start: number;
@@ -7653,14 +7653,19 @@ declare const LLMFailed: Schema.Struct<{
7653
7653
  type: "image";
7654
7654
  data: string;
7655
7655
  mimeType: string;
7656
+ } | {
7657
+ type: "thinking";
7658
+ thinking: string;
7659
+ thinkingSignature?: string;
7660
+ redacted?: boolean;
7656
7661
  } | {
7657
7662
  addedToolNames?: string[];
7658
7663
  arguments: Record<string, any>;
7659
7664
  callID: string;
7660
7665
  name: string;
7661
7666
  namespace?: string;
7662
- result: {
7663
- content: ({
7667
+ partial?: {
7668
+ content?: ({
7664
7669
  type: "text";
7665
7670
  text: string;
7666
7671
  textSignature?: string;
@@ -7670,9 +7675,8 @@ declare const LLMFailed: Schema.Struct<{
7670
7675
  mimeType: string;
7671
7676
  })[];
7672
7677
  details?: any;
7673
- isError: false;
7674
7678
  };
7675
- status: "completed";
7679
+ status: "running";
7676
7680
  thoughtSignature?: string;
7677
7681
  time: {
7678
7682
  start: number;
@@ -7696,9 +7700,9 @@ declare const LLMFailed: Schema.Struct<{
7696
7700
  mimeType: string;
7697
7701
  })[];
7698
7702
  details?: any;
7699
- isError: true;
7703
+ isError: false;
7700
7704
  };
7701
- status: "error";
7705
+ status: "completed";
7702
7706
  thoughtSignature?: string;
7703
7707
  time: {
7704
7708
  start: number;
@@ -7724,7 +7728,7 @@ declare const LLMFailed: Schema.Struct<{
7724
7728
  details?: any;
7725
7729
  isError: true;
7726
7730
  };
7727
- status: "skipped";
7731
+ status: "error";
7728
7732
  thoughtSignature?: string;
7729
7733
  time: {
7730
7734
  start: number;
@@ -7750,26 +7754,21 @@ declare const LLMFailed: Schema.Struct<{
7750
7754
  details?: any;
7751
7755
  isError: true;
7752
7756
  };
7753
- status: "aborted";
7757
+ status: "skipped";
7754
7758
  thoughtSignature?: string;
7755
7759
  time: {
7756
7760
  start: number;
7757
7761
  end: number;
7758
7762
  };
7759
7763
  type: "toolCall";
7760
- } | {
7761
- type: "thinking";
7762
- thinking: string;
7763
- thinkingSignature?: string;
7764
- redacted?: boolean;
7765
7764
  } | {
7766
7765
  addedToolNames?: string[];
7767
7766
  arguments: Record<string, any>;
7768
7767
  callID: string;
7769
7768
  name: string;
7770
7769
  namespace?: string;
7771
- partial?: {
7772
- content?: ({
7770
+ result: {
7771
+ content: ({
7773
7772
  type: "text";
7774
7773
  text: string;
7775
7774
  textSignature?: string;
@@ -7779,8 +7778,9 @@ declare const LLMFailed: Schema.Struct<{
7779
7778
  mimeType: string;
7780
7779
  })[];
7781
7780
  details?: any;
7781
+ isError: true;
7782
7782
  };
7783
- status: "running";
7783
+ status: "aborted";
7784
7784
  thoughtSignature?: string;
7785
7785
  time: {
7786
7786
  start: number;
@@ -7955,14 +7955,19 @@ declare const LLMFailed: Schema.Struct<{
7955
7955
  type: "image";
7956
7956
  data: string;
7957
7957
  mimeType: string;
7958
+ } | {
7959
+ type: "thinking";
7960
+ thinking: string;
7961
+ thinkingSignature?: string;
7962
+ redacted?: boolean;
7958
7963
  } | {
7959
7964
  addedToolNames?: string[];
7960
7965
  arguments: Record<string, any>;
7961
7966
  callID: string;
7962
7967
  name: string;
7963
7968
  namespace?: string;
7964
- result: {
7965
- content: ({
7969
+ partial?: {
7970
+ content?: ({
7966
7971
  type: "text";
7967
7972
  text: string;
7968
7973
  textSignature?: string;
@@ -7972,9 +7977,8 @@ declare const LLMFailed: Schema.Struct<{
7972
7977
  mimeType: string;
7973
7978
  })[];
7974
7979
  details?: any;
7975
- isError: false;
7976
7980
  };
7977
- status: "completed";
7981
+ status: "running";
7978
7982
  thoughtSignature?: string;
7979
7983
  time: {
7980
7984
  start: number;
@@ -7998,9 +8002,9 @@ declare const LLMFailed: Schema.Struct<{
7998
8002
  mimeType: string;
7999
8003
  })[];
8000
8004
  details?: any;
8001
- isError: true;
8005
+ isError: false;
8002
8006
  };
8003
- status: "error";
8007
+ status: "completed";
8004
8008
  thoughtSignature?: string;
8005
8009
  time: {
8006
8010
  start: number;
@@ -8026,7 +8030,7 @@ declare const LLMFailed: Schema.Struct<{
8026
8030
  details?: any;
8027
8031
  isError: true;
8028
8032
  };
8029
- status: "skipped";
8033
+ status: "error";
8030
8034
  thoughtSignature?: string;
8031
8035
  time: {
8032
8036
  start: number;
@@ -8052,26 +8056,21 @@ declare const LLMFailed: Schema.Struct<{
8052
8056
  details?: any;
8053
8057
  isError: true;
8054
8058
  };
8055
- status: "aborted";
8059
+ status: "skipped";
8056
8060
  thoughtSignature?: string;
8057
8061
  time: {
8058
8062
  start: number;
8059
8063
  end: number;
8060
8064
  };
8061
8065
  type: "toolCall";
8062
- } | {
8063
- type: "thinking";
8064
- thinking: string;
8065
- thinkingSignature?: string;
8066
- redacted?: boolean;
8067
8066
  } | {
8068
8067
  addedToolNames?: string[];
8069
8068
  arguments: Record<string, any>;
8070
8069
  callID: string;
8071
8070
  name: string;
8072
8071
  namespace?: string;
8073
- partial?: {
8074
- content?: ({
8072
+ result: {
8073
+ content: ({
8075
8074
  type: "text";
8076
8075
  text: string;
8077
8076
  textSignature?: string;
@@ -8081,8 +8080,9 @@ declare const LLMFailed: Schema.Struct<{
8081
8080
  mimeType: string;
8082
8081
  })[];
8083
8082
  details?: any;
8083
+ isError: true;
8084
8084
  };
8085
- status: "running";
8085
+ status: "aborted";
8086
8086
  thoughtSignature?: string;
8087
8087
  time: {
8088
8088
  start: number;
@@ -8276,14 +8276,19 @@ declare const LLMFailed: Schema.Struct<{
8276
8276
  type: "image";
8277
8277
  data: string;
8278
8278
  mimeType: string;
8279
+ } | {
8280
+ type: "thinking";
8281
+ thinking: string;
8282
+ thinkingSignature?: string;
8283
+ redacted?: boolean;
8279
8284
  } | {
8280
8285
  addedToolNames?: string[];
8281
8286
  arguments: Record<string, any>;
8282
8287
  callID: string;
8283
8288
  name: string;
8284
8289
  namespace?: string;
8285
- result: {
8286
- content: ({
8290
+ partial?: {
8291
+ content?: ({
8287
8292
  type: "text";
8288
8293
  text: string;
8289
8294
  textSignature?: string;
@@ -8293,9 +8298,8 @@ declare const LLMFailed: Schema.Struct<{
8293
8298
  mimeType: string;
8294
8299
  })[];
8295
8300
  details?: any;
8296
- isError: false;
8297
8301
  };
8298
- status: "completed";
8302
+ status: "running";
8299
8303
  thoughtSignature?: string;
8300
8304
  time: {
8301
8305
  start: number;
@@ -8319,9 +8323,9 @@ declare const LLMFailed: Schema.Struct<{
8319
8323
  mimeType: string;
8320
8324
  })[];
8321
8325
  details?: any;
8322
- isError: true;
8326
+ isError: false;
8323
8327
  };
8324
- status: "error";
8328
+ status: "completed";
8325
8329
  thoughtSignature?: string;
8326
8330
  time: {
8327
8331
  start: number;
@@ -8347,7 +8351,7 @@ declare const LLMFailed: Schema.Struct<{
8347
8351
  details?: any;
8348
8352
  isError: true;
8349
8353
  };
8350
- status: "skipped";
8354
+ status: "error";
8351
8355
  thoughtSignature?: string;
8352
8356
  time: {
8353
8357
  start: number;
@@ -8373,26 +8377,21 @@ declare const LLMFailed: Schema.Struct<{
8373
8377
  details?: any;
8374
8378
  isError: true;
8375
8379
  };
8376
- status: "aborted";
8380
+ status: "skipped";
8377
8381
  thoughtSignature?: string;
8378
8382
  time: {
8379
8383
  start: number;
8380
8384
  end: number;
8381
8385
  };
8382
8386
  type: "toolCall";
8383
- } | {
8384
- type: "thinking";
8385
- thinking: string;
8386
- thinkingSignature?: string;
8387
- redacted?: boolean;
8388
8387
  } | {
8389
8388
  addedToolNames?: string[];
8390
8389
  arguments: Record<string, any>;
8391
8390
  callID: string;
8392
8391
  name: string;
8393
8392
  namespace?: string;
8394
- partial?: {
8395
- content?: ({
8393
+ result: {
8394
+ content: ({
8396
8395
  type: "text";
8397
8396
  text: string;
8398
8397
  textSignature?: string;
@@ -8402,8 +8401,9 @@ declare const LLMFailed: Schema.Struct<{
8402
8401
  mimeType: string;
8403
8402
  })[];
8404
8403
  details?: any;
8404
+ isError: true;
8405
8405
  };
8406
- status: "running";
8406
+ status: "aborted";
8407
8407
  thoughtSignature?: string;
8408
8408
  time: {
8409
8409
  start: number;
@@ -8578,14 +8578,19 @@ declare const LLMFailed: Schema.Struct<{
8578
8578
  type: "image";
8579
8579
  data: string;
8580
8580
  mimeType: string;
8581
+ } | {
8582
+ type: "thinking";
8583
+ thinking: string;
8584
+ thinkingSignature?: string;
8585
+ redacted?: boolean;
8581
8586
  } | {
8582
8587
  addedToolNames?: string[];
8583
8588
  arguments: Record<string, any>;
8584
8589
  callID: string;
8585
8590
  name: string;
8586
8591
  namespace?: string;
8587
- result: {
8588
- content: ({
8592
+ partial?: {
8593
+ content?: ({
8589
8594
  type: "text";
8590
8595
  text: string;
8591
8596
  textSignature?: string;
@@ -8595,9 +8600,8 @@ declare const LLMFailed: Schema.Struct<{
8595
8600
  mimeType: string;
8596
8601
  })[];
8597
8602
  details?: any;
8598
- isError: false;
8599
8603
  };
8600
- status: "completed";
8604
+ status: "running";
8601
8605
  thoughtSignature?: string;
8602
8606
  time: {
8603
8607
  start: number;
@@ -8621,9 +8625,9 @@ declare const LLMFailed: Schema.Struct<{
8621
8625
  mimeType: string;
8622
8626
  })[];
8623
8627
  details?: any;
8624
- isError: true;
8628
+ isError: false;
8625
8629
  };
8626
- status: "error";
8630
+ status: "completed";
8627
8631
  thoughtSignature?: string;
8628
8632
  time: {
8629
8633
  start: number;
@@ -8649,7 +8653,7 @@ declare const LLMFailed: Schema.Struct<{
8649
8653
  details?: any;
8650
8654
  isError: true;
8651
8655
  };
8652
- status: "skipped";
8656
+ status: "error";
8653
8657
  thoughtSignature?: string;
8654
8658
  time: {
8655
8659
  start: number;
@@ -8675,26 +8679,21 @@ declare const LLMFailed: Schema.Struct<{
8675
8679
  details?: any;
8676
8680
  isError: true;
8677
8681
  };
8678
- status: "aborted";
8682
+ status: "skipped";
8679
8683
  thoughtSignature?: string;
8680
8684
  time: {
8681
8685
  start: number;
8682
8686
  end: number;
8683
8687
  };
8684
8688
  type: "toolCall";
8685
- } | {
8686
- type: "thinking";
8687
- thinking: string;
8688
- thinkingSignature?: string;
8689
- redacted?: boolean;
8690
8689
  } | {
8691
8690
  addedToolNames?: string[];
8692
8691
  arguments: Record<string, any>;
8693
8692
  callID: string;
8694
8693
  name: string;
8695
8694
  namespace?: string;
8696
- partial?: {
8697
- content?: ({
8695
+ result: {
8696
+ content: ({
8698
8697
  type: "text";
8699
8698
  text: string;
8700
8699
  textSignature?: string;
@@ -8704,8 +8703,9 @@ declare const LLMFailed: Schema.Struct<{
8704
8703
  mimeType: string;
8705
8704
  })[];
8706
8705
  details?: any;
8706
+ isError: true;
8707
8707
  };
8708
- status: "running";
8708
+ status: "aborted";
8709
8709
  thoughtSignature?: string;
8710
8710
  time: {
8711
8711
  start: number;
@@ -10453,14 +10453,19 @@ declare const Definitions: readonly [Schema.Struct<{
10453
10453
  type: "image";
10454
10454
  data: string;
10455
10455
  mimeType: string;
10456
+ } | {
10457
+ type: "thinking";
10458
+ thinking: string;
10459
+ thinkingSignature?: string;
10460
+ redacted?: boolean;
10456
10461
  } | {
10457
10462
  addedToolNames?: string[];
10458
10463
  arguments: Record<string, any>;
10459
10464
  callID: string;
10460
10465
  name: string;
10461
10466
  namespace?: string;
10462
- result: {
10463
- content: ({
10467
+ partial?: {
10468
+ content?: ({
10464
10469
  type: "text";
10465
10470
  text: string;
10466
10471
  textSignature?: string;
@@ -10470,9 +10475,8 @@ declare const Definitions: readonly [Schema.Struct<{
10470
10475
  mimeType: string;
10471
10476
  })[];
10472
10477
  details?: any;
10473
- isError: false;
10474
10478
  };
10475
- status: "completed";
10479
+ status: "running";
10476
10480
  thoughtSignature?: string;
10477
10481
  time: {
10478
10482
  start: number;
@@ -10496,9 +10500,9 @@ declare const Definitions: readonly [Schema.Struct<{
10496
10500
  mimeType: string;
10497
10501
  })[];
10498
10502
  details?: any;
10499
- isError: true;
10503
+ isError: false;
10500
10504
  };
10501
- status: "error";
10505
+ status: "completed";
10502
10506
  thoughtSignature?: string;
10503
10507
  time: {
10504
10508
  start: number;
@@ -10524,7 +10528,7 @@ declare const Definitions: readonly [Schema.Struct<{
10524
10528
  details?: any;
10525
10529
  isError: true;
10526
10530
  };
10527
- status: "skipped";
10531
+ status: "error";
10528
10532
  thoughtSignature?: string;
10529
10533
  time: {
10530
10534
  start: number;
@@ -10550,26 +10554,21 @@ declare const Definitions: readonly [Schema.Struct<{
10550
10554
  details?: any;
10551
10555
  isError: true;
10552
10556
  };
10553
- status: "aborted";
10557
+ status: "skipped";
10554
10558
  thoughtSignature?: string;
10555
10559
  time: {
10556
10560
  start: number;
10557
10561
  end: number;
10558
10562
  };
10559
10563
  type: "toolCall";
10560
- } | {
10561
- type: "thinking";
10562
- thinking: string;
10563
- thinkingSignature?: string;
10564
- redacted?: boolean;
10565
10564
  } | {
10566
10565
  addedToolNames?: string[];
10567
10566
  arguments: Record<string, any>;
10568
10567
  callID: string;
10569
10568
  name: string;
10570
10569
  namespace?: string;
10571
- partial?: {
10572
- content?: ({
10570
+ result: {
10571
+ content: ({
10573
10572
  type: "text";
10574
10573
  text: string;
10575
10574
  textSignature?: string;
@@ -10579,8 +10578,9 @@ declare const Definitions: readonly [Schema.Struct<{
10579
10578
  mimeType: string;
10580
10579
  })[];
10581
10580
  details?: any;
10581
+ isError: true;
10582
10582
  };
10583
- status: "running";
10583
+ status: "aborted";
10584
10584
  thoughtSignature?: string;
10585
10585
  time: {
10586
10586
  start: number;
@@ -10755,14 +10755,19 @@ declare const Definitions: readonly [Schema.Struct<{
10755
10755
  type: "image";
10756
10756
  data: string;
10757
10757
  mimeType: string;
10758
+ } | {
10759
+ type: "thinking";
10760
+ thinking: string;
10761
+ thinkingSignature?: string;
10762
+ redacted?: boolean;
10758
10763
  } | {
10759
10764
  addedToolNames?: string[];
10760
10765
  arguments: Record<string, any>;
10761
10766
  callID: string;
10762
10767
  name: string;
10763
10768
  namespace?: string;
10764
- result: {
10765
- content: ({
10769
+ partial?: {
10770
+ content?: ({
10766
10771
  type: "text";
10767
10772
  text: string;
10768
10773
  textSignature?: string;
@@ -10772,9 +10777,8 @@ declare const Definitions: readonly [Schema.Struct<{
10772
10777
  mimeType: string;
10773
10778
  })[];
10774
10779
  details?: any;
10775
- isError: false;
10776
10780
  };
10777
- status: "completed";
10781
+ status: "running";
10778
10782
  thoughtSignature?: string;
10779
10783
  time: {
10780
10784
  start: number;
@@ -10798,9 +10802,9 @@ declare const Definitions: readonly [Schema.Struct<{
10798
10802
  mimeType: string;
10799
10803
  })[];
10800
10804
  details?: any;
10801
- isError: true;
10805
+ isError: false;
10802
10806
  };
10803
- status: "error";
10807
+ status: "completed";
10804
10808
  thoughtSignature?: string;
10805
10809
  time: {
10806
10810
  start: number;
@@ -10826,7 +10830,7 @@ declare const Definitions: readonly [Schema.Struct<{
10826
10830
  details?: any;
10827
10831
  isError: true;
10828
10832
  };
10829
- status: "skipped";
10833
+ status: "error";
10830
10834
  thoughtSignature?: string;
10831
10835
  time: {
10832
10836
  start: number;
@@ -10852,26 +10856,21 @@ declare const Definitions: readonly [Schema.Struct<{
10852
10856
  details?: any;
10853
10857
  isError: true;
10854
10858
  };
10855
- status: "aborted";
10859
+ status: "skipped";
10856
10860
  thoughtSignature?: string;
10857
10861
  time: {
10858
10862
  start: number;
10859
10863
  end: number;
10860
10864
  };
10861
10865
  type: "toolCall";
10862
- } | {
10863
- type: "thinking";
10864
- thinking: string;
10865
- thinkingSignature?: string;
10866
- redacted?: boolean;
10867
10866
  } | {
10868
10867
  addedToolNames?: string[];
10869
10868
  arguments: Record<string, any>;
10870
10869
  callID: string;
10871
10870
  name: string;
10872
10871
  namespace?: string;
10873
- partial?: {
10874
- content?: ({
10872
+ result: {
10873
+ content: ({
10875
10874
  type: "text";
10876
10875
  text: string;
10877
10876
  textSignature?: string;
@@ -10881,8 +10880,9 @@ declare const Definitions: readonly [Schema.Struct<{
10881
10880
  mimeType: string;
10882
10881
  })[];
10883
10882
  details?: any;
10883
+ isError: true;
10884
10884
  };
10885
- status: "running";
10885
+ status: "aborted";
10886
10886
  thoughtSignature?: string;
10887
10887
  time: {
10888
10888
  start: number;
@@ -11075,14 +11075,19 @@ declare const Definitions: readonly [Schema.Struct<{
11075
11075
  type: "image";
11076
11076
  data: string;
11077
11077
  mimeType: string;
11078
+ } | {
11079
+ type: "thinking";
11080
+ thinking: string;
11081
+ thinkingSignature?: string;
11082
+ redacted?: boolean;
11078
11083
  } | {
11079
11084
  addedToolNames?: string[];
11080
11085
  arguments: Record<string, any>;
11081
11086
  callID: string;
11082
11087
  name: string;
11083
11088
  namespace?: string;
11084
- result: {
11085
- content: ({
11089
+ partial?: {
11090
+ content?: ({
11086
11091
  type: "text";
11087
11092
  text: string;
11088
11093
  textSignature?: string;
@@ -11092,9 +11097,8 @@ declare const Definitions: readonly [Schema.Struct<{
11092
11097
  mimeType: string;
11093
11098
  })[];
11094
11099
  details?: any;
11095
- isError: false;
11096
11100
  };
11097
- status: "completed";
11101
+ status: "running";
11098
11102
  thoughtSignature?: string;
11099
11103
  time: {
11100
11104
  start: number;
@@ -11118,9 +11122,9 @@ declare const Definitions: readonly [Schema.Struct<{
11118
11122
  mimeType: string;
11119
11123
  })[];
11120
11124
  details?: any;
11121
- isError: true;
11125
+ isError: false;
11122
11126
  };
11123
- status: "error";
11127
+ status: "completed";
11124
11128
  thoughtSignature?: string;
11125
11129
  time: {
11126
11130
  start: number;
@@ -11146,7 +11150,7 @@ declare const Definitions: readonly [Schema.Struct<{
11146
11150
  details?: any;
11147
11151
  isError: true;
11148
11152
  };
11149
- status: "skipped";
11153
+ status: "error";
11150
11154
  thoughtSignature?: string;
11151
11155
  time: {
11152
11156
  start: number;
@@ -11172,26 +11176,21 @@ declare const Definitions: readonly [Schema.Struct<{
11172
11176
  details?: any;
11173
11177
  isError: true;
11174
11178
  };
11175
- status: "aborted";
11179
+ status: "skipped";
11176
11180
  thoughtSignature?: string;
11177
11181
  time: {
11178
11182
  start: number;
11179
11183
  end: number;
11180
11184
  };
11181
11185
  type: "toolCall";
11182
- } | {
11183
- type: "thinking";
11184
- thinking: string;
11185
- thinkingSignature?: string;
11186
- redacted?: boolean;
11187
11186
  } | {
11188
11187
  addedToolNames?: string[];
11189
11188
  arguments: Record<string, any>;
11190
11189
  callID: string;
11191
11190
  name: string;
11192
11191
  namespace?: string;
11193
- partial?: {
11194
- content?: ({
11192
+ result: {
11193
+ content: ({
11195
11194
  type: "text";
11196
11195
  text: string;
11197
11196
  textSignature?: string;
@@ -11201,8 +11200,9 @@ declare const Definitions: readonly [Schema.Struct<{
11201
11200
  mimeType: string;
11202
11201
  })[];
11203
11202
  details?: any;
11203
+ isError: true;
11204
11204
  };
11205
- status: "running";
11205
+ status: "aborted";
11206
11206
  thoughtSignature?: string;
11207
11207
  time: {
11208
11208
  start: number;
@@ -11377,14 +11377,19 @@ declare const Definitions: readonly [Schema.Struct<{
11377
11377
  type: "image";
11378
11378
  data: string;
11379
11379
  mimeType: string;
11380
+ } | {
11381
+ type: "thinking";
11382
+ thinking: string;
11383
+ thinkingSignature?: string;
11384
+ redacted?: boolean;
11380
11385
  } | {
11381
11386
  addedToolNames?: string[];
11382
11387
  arguments: Record<string, any>;
11383
11388
  callID: string;
11384
11389
  name: string;
11385
11390
  namespace?: string;
11386
- result: {
11387
- content: ({
11391
+ partial?: {
11392
+ content?: ({
11388
11393
  type: "text";
11389
11394
  text: string;
11390
11395
  textSignature?: string;
@@ -11394,9 +11399,8 @@ declare const Definitions: readonly [Schema.Struct<{
11394
11399
  mimeType: string;
11395
11400
  })[];
11396
11401
  details?: any;
11397
- isError: false;
11398
11402
  };
11399
- status: "completed";
11403
+ status: "running";
11400
11404
  thoughtSignature?: string;
11401
11405
  time: {
11402
11406
  start: number;
@@ -11420,9 +11424,9 @@ declare const Definitions: readonly [Schema.Struct<{
11420
11424
  mimeType: string;
11421
11425
  })[];
11422
11426
  details?: any;
11423
- isError: true;
11427
+ isError: false;
11424
11428
  };
11425
- status: "error";
11429
+ status: "completed";
11426
11430
  thoughtSignature?: string;
11427
11431
  time: {
11428
11432
  start: number;
@@ -11448,7 +11452,7 @@ declare const Definitions: readonly [Schema.Struct<{
11448
11452
  details?: any;
11449
11453
  isError: true;
11450
11454
  };
11451
- status: "skipped";
11455
+ status: "error";
11452
11456
  thoughtSignature?: string;
11453
11457
  time: {
11454
11458
  start: number;
@@ -11474,26 +11478,21 @@ declare const Definitions: readonly [Schema.Struct<{
11474
11478
  details?: any;
11475
11479
  isError: true;
11476
11480
  };
11477
- status: "aborted";
11481
+ status: "skipped";
11478
11482
  thoughtSignature?: string;
11479
11483
  time: {
11480
11484
  start: number;
11481
11485
  end: number;
11482
11486
  };
11483
11487
  type: "toolCall";
11484
- } | {
11485
- type: "thinking";
11486
- thinking: string;
11487
- thinkingSignature?: string;
11488
- redacted?: boolean;
11489
11488
  } | {
11490
11489
  addedToolNames?: string[];
11491
11490
  arguments: Record<string, any>;
11492
11491
  callID: string;
11493
11492
  name: string;
11494
11493
  namespace?: string;
11495
- partial?: {
11496
- content?: ({
11494
+ result: {
11495
+ content: ({
11497
11496
  type: "text";
11498
11497
  text: string;
11499
11498
  textSignature?: string;
@@ -11503,8 +11502,9 @@ declare const Definitions: readonly [Schema.Struct<{
11503
11502
  mimeType: string;
11504
11503
  })[];
11505
11504
  details?: any;
11505
+ isError: true;
11506
11506
  };
11507
- status: "running";
11507
+ status: "aborted";
11508
11508
  thoughtSignature?: string;
11509
11509
  time: {
11510
11510
  start: number;
@@ -11985,14 +11985,19 @@ declare const Definitions: readonly [Schema.Struct<{
11985
11985
  type: "image";
11986
11986
  data: string;
11987
11987
  mimeType: string;
11988
+ } | {
11989
+ type: "thinking";
11990
+ thinking: string;
11991
+ thinkingSignature?: string;
11992
+ redacted?: boolean;
11988
11993
  } | {
11989
11994
  addedToolNames?: string[];
11990
11995
  arguments: Record<string, any>;
11991
11996
  callID: string;
11992
11997
  name: string;
11993
11998
  namespace?: string;
11994
- result: {
11995
- content: ({
11999
+ partial?: {
12000
+ content?: ({
11996
12001
  type: "text";
11997
12002
  text: string;
11998
12003
  textSignature?: string;
@@ -12002,9 +12007,8 @@ declare const Definitions: readonly [Schema.Struct<{
12002
12007
  mimeType: string;
12003
12008
  })[];
12004
12009
  details?: any;
12005
- isError: false;
12006
12010
  };
12007
- status: "completed";
12011
+ status: "running";
12008
12012
  thoughtSignature?: string;
12009
12013
  time: {
12010
12014
  start: number;
@@ -12028,9 +12032,9 @@ declare const Definitions: readonly [Schema.Struct<{
12028
12032
  mimeType: string;
12029
12033
  })[];
12030
12034
  details?: any;
12031
- isError: true;
12035
+ isError: false;
12032
12036
  };
12033
- status: "error";
12037
+ status: "completed";
12034
12038
  thoughtSignature?: string;
12035
12039
  time: {
12036
12040
  start: number;
@@ -12056,7 +12060,7 @@ declare const Definitions: readonly [Schema.Struct<{
12056
12060
  details?: any;
12057
12061
  isError: true;
12058
12062
  };
12059
- status: "skipped";
12063
+ status: "error";
12060
12064
  thoughtSignature?: string;
12061
12065
  time: {
12062
12066
  start: number;
@@ -12082,26 +12086,21 @@ declare const Definitions: readonly [Schema.Struct<{
12082
12086
  details?: any;
12083
12087
  isError: true;
12084
12088
  };
12085
- status: "aborted";
12089
+ status: "skipped";
12086
12090
  thoughtSignature?: string;
12087
12091
  time: {
12088
12092
  start: number;
12089
12093
  end: number;
12090
12094
  };
12091
12095
  type: "toolCall";
12092
- } | {
12093
- type: "thinking";
12094
- thinking: string;
12095
- thinkingSignature?: string;
12096
- redacted?: boolean;
12097
12096
  } | {
12098
12097
  addedToolNames?: string[];
12099
12098
  arguments: Record<string, any>;
12100
12099
  callID: string;
12101
12100
  name: string;
12102
12101
  namespace?: string;
12103
- partial?: {
12104
- content?: ({
12102
+ result: {
12103
+ content: ({
12105
12104
  type: "text";
12106
12105
  text: string;
12107
12106
  textSignature?: string;
@@ -12111,8 +12110,9 @@ declare const Definitions: readonly [Schema.Struct<{
12111
12110
  mimeType: string;
12112
12111
  })[];
12113
12112
  details?: any;
12113
+ isError: true;
12114
12114
  };
12115
- status: "running";
12115
+ status: "aborted";
12116
12116
  thoughtSignature?: string;
12117
12117
  time: {
12118
12118
  start: number;
@@ -12287,14 +12287,19 @@ declare const Definitions: readonly [Schema.Struct<{
12287
12287
  type: "image";
12288
12288
  data: string;
12289
12289
  mimeType: string;
12290
+ } | {
12291
+ type: "thinking";
12292
+ thinking: string;
12293
+ thinkingSignature?: string;
12294
+ redacted?: boolean;
12290
12295
  } | {
12291
12296
  addedToolNames?: string[];
12292
12297
  arguments: Record<string, any>;
12293
12298
  callID: string;
12294
12299
  name: string;
12295
12300
  namespace?: string;
12296
- result: {
12297
- content: ({
12301
+ partial?: {
12302
+ content?: ({
12298
12303
  type: "text";
12299
12304
  text: string;
12300
12305
  textSignature?: string;
@@ -12304,9 +12309,8 @@ declare const Definitions: readonly [Schema.Struct<{
12304
12309
  mimeType: string;
12305
12310
  })[];
12306
12311
  details?: any;
12307
- isError: false;
12308
12312
  };
12309
- status: "completed";
12313
+ status: "running";
12310
12314
  thoughtSignature?: string;
12311
12315
  time: {
12312
12316
  start: number;
@@ -12330,9 +12334,9 @@ declare const Definitions: readonly [Schema.Struct<{
12330
12334
  mimeType: string;
12331
12335
  })[];
12332
12336
  details?: any;
12333
- isError: true;
12337
+ isError: false;
12334
12338
  };
12335
- status: "error";
12339
+ status: "completed";
12336
12340
  thoughtSignature?: string;
12337
12341
  time: {
12338
12342
  start: number;
@@ -12358,7 +12362,7 @@ declare const Definitions: readonly [Schema.Struct<{
12358
12362
  details?: any;
12359
12363
  isError: true;
12360
12364
  };
12361
- status: "skipped";
12365
+ status: "error";
12362
12366
  thoughtSignature?: string;
12363
12367
  time: {
12364
12368
  start: number;
@@ -12384,26 +12388,21 @@ declare const Definitions: readonly [Schema.Struct<{
12384
12388
  details?: any;
12385
12389
  isError: true;
12386
12390
  };
12387
- status: "aborted";
12391
+ status: "skipped";
12388
12392
  thoughtSignature?: string;
12389
12393
  time: {
12390
12394
  start: number;
12391
12395
  end: number;
12392
12396
  };
12393
12397
  type: "toolCall";
12394
- } | {
12395
- type: "thinking";
12396
- thinking: string;
12397
- thinkingSignature?: string;
12398
- redacted?: boolean;
12399
12398
  } | {
12400
12399
  addedToolNames?: string[];
12401
12400
  arguments: Record<string, any>;
12402
12401
  callID: string;
12403
12402
  name: string;
12404
12403
  namespace?: string;
12405
- partial?: {
12406
- content?: ({
12404
+ result: {
12405
+ content: ({
12407
12406
  type: "text";
12408
12407
  text: string;
12409
12408
  textSignature?: string;
@@ -12413,8 +12412,9 @@ declare const Definitions: readonly [Schema.Struct<{
12413
12412
  mimeType: string;
12414
12413
  })[];
12415
12414
  details?: any;
12415
+ isError: true;
12416
12416
  };
12417
- status: "running";
12417
+ status: "aborted";
12418
12418
  thoughtSignature?: string;
12419
12419
  time: {
12420
12420
  start: number;
@@ -12608,14 +12608,19 @@ declare const Definitions: readonly [Schema.Struct<{
12608
12608
  type: "image";
12609
12609
  data: string;
12610
12610
  mimeType: string;
12611
+ } | {
12612
+ type: "thinking";
12613
+ thinking: string;
12614
+ thinkingSignature?: string;
12615
+ redacted?: boolean;
12611
12616
  } | {
12612
12617
  addedToolNames?: string[];
12613
12618
  arguments: Record<string, any>;
12614
12619
  callID: string;
12615
12620
  name: string;
12616
12621
  namespace?: string;
12617
- result: {
12618
- content: ({
12622
+ partial?: {
12623
+ content?: ({
12619
12624
  type: "text";
12620
12625
  text: string;
12621
12626
  textSignature?: string;
@@ -12625,9 +12630,8 @@ declare const Definitions: readonly [Schema.Struct<{
12625
12630
  mimeType: string;
12626
12631
  })[];
12627
12632
  details?: any;
12628
- isError: false;
12629
12633
  };
12630
- status: "completed";
12634
+ status: "running";
12631
12635
  thoughtSignature?: string;
12632
12636
  time: {
12633
12637
  start: number;
@@ -12651,9 +12655,9 @@ declare const Definitions: readonly [Schema.Struct<{
12651
12655
  mimeType: string;
12652
12656
  })[];
12653
12657
  details?: any;
12654
- isError: true;
12658
+ isError: false;
12655
12659
  };
12656
- status: "error";
12660
+ status: "completed";
12657
12661
  thoughtSignature?: string;
12658
12662
  time: {
12659
12663
  start: number;
@@ -12679,7 +12683,7 @@ declare const Definitions: readonly [Schema.Struct<{
12679
12683
  details?: any;
12680
12684
  isError: true;
12681
12685
  };
12682
- status: "skipped";
12686
+ status: "error";
12683
12687
  thoughtSignature?: string;
12684
12688
  time: {
12685
12689
  start: number;
@@ -12705,26 +12709,21 @@ declare const Definitions: readonly [Schema.Struct<{
12705
12709
  details?: any;
12706
12710
  isError: true;
12707
12711
  };
12708
- status: "aborted";
12712
+ status: "skipped";
12709
12713
  thoughtSignature?: string;
12710
12714
  time: {
12711
12715
  start: number;
12712
12716
  end: number;
12713
12717
  };
12714
12718
  type: "toolCall";
12715
- } | {
12716
- type: "thinking";
12717
- thinking: string;
12718
- thinkingSignature?: string;
12719
- redacted?: boolean;
12720
12719
  } | {
12721
12720
  addedToolNames?: string[];
12722
12721
  arguments: Record<string, any>;
12723
12722
  callID: string;
12724
12723
  name: string;
12725
12724
  namespace?: string;
12726
- partial?: {
12727
- content?: ({
12725
+ result: {
12726
+ content: ({
12728
12727
  type: "text";
12729
12728
  text: string;
12730
12729
  textSignature?: string;
@@ -12734,8 +12733,9 @@ declare const Definitions: readonly [Schema.Struct<{
12734
12733
  mimeType: string;
12735
12734
  })[];
12736
12735
  details?: any;
12736
+ isError: true;
12737
12737
  };
12738
- status: "running";
12738
+ status: "aborted";
12739
12739
  thoughtSignature?: string;
12740
12740
  time: {
12741
12741
  start: number;
@@ -12910,14 +12910,19 @@ declare const Definitions: readonly [Schema.Struct<{
12910
12910
  type: "image";
12911
12911
  data: string;
12912
12912
  mimeType: string;
12913
+ } | {
12914
+ type: "thinking";
12915
+ thinking: string;
12916
+ thinkingSignature?: string;
12917
+ redacted?: boolean;
12913
12918
  } | {
12914
12919
  addedToolNames?: string[];
12915
12920
  arguments: Record<string, any>;
12916
12921
  callID: string;
12917
12922
  name: string;
12918
12923
  namespace?: string;
12919
- result: {
12920
- content: ({
12924
+ partial?: {
12925
+ content?: ({
12921
12926
  type: "text";
12922
12927
  text: string;
12923
12928
  textSignature?: string;
@@ -12927,9 +12932,8 @@ declare const Definitions: readonly [Schema.Struct<{
12927
12932
  mimeType: string;
12928
12933
  })[];
12929
12934
  details?: any;
12930
- isError: false;
12931
12935
  };
12932
- status: "completed";
12936
+ status: "running";
12933
12937
  thoughtSignature?: string;
12934
12938
  time: {
12935
12939
  start: number;
@@ -12953,9 +12957,9 @@ declare const Definitions: readonly [Schema.Struct<{
12953
12957
  mimeType: string;
12954
12958
  })[];
12955
12959
  details?: any;
12956
- isError: true;
12960
+ isError: false;
12957
12961
  };
12958
- status: "error";
12962
+ status: "completed";
12959
12963
  thoughtSignature?: string;
12960
12964
  time: {
12961
12965
  start: number;
@@ -12981,7 +12985,7 @@ declare const Definitions: readonly [Schema.Struct<{
12981
12985
  details?: any;
12982
12986
  isError: true;
12983
12987
  };
12984
- status: "skipped";
12988
+ status: "error";
12985
12989
  thoughtSignature?: string;
12986
12990
  time: {
12987
12991
  start: number;
@@ -13007,26 +13011,21 @@ declare const Definitions: readonly [Schema.Struct<{
13007
13011
  details?: any;
13008
13012
  isError: true;
13009
13013
  };
13010
- status: "aborted";
13014
+ status: "skipped";
13011
13015
  thoughtSignature?: string;
13012
13016
  time: {
13013
13017
  start: number;
13014
13018
  end: number;
13015
13019
  };
13016
13020
  type: "toolCall";
13017
- } | {
13018
- type: "thinking";
13019
- thinking: string;
13020
- thinkingSignature?: string;
13021
- redacted?: boolean;
13022
13021
  } | {
13023
13022
  addedToolNames?: string[];
13024
13023
  arguments: Record<string, any>;
13025
13024
  callID: string;
13026
13025
  name: string;
13027
13026
  namespace?: string;
13028
- partial?: {
13029
- content?: ({
13027
+ result: {
13028
+ content: ({
13030
13029
  type: "text";
13031
13030
  text: string;
13032
13031
  textSignature?: string;
@@ -13036,8 +13035,9 @@ declare const Definitions: readonly [Schema.Struct<{
13036
13035
  mimeType: string;
13037
13036
  })[];
13038
13037
  details?: any;
13038
+ isError: true;
13039
13039
  };
13040
- status: "running";
13040
+ status: "aborted";
13041
13041
  thoughtSignature?: string;
13042
13042
  time: {
13043
13043
  start: number;
@@ -13240,14 +13240,19 @@ declare const Definitions: readonly [Schema.Struct<{
13240
13240
  type: "image";
13241
13241
  data: string;
13242
13242
  mimeType: string;
13243
+ } | {
13244
+ type: "thinking";
13245
+ thinking: string;
13246
+ thinkingSignature?: string;
13247
+ redacted?: boolean;
13243
13248
  } | {
13244
13249
  addedToolNames?: string[];
13245
13250
  arguments: Record<string, any>;
13246
13251
  callID: string;
13247
13252
  name: string;
13248
13253
  namespace?: string;
13249
- result: {
13250
- content: ({
13254
+ partial?: {
13255
+ content?: ({
13251
13256
  type: "text";
13252
13257
  text: string;
13253
13258
  textSignature?: string;
@@ -13257,9 +13262,8 @@ declare const Definitions: readonly [Schema.Struct<{
13257
13262
  mimeType: string;
13258
13263
  })[];
13259
13264
  details?: any;
13260
- isError: false;
13261
13265
  };
13262
- status: "completed";
13266
+ status: "running";
13263
13267
  thoughtSignature?: string;
13264
13268
  time: {
13265
13269
  start: number;
@@ -13283,9 +13287,9 @@ declare const Definitions: readonly [Schema.Struct<{
13283
13287
  mimeType: string;
13284
13288
  })[];
13285
13289
  details?: any;
13286
- isError: true;
13290
+ isError: false;
13287
13291
  };
13288
- status: "error";
13292
+ status: "completed";
13289
13293
  thoughtSignature?: string;
13290
13294
  time: {
13291
13295
  start: number;
@@ -13311,7 +13315,7 @@ declare const Definitions: readonly [Schema.Struct<{
13311
13315
  details?: any;
13312
13316
  isError: true;
13313
13317
  };
13314
- status: "skipped";
13318
+ status: "error";
13315
13319
  thoughtSignature?: string;
13316
13320
  time: {
13317
13321
  start: number;
@@ -13337,26 +13341,21 @@ declare const Definitions: readonly [Schema.Struct<{
13337
13341
  details?: any;
13338
13342
  isError: true;
13339
13343
  };
13340
- status: "aborted";
13344
+ status: "skipped";
13341
13345
  thoughtSignature?: string;
13342
13346
  time: {
13343
13347
  start: number;
13344
13348
  end: number;
13345
13349
  };
13346
13350
  type: "toolCall";
13347
- } | {
13348
- type: "thinking";
13349
- thinking: string;
13350
- thinkingSignature?: string;
13351
- redacted?: boolean;
13352
13351
  } | {
13353
13352
  addedToolNames?: string[];
13354
13353
  arguments: Record<string, any>;
13355
13354
  callID: string;
13356
13355
  name: string;
13357
13356
  namespace?: string;
13358
- partial?: {
13359
- content?: ({
13357
+ result: {
13358
+ content: ({
13360
13359
  type: "text";
13361
13360
  text: string;
13362
13361
  textSignature?: string;
@@ -13366,8 +13365,9 @@ declare const Definitions: readonly [Schema.Struct<{
13366
13365
  mimeType: string;
13367
13366
  })[];
13368
13367
  details?: any;
13368
+ isError: true;
13369
13369
  };
13370
- status: "running";
13370
+ status: "aborted";
13371
13371
  thoughtSignature?: string;
13372
13372
  time: {
13373
13373
  start: number;
@@ -13542,14 +13542,19 @@ declare const Definitions: readonly [Schema.Struct<{
13542
13542
  type: "image";
13543
13543
  data: string;
13544
13544
  mimeType: string;
13545
+ } | {
13546
+ type: "thinking";
13547
+ thinking: string;
13548
+ thinkingSignature?: string;
13549
+ redacted?: boolean;
13545
13550
  } | {
13546
13551
  addedToolNames?: string[];
13547
13552
  arguments: Record<string, any>;
13548
13553
  callID: string;
13549
13554
  name: string;
13550
13555
  namespace?: string;
13551
- result: {
13552
- content: ({
13556
+ partial?: {
13557
+ content?: ({
13553
13558
  type: "text";
13554
13559
  text: string;
13555
13560
  textSignature?: string;
@@ -13559,9 +13564,8 @@ declare const Definitions: readonly [Schema.Struct<{
13559
13564
  mimeType: string;
13560
13565
  })[];
13561
13566
  details?: any;
13562
- isError: false;
13563
13567
  };
13564
- status: "completed";
13568
+ status: "running";
13565
13569
  thoughtSignature?: string;
13566
13570
  time: {
13567
13571
  start: number;
@@ -13585,9 +13589,9 @@ declare const Definitions: readonly [Schema.Struct<{
13585
13589
  mimeType: string;
13586
13590
  })[];
13587
13591
  details?: any;
13588
- isError: true;
13592
+ isError: false;
13589
13593
  };
13590
- status: "error";
13594
+ status: "completed";
13591
13595
  thoughtSignature?: string;
13592
13596
  time: {
13593
13597
  start: number;
@@ -13613,7 +13617,7 @@ declare const Definitions: readonly [Schema.Struct<{
13613
13617
  details?: any;
13614
13618
  isError: true;
13615
13619
  };
13616
- status: "skipped";
13620
+ status: "error";
13617
13621
  thoughtSignature?: string;
13618
13622
  time: {
13619
13623
  start: number;
@@ -13639,26 +13643,21 @@ declare const Definitions: readonly [Schema.Struct<{
13639
13643
  details?: any;
13640
13644
  isError: true;
13641
13645
  };
13642
- status: "aborted";
13646
+ status: "skipped";
13643
13647
  thoughtSignature?: string;
13644
13648
  time: {
13645
13649
  start: number;
13646
13650
  end: number;
13647
13651
  };
13648
13652
  type: "toolCall";
13649
- } | {
13650
- type: "thinking";
13651
- thinking: string;
13652
- thinkingSignature?: string;
13653
- redacted?: boolean;
13654
13653
  } | {
13655
13654
  addedToolNames?: string[];
13656
13655
  arguments: Record<string, any>;
13657
13656
  callID: string;
13658
13657
  name: string;
13659
13658
  namespace?: string;
13660
- partial?: {
13661
- content?: ({
13659
+ result: {
13660
+ content: ({
13662
13661
  type: "text";
13663
13662
  text: string;
13664
13663
  textSignature?: string;
@@ -13668,8 +13667,9 @@ declare const Definitions: readonly [Schema.Struct<{
13668
13667
  mimeType: string;
13669
13668
  })[];
13670
13669
  details?: any;
13670
+ isError: true;
13671
13671
  };
13672
- status: "running";
13672
+ status: "aborted";
13673
13673
  thoughtSignature?: string;
13674
13674
  time: {
13675
13675
  start: number;
@@ -13863,14 +13863,19 @@ declare const Definitions: readonly [Schema.Struct<{
13863
13863
  type: "image";
13864
13864
  data: string;
13865
13865
  mimeType: string;
13866
+ } | {
13867
+ type: "thinking";
13868
+ thinking: string;
13869
+ thinkingSignature?: string;
13870
+ redacted?: boolean;
13866
13871
  } | {
13867
13872
  addedToolNames?: string[];
13868
13873
  arguments: Record<string, any>;
13869
13874
  callID: string;
13870
13875
  name: string;
13871
13876
  namespace?: string;
13872
- result: {
13873
- content: ({
13877
+ partial?: {
13878
+ content?: ({
13874
13879
  type: "text";
13875
13880
  text: string;
13876
13881
  textSignature?: string;
@@ -13880,9 +13885,8 @@ declare const Definitions: readonly [Schema.Struct<{
13880
13885
  mimeType: string;
13881
13886
  })[];
13882
13887
  details?: any;
13883
- isError: false;
13884
13888
  };
13885
- status: "completed";
13889
+ status: "running";
13886
13890
  thoughtSignature?: string;
13887
13891
  time: {
13888
13892
  start: number;
@@ -13906,9 +13910,9 @@ declare const Definitions: readonly [Schema.Struct<{
13906
13910
  mimeType: string;
13907
13911
  })[];
13908
13912
  details?: any;
13909
- isError: true;
13913
+ isError: false;
13910
13914
  };
13911
- status: "error";
13915
+ status: "completed";
13912
13916
  thoughtSignature?: string;
13913
13917
  time: {
13914
13918
  start: number;
@@ -13934,7 +13938,7 @@ declare const Definitions: readonly [Schema.Struct<{
13934
13938
  details?: any;
13935
13939
  isError: true;
13936
13940
  };
13937
- status: "skipped";
13941
+ status: "error";
13938
13942
  thoughtSignature?: string;
13939
13943
  time: {
13940
13944
  start: number;
@@ -13960,26 +13964,21 @@ declare const Definitions: readonly [Schema.Struct<{
13960
13964
  details?: any;
13961
13965
  isError: true;
13962
13966
  };
13963
- status: "aborted";
13967
+ status: "skipped";
13964
13968
  thoughtSignature?: string;
13965
13969
  time: {
13966
13970
  start: number;
13967
13971
  end: number;
13968
13972
  };
13969
13973
  type: "toolCall";
13970
- } | {
13971
- type: "thinking";
13972
- thinking: string;
13973
- thinkingSignature?: string;
13974
- redacted?: boolean;
13975
13974
  } | {
13976
13975
  addedToolNames?: string[];
13977
13976
  arguments: Record<string, any>;
13978
13977
  callID: string;
13979
13978
  name: string;
13980
13979
  namespace?: string;
13981
- partial?: {
13982
- content?: ({
13980
+ result: {
13981
+ content: ({
13983
13982
  type: "text";
13984
13983
  text: string;
13985
13984
  textSignature?: string;
@@ -13989,8 +13988,9 @@ declare const Definitions: readonly [Schema.Struct<{
13989
13988
  mimeType: string;
13990
13989
  })[];
13991
13990
  details?: any;
13991
+ isError: true;
13992
13992
  };
13993
- status: "running";
13993
+ status: "aborted";
13994
13994
  thoughtSignature?: string;
13995
13995
  time: {
13996
13996
  start: number;
@@ -14165,14 +14165,19 @@ declare const Definitions: readonly [Schema.Struct<{
14165
14165
  type: "image";
14166
14166
  data: string;
14167
14167
  mimeType: string;
14168
+ } | {
14169
+ type: "thinking";
14170
+ thinking: string;
14171
+ thinkingSignature?: string;
14172
+ redacted?: boolean;
14168
14173
  } | {
14169
14174
  addedToolNames?: string[];
14170
14175
  arguments: Record<string, any>;
14171
14176
  callID: string;
14172
14177
  name: string;
14173
14178
  namespace?: string;
14174
- result: {
14175
- content: ({
14179
+ partial?: {
14180
+ content?: ({
14176
14181
  type: "text";
14177
14182
  text: string;
14178
14183
  textSignature?: string;
@@ -14182,9 +14187,8 @@ declare const Definitions: readonly [Schema.Struct<{
14182
14187
  mimeType: string;
14183
14188
  })[];
14184
14189
  details?: any;
14185
- isError: false;
14186
14190
  };
14187
- status: "completed";
14191
+ status: "running";
14188
14192
  thoughtSignature?: string;
14189
14193
  time: {
14190
14194
  start: number;
@@ -14208,9 +14212,9 @@ declare const Definitions: readonly [Schema.Struct<{
14208
14212
  mimeType: string;
14209
14213
  })[];
14210
14214
  details?: any;
14211
- isError: true;
14215
+ isError: false;
14212
14216
  };
14213
- status: "error";
14217
+ status: "completed";
14214
14218
  thoughtSignature?: string;
14215
14219
  time: {
14216
14220
  start: number;
@@ -14236,7 +14240,7 @@ declare const Definitions: readonly [Schema.Struct<{
14236
14240
  details?: any;
14237
14241
  isError: true;
14238
14242
  };
14239
- status: "skipped";
14243
+ status: "error";
14240
14244
  thoughtSignature?: string;
14241
14245
  time: {
14242
14246
  start: number;
@@ -14262,26 +14266,21 @@ declare const Definitions: readonly [Schema.Struct<{
14262
14266
  details?: any;
14263
14267
  isError: true;
14264
14268
  };
14265
- status: "aborted";
14269
+ status: "skipped";
14266
14270
  thoughtSignature?: string;
14267
14271
  time: {
14268
14272
  start: number;
14269
14273
  end: number;
14270
14274
  };
14271
14275
  type: "toolCall";
14272
- } | {
14273
- type: "thinking";
14274
- thinking: string;
14275
- thinkingSignature?: string;
14276
- redacted?: boolean;
14277
14276
  } | {
14278
14277
  addedToolNames?: string[];
14279
14278
  arguments: Record<string, any>;
14280
14279
  callID: string;
14281
14280
  name: string;
14282
14281
  namespace?: string;
14283
- partial?: {
14284
- content?: ({
14282
+ result: {
14283
+ content: ({
14285
14284
  type: "text";
14286
14285
  text: string;
14287
14286
  textSignature?: string;
@@ -14291,8 +14290,9 @@ declare const Definitions: readonly [Schema.Struct<{
14291
14290
  mimeType: string;
14292
14291
  })[];
14293
14292
  details?: any;
14293
+ isError: true;
14294
14294
  };
14295
- status: "running";
14295
+ status: "aborted";
14296
14296
  thoughtSignature?: string;
14297
14297
  time: {
14298
14298
  start: number;
@@ -15801,14 +15801,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15801
15801
  type: "image";
15802
15802
  data: string;
15803
15803
  mimeType: string;
15804
+ } | {
15805
+ type: "thinking";
15806
+ thinking: string;
15807
+ thinkingSignature?: string;
15808
+ redacted?: boolean;
15804
15809
  } | {
15805
15810
  addedToolNames?: string[];
15806
15811
  arguments: Record<string, any>;
15807
15812
  callID: string;
15808
15813
  name: string;
15809
15814
  namespace?: string;
15810
- result: {
15811
- content: ({
15815
+ partial?: {
15816
+ content?: ({
15812
15817
  type: "text";
15813
15818
  text: string;
15814
15819
  textSignature?: string;
@@ -15818,9 +15823,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15818
15823
  mimeType: string;
15819
15824
  })[];
15820
15825
  details?: any;
15821
- isError: false;
15822
15826
  };
15823
- status: "completed";
15827
+ status: "running";
15824
15828
  thoughtSignature?: string;
15825
15829
  time: {
15826
15830
  start: number;
@@ -15844,9 +15848,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15844
15848
  mimeType: string;
15845
15849
  })[];
15846
15850
  details?: any;
15847
- isError: true;
15851
+ isError: false;
15848
15852
  };
15849
- status: "error";
15853
+ status: "completed";
15850
15854
  thoughtSignature?: string;
15851
15855
  time: {
15852
15856
  start: number;
@@ -15872,7 +15876,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15872
15876
  details?: any;
15873
15877
  isError: true;
15874
15878
  };
15875
- status: "skipped";
15879
+ status: "error";
15876
15880
  thoughtSignature?: string;
15877
15881
  time: {
15878
15882
  start: number;
@@ -15898,26 +15902,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15898
15902
  details?: any;
15899
15903
  isError: true;
15900
15904
  };
15901
- status: "aborted";
15905
+ status: "skipped";
15902
15906
  thoughtSignature?: string;
15903
15907
  time: {
15904
15908
  start: number;
15905
15909
  end: number;
15906
15910
  };
15907
15911
  type: "toolCall";
15908
- } | {
15909
- type: "thinking";
15910
- thinking: string;
15911
- thinkingSignature?: string;
15912
- redacted?: boolean;
15913
15912
  } | {
15914
15913
  addedToolNames?: string[];
15915
15914
  arguments: Record<string, any>;
15916
15915
  callID: string;
15917
15916
  name: string;
15918
15917
  namespace?: string;
15919
- partial?: {
15920
- content?: ({
15918
+ result: {
15919
+ content: ({
15921
15920
  type: "text";
15922
15921
  text: string;
15923
15922
  textSignature?: string;
@@ -15927,8 +15926,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15927
15926
  mimeType: string;
15928
15927
  })[];
15929
15928
  details?: any;
15929
+ isError: true;
15930
15930
  };
15931
- status: "running";
15931
+ status: "aborted";
15932
15932
  thoughtSignature?: string;
15933
15933
  time: {
15934
15934
  start: number;
@@ -16103,14 +16103,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16103
16103
  type: "image";
16104
16104
  data: string;
16105
16105
  mimeType: string;
16106
+ } | {
16107
+ type: "thinking";
16108
+ thinking: string;
16109
+ thinkingSignature?: string;
16110
+ redacted?: boolean;
16106
16111
  } | {
16107
16112
  addedToolNames?: string[];
16108
16113
  arguments: Record<string, any>;
16109
16114
  callID: string;
16110
16115
  name: string;
16111
16116
  namespace?: string;
16112
- result: {
16113
- content: ({
16117
+ partial?: {
16118
+ content?: ({
16114
16119
  type: "text";
16115
16120
  text: string;
16116
16121
  textSignature?: string;
@@ -16120,9 +16125,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16120
16125
  mimeType: string;
16121
16126
  })[];
16122
16127
  details?: any;
16123
- isError: false;
16124
16128
  };
16125
- status: "completed";
16129
+ status: "running";
16126
16130
  thoughtSignature?: string;
16127
16131
  time: {
16128
16132
  start: number;
@@ -16146,9 +16150,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16146
16150
  mimeType: string;
16147
16151
  })[];
16148
16152
  details?: any;
16149
- isError: true;
16153
+ isError: false;
16150
16154
  };
16151
- status: "error";
16155
+ status: "completed";
16152
16156
  thoughtSignature?: string;
16153
16157
  time: {
16154
16158
  start: number;
@@ -16174,7 +16178,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16174
16178
  details?: any;
16175
16179
  isError: true;
16176
16180
  };
16177
- status: "skipped";
16181
+ status: "error";
16178
16182
  thoughtSignature?: string;
16179
16183
  time: {
16180
16184
  start: number;
@@ -16200,26 +16204,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16200
16204
  details?: any;
16201
16205
  isError: true;
16202
16206
  };
16203
- status: "aborted";
16207
+ status: "skipped";
16204
16208
  thoughtSignature?: string;
16205
16209
  time: {
16206
16210
  start: number;
16207
16211
  end: number;
16208
16212
  };
16209
16213
  type: "toolCall";
16210
- } | {
16211
- type: "thinking";
16212
- thinking: string;
16213
- thinkingSignature?: string;
16214
- redacted?: boolean;
16215
16214
  } | {
16216
16215
  addedToolNames?: string[];
16217
16216
  arguments: Record<string, any>;
16218
16217
  callID: string;
16219
16218
  name: string;
16220
16219
  namespace?: string;
16221
- partial?: {
16222
- content?: ({
16220
+ result: {
16221
+ content: ({
16223
16222
  type: "text";
16224
16223
  text: string;
16225
16224
  textSignature?: string;
@@ -16229,8 +16228,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16229
16228
  mimeType: string;
16230
16229
  })[];
16231
16230
  details?: any;
16231
+ isError: true;
16232
16232
  };
16233
- status: "running";
16233
+ status: "aborted";
16234
16234
  thoughtSignature?: string;
16235
16235
  time: {
16236
16236
  start: number;
@@ -16423,14 +16423,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16423
16423
  type: "image";
16424
16424
  data: string;
16425
16425
  mimeType: string;
16426
+ } | {
16427
+ type: "thinking";
16428
+ thinking: string;
16429
+ thinkingSignature?: string;
16430
+ redacted?: boolean;
16426
16431
  } | {
16427
16432
  addedToolNames?: string[];
16428
16433
  arguments: Record<string, any>;
16429
16434
  callID: string;
16430
16435
  name: string;
16431
16436
  namespace?: string;
16432
- result: {
16433
- content: ({
16437
+ partial?: {
16438
+ content?: ({
16434
16439
  type: "text";
16435
16440
  text: string;
16436
16441
  textSignature?: string;
@@ -16440,9 +16445,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16440
16445
  mimeType: string;
16441
16446
  })[];
16442
16447
  details?: any;
16443
- isError: false;
16444
16448
  };
16445
- status: "completed";
16449
+ status: "running";
16446
16450
  thoughtSignature?: string;
16447
16451
  time: {
16448
16452
  start: number;
@@ -16466,9 +16470,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16466
16470
  mimeType: string;
16467
16471
  })[];
16468
16472
  details?: any;
16469
- isError: true;
16473
+ isError: false;
16470
16474
  };
16471
- status: "error";
16475
+ status: "completed";
16472
16476
  thoughtSignature?: string;
16473
16477
  time: {
16474
16478
  start: number;
@@ -16494,7 +16498,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16494
16498
  details?: any;
16495
16499
  isError: true;
16496
16500
  };
16497
- status: "skipped";
16501
+ status: "error";
16498
16502
  thoughtSignature?: string;
16499
16503
  time: {
16500
16504
  start: number;
@@ -16520,26 +16524,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16520
16524
  details?: any;
16521
16525
  isError: true;
16522
16526
  };
16523
- status: "aborted";
16527
+ status: "skipped";
16524
16528
  thoughtSignature?: string;
16525
16529
  time: {
16526
16530
  start: number;
16527
16531
  end: number;
16528
16532
  };
16529
16533
  type: "toolCall";
16530
- } | {
16531
- type: "thinking";
16532
- thinking: string;
16533
- thinkingSignature?: string;
16534
- redacted?: boolean;
16535
16534
  } | {
16536
16535
  addedToolNames?: string[];
16537
16536
  arguments: Record<string, any>;
16538
16537
  callID: string;
16539
16538
  name: string;
16540
16539
  namespace?: string;
16541
- partial?: {
16542
- content?: ({
16540
+ result: {
16541
+ content: ({
16543
16542
  type: "text";
16544
16543
  text: string;
16545
16544
  textSignature?: string;
@@ -16549,8 +16548,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16549
16548
  mimeType: string;
16550
16549
  })[];
16551
16550
  details?: any;
16551
+ isError: true;
16552
16552
  };
16553
- status: "running";
16553
+ status: "aborted";
16554
16554
  thoughtSignature?: string;
16555
16555
  time: {
16556
16556
  start: number;
@@ -16725,14 +16725,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16725
16725
  type: "image";
16726
16726
  data: string;
16727
16727
  mimeType: string;
16728
+ } | {
16729
+ type: "thinking";
16730
+ thinking: string;
16731
+ thinkingSignature?: string;
16732
+ redacted?: boolean;
16728
16733
  } | {
16729
16734
  addedToolNames?: string[];
16730
16735
  arguments: Record<string, any>;
16731
16736
  callID: string;
16732
16737
  name: string;
16733
16738
  namespace?: string;
16734
- result: {
16735
- content: ({
16739
+ partial?: {
16740
+ content?: ({
16736
16741
  type: "text";
16737
16742
  text: string;
16738
16743
  textSignature?: string;
@@ -16742,9 +16747,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16742
16747
  mimeType: string;
16743
16748
  })[];
16744
16749
  details?: any;
16745
- isError: false;
16746
16750
  };
16747
- status: "completed";
16751
+ status: "running";
16748
16752
  thoughtSignature?: string;
16749
16753
  time: {
16750
16754
  start: number;
@@ -16768,9 +16772,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16768
16772
  mimeType: string;
16769
16773
  })[];
16770
16774
  details?: any;
16771
- isError: true;
16775
+ isError: false;
16772
16776
  };
16773
- status: "error";
16777
+ status: "completed";
16774
16778
  thoughtSignature?: string;
16775
16779
  time: {
16776
16780
  start: number;
@@ -16796,7 +16800,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16796
16800
  details?: any;
16797
16801
  isError: true;
16798
16802
  };
16799
- status: "skipped";
16803
+ status: "error";
16800
16804
  thoughtSignature?: string;
16801
16805
  time: {
16802
16806
  start: number;
@@ -16822,26 +16826,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16822
16826
  details?: any;
16823
16827
  isError: true;
16824
16828
  };
16825
- status: "aborted";
16829
+ status: "skipped";
16826
16830
  thoughtSignature?: string;
16827
16831
  time: {
16828
16832
  start: number;
16829
16833
  end: number;
16830
16834
  };
16831
16835
  type: "toolCall";
16832
- } | {
16833
- type: "thinking";
16834
- thinking: string;
16835
- thinkingSignature?: string;
16836
- redacted?: boolean;
16837
16836
  } | {
16838
16837
  addedToolNames?: string[];
16839
16838
  arguments: Record<string, any>;
16840
16839
  callID: string;
16841
16840
  name: string;
16842
16841
  namespace?: string;
16843
- partial?: {
16844
- content?: ({
16842
+ result: {
16843
+ content: ({
16845
16844
  type: "text";
16846
16845
  text: string;
16847
16846
  textSignature?: string;
@@ -16851,8 +16850,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16851
16850
  mimeType: string;
16852
16851
  })[];
16853
16852
  details?: any;
16853
+ isError: true;
16854
16854
  };
16855
- status: "running";
16855
+ status: "aborted";
16856
16856
  thoughtSignature?: string;
16857
16857
  time: {
16858
16858
  start: number;
@@ -17333,14 +17333,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17333
17333
  type: "image";
17334
17334
  data: string;
17335
17335
  mimeType: string;
17336
+ } | {
17337
+ type: "thinking";
17338
+ thinking: string;
17339
+ thinkingSignature?: string;
17340
+ redacted?: boolean;
17336
17341
  } | {
17337
17342
  addedToolNames?: string[];
17338
17343
  arguments: Record<string, any>;
17339
17344
  callID: string;
17340
17345
  name: string;
17341
17346
  namespace?: string;
17342
- result: {
17343
- content: ({
17347
+ partial?: {
17348
+ content?: ({
17344
17349
  type: "text";
17345
17350
  text: string;
17346
17351
  textSignature?: string;
@@ -17350,9 +17355,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17350
17355
  mimeType: string;
17351
17356
  })[];
17352
17357
  details?: any;
17353
- isError: false;
17354
17358
  };
17355
- status: "completed";
17359
+ status: "running";
17356
17360
  thoughtSignature?: string;
17357
17361
  time: {
17358
17362
  start: number;
@@ -17376,9 +17380,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17376
17380
  mimeType: string;
17377
17381
  })[];
17378
17382
  details?: any;
17379
- isError: true;
17383
+ isError: false;
17380
17384
  };
17381
- status: "error";
17385
+ status: "completed";
17382
17386
  thoughtSignature?: string;
17383
17387
  time: {
17384
17388
  start: number;
@@ -17404,7 +17408,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17404
17408
  details?: any;
17405
17409
  isError: true;
17406
17410
  };
17407
- status: "skipped";
17411
+ status: "error";
17408
17412
  thoughtSignature?: string;
17409
17413
  time: {
17410
17414
  start: number;
@@ -17430,26 +17434,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17430
17434
  details?: any;
17431
17435
  isError: true;
17432
17436
  };
17433
- status: "aborted";
17437
+ status: "skipped";
17434
17438
  thoughtSignature?: string;
17435
17439
  time: {
17436
17440
  start: number;
17437
17441
  end: number;
17438
17442
  };
17439
17443
  type: "toolCall";
17440
- } | {
17441
- type: "thinking";
17442
- thinking: string;
17443
- thinkingSignature?: string;
17444
- redacted?: boolean;
17445
17444
  } | {
17446
17445
  addedToolNames?: string[];
17447
17446
  arguments: Record<string, any>;
17448
17447
  callID: string;
17449
17448
  name: string;
17450
17449
  namespace?: string;
17451
- partial?: {
17452
- content?: ({
17450
+ result: {
17451
+ content: ({
17453
17452
  type: "text";
17454
17453
  text: string;
17455
17454
  textSignature?: string;
@@ -17459,8 +17458,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17459
17458
  mimeType: string;
17460
17459
  })[];
17461
17460
  details?: any;
17461
+ isError: true;
17462
17462
  };
17463
- status: "running";
17463
+ status: "aborted";
17464
17464
  thoughtSignature?: string;
17465
17465
  time: {
17466
17466
  start: number;
@@ -17635,14 +17635,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17635
17635
  type: "image";
17636
17636
  data: string;
17637
17637
  mimeType: string;
17638
+ } | {
17639
+ type: "thinking";
17640
+ thinking: string;
17641
+ thinkingSignature?: string;
17642
+ redacted?: boolean;
17638
17643
  } | {
17639
17644
  addedToolNames?: string[];
17640
17645
  arguments: Record<string, any>;
17641
17646
  callID: string;
17642
17647
  name: string;
17643
17648
  namespace?: string;
17644
- result: {
17645
- content: ({
17649
+ partial?: {
17650
+ content?: ({
17646
17651
  type: "text";
17647
17652
  text: string;
17648
17653
  textSignature?: string;
@@ -17652,9 +17657,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17652
17657
  mimeType: string;
17653
17658
  })[];
17654
17659
  details?: any;
17655
- isError: false;
17656
17660
  };
17657
- status: "completed";
17661
+ status: "running";
17658
17662
  thoughtSignature?: string;
17659
17663
  time: {
17660
17664
  start: number;
@@ -17678,9 +17682,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17678
17682
  mimeType: string;
17679
17683
  })[];
17680
17684
  details?: any;
17681
- isError: true;
17685
+ isError: false;
17682
17686
  };
17683
- status: "error";
17687
+ status: "completed";
17684
17688
  thoughtSignature?: string;
17685
17689
  time: {
17686
17690
  start: number;
@@ -17706,7 +17710,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17706
17710
  details?: any;
17707
17711
  isError: true;
17708
17712
  };
17709
- status: "skipped";
17713
+ status: "error";
17710
17714
  thoughtSignature?: string;
17711
17715
  time: {
17712
17716
  start: number;
@@ -17732,26 +17736,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17732
17736
  details?: any;
17733
17737
  isError: true;
17734
17738
  };
17735
- status: "aborted";
17739
+ status: "skipped";
17736
17740
  thoughtSignature?: string;
17737
17741
  time: {
17738
17742
  start: number;
17739
17743
  end: number;
17740
17744
  };
17741
17745
  type: "toolCall";
17742
- } | {
17743
- type: "thinking";
17744
- thinking: string;
17745
- thinkingSignature?: string;
17746
- redacted?: boolean;
17747
17746
  } | {
17748
17747
  addedToolNames?: string[];
17749
17748
  arguments: Record<string, any>;
17750
17749
  callID: string;
17751
17750
  name: string;
17752
17751
  namespace?: string;
17753
- partial?: {
17754
- content?: ({
17752
+ result: {
17753
+ content: ({
17755
17754
  type: "text";
17756
17755
  text: string;
17757
17756
  textSignature?: string;
@@ -17761,8 +17760,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17761
17760
  mimeType: string;
17762
17761
  })[];
17763
17762
  details?: any;
17763
+ isError: true;
17764
17764
  };
17765
- status: "running";
17765
+ status: "aborted";
17766
17766
  thoughtSignature?: string;
17767
17767
  time: {
17768
17768
  start: number;
@@ -17956,14 +17956,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17956
17956
  type: "image";
17957
17957
  data: string;
17958
17958
  mimeType: string;
17959
+ } | {
17960
+ type: "thinking";
17961
+ thinking: string;
17962
+ thinkingSignature?: string;
17963
+ redacted?: boolean;
17959
17964
  } | {
17960
17965
  addedToolNames?: string[];
17961
17966
  arguments: Record<string, any>;
17962
17967
  callID: string;
17963
17968
  name: string;
17964
17969
  namespace?: string;
17965
- result: {
17966
- content: ({
17970
+ partial?: {
17971
+ content?: ({
17967
17972
  type: "text";
17968
17973
  text: string;
17969
17974
  textSignature?: string;
@@ -17973,9 +17978,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17973
17978
  mimeType: string;
17974
17979
  })[];
17975
17980
  details?: any;
17976
- isError: false;
17977
17981
  };
17978
- status: "completed";
17982
+ status: "running";
17979
17983
  thoughtSignature?: string;
17980
17984
  time: {
17981
17985
  start: number;
@@ -17999,9 +18003,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17999
18003
  mimeType: string;
18000
18004
  })[];
18001
18005
  details?: any;
18002
- isError: true;
18006
+ isError: false;
18003
18007
  };
18004
- status: "error";
18008
+ status: "completed";
18005
18009
  thoughtSignature?: string;
18006
18010
  time: {
18007
18011
  start: number;
@@ -18027,7 +18031,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18027
18031
  details?: any;
18028
18032
  isError: true;
18029
18033
  };
18030
- status: "skipped";
18034
+ status: "error";
18031
18035
  thoughtSignature?: string;
18032
18036
  time: {
18033
18037
  start: number;
@@ -18053,26 +18057,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18053
18057
  details?: any;
18054
18058
  isError: true;
18055
18059
  };
18056
- status: "aborted";
18060
+ status: "skipped";
18057
18061
  thoughtSignature?: string;
18058
18062
  time: {
18059
18063
  start: number;
18060
18064
  end: number;
18061
18065
  };
18062
18066
  type: "toolCall";
18063
- } | {
18064
- type: "thinking";
18065
- thinking: string;
18066
- thinkingSignature?: string;
18067
- redacted?: boolean;
18068
18067
  } | {
18069
18068
  addedToolNames?: string[];
18070
18069
  arguments: Record<string, any>;
18071
18070
  callID: string;
18072
18071
  name: string;
18073
18072
  namespace?: string;
18074
- partial?: {
18075
- content?: ({
18073
+ result: {
18074
+ content: ({
18076
18075
  type: "text";
18077
18076
  text: string;
18078
18077
  textSignature?: string;
@@ -18082,8 +18081,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18082
18081
  mimeType: string;
18083
18082
  })[];
18084
18083
  details?: any;
18084
+ isError: true;
18085
18085
  };
18086
- status: "running";
18086
+ status: "aborted";
18087
18087
  thoughtSignature?: string;
18088
18088
  time: {
18089
18089
  start: number;
@@ -18258,14 +18258,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18258
18258
  type: "image";
18259
18259
  data: string;
18260
18260
  mimeType: string;
18261
+ } | {
18262
+ type: "thinking";
18263
+ thinking: string;
18264
+ thinkingSignature?: string;
18265
+ redacted?: boolean;
18261
18266
  } | {
18262
18267
  addedToolNames?: string[];
18263
18268
  arguments: Record<string, any>;
18264
18269
  callID: string;
18265
18270
  name: string;
18266
18271
  namespace?: string;
18267
- result: {
18268
- content: ({
18272
+ partial?: {
18273
+ content?: ({
18269
18274
  type: "text";
18270
18275
  text: string;
18271
18276
  textSignature?: string;
@@ -18275,9 +18280,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18275
18280
  mimeType: string;
18276
18281
  })[];
18277
18282
  details?: any;
18278
- isError: false;
18279
18283
  };
18280
- status: "completed";
18284
+ status: "running";
18281
18285
  thoughtSignature?: string;
18282
18286
  time: {
18283
18287
  start: number;
@@ -18301,9 +18305,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18301
18305
  mimeType: string;
18302
18306
  })[];
18303
18307
  details?: any;
18304
- isError: true;
18308
+ isError: false;
18305
18309
  };
18306
- status: "error";
18310
+ status: "completed";
18307
18311
  thoughtSignature?: string;
18308
18312
  time: {
18309
18313
  start: number;
@@ -18329,7 +18333,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18329
18333
  details?: any;
18330
18334
  isError: true;
18331
18335
  };
18332
- status: "skipped";
18336
+ status: "error";
18333
18337
  thoughtSignature?: string;
18334
18338
  time: {
18335
18339
  start: number;
@@ -18355,26 +18359,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18355
18359
  details?: any;
18356
18360
  isError: true;
18357
18361
  };
18358
- status: "aborted";
18362
+ status: "skipped";
18359
18363
  thoughtSignature?: string;
18360
18364
  time: {
18361
18365
  start: number;
18362
18366
  end: number;
18363
18367
  };
18364
18368
  type: "toolCall";
18365
- } | {
18366
- type: "thinking";
18367
- thinking: string;
18368
- thinkingSignature?: string;
18369
- redacted?: boolean;
18370
18369
  } | {
18371
18370
  addedToolNames?: string[];
18372
18371
  arguments: Record<string, any>;
18373
18372
  callID: string;
18374
18373
  name: string;
18375
18374
  namespace?: string;
18376
- partial?: {
18377
- content?: ({
18375
+ result: {
18376
+ content: ({
18378
18377
  type: "text";
18379
18378
  text: string;
18380
18379
  textSignature?: string;
@@ -18384,8 +18383,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18384
18383
  mimeType: string;
18385
18384
  })[];
18386
18385
  details?: any;
18386
+ isError: true;
18387
18387
  };
18388
- status: "running";
18388
+ status: "aborted";
18389
18389
  thoughtSignature?: string;
18390
18390
  time: {
18391
18391
  start: number;
@@ -18588,14 +18588,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18588
18588
  type: "image";
18589
18589
  data: string;
18590
18590
  mimeType: string;
18591
+ } | {
18592
+ type: "thinking";
18593
+ thinking: string;
18594
+ thinkingSignature?: string;
18595
+ redacted?: boolean;
18591
18596
  } | {
18592
18597
  addedToolNames?: string[];
18593
18598
  arguments: Record<string, any>;
18594
18599
  callID: string;
18595
18600
  name: string;
18596
18601
  namespace?: string;
18597
- result: {
18598
- content: ({
18602
+ partial?: {
18603
+ content?: ({
18599
18604
  type: "text";
18600
18605
  text: string;
18601
18606
  textSignature?: string;
@@ -18605,9 +18610,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18605
18610
  mimeType: string;
18606
18611
  })[];
18607
18612
  details?: any;
18608
- isError: false;
18609
18613
  };
18610
- status: "completed";
18614
+ status: "running";
18611
18615
  thoughtSignature?: string;
18612
18616
  time: {
18613
18617
  start: number;
@@ -18631,9 +18635,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18631
18635
  mimeType: string;
18632
18636
  })[];
18633
18637
  details?: any;
18634
- isError: true;
18638
+ isError: false;
18635
18639
  };
18636
- status: "error";
18640
+ status: "completed";
18637
18641
  thoughtSignature?: string;
18638
18642
  time: {
18639
18643
  start: number;
@@ -18659,7 +18663,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18659
18663
  details?: any;
18660
18664
  isError: true;
18661
18665
  };
18662
- status: "skipped";
18666
+ status: "error";
18663
18667
  thoughtSignature?: string;
18664
18668
  time: {
18665
18669
  start: number;
@@ -18685,26 +18689,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18685
18689
  details?: any;
18686
18690
  isError: true;
18687
18691
  };
18688
- status: "aborted";
18692
+ status: "skipped";
18689
18693
  thoughtSignature?: string;
18690
18694
  time: {
18691
18695
  start: number;
18692
18696
  end: number;
18693
18697
  };
18694
18698
  type: "toolCall";
18695
- } | {
18696
- type: "thinking";
18697
- thinking: string;
18698
- thinkingSignature?: string;
18699
- redacted?: boolean;
18700
18699
  } | {
18701
18700
  addedToolNames?: string[];
18702
18701
  arguments: Record<string, any>;
18703
18702
  callID: string;
18704
18703
  name: string;
18705
18704
  namespace?: string;
18706
- partial?: {
18707
- content?: ({
18705
+ result: {
18706
+ content: ({
18708
18707
  type: "text";
18709
18708
  text: string;
18710
18709
  textSignature?: string;
@@ -18714,8 +18713,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18714
18713
  mimeType: string;
18715
18714
  })[];
18716
18715
  details?: any;
18716
+ isError: true;
18717
18717
  };
18718
- status: "running";
18718
+ status: "aborted";
18719
18719
  thoughtSignature?: string;
18720
18720
  time: {
18721
18721
  start: number;
@@ -18890,14 +18890,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18890
18890
  type: "image";
18891
18891
  data: string;
18892
18892
  mimeType: string;
18893
+ } | {
18894
+ type: "thinking";
18895
+ thinking: string;
18896
+ thinkingSignature?: string;
18897
+ redacted?: boolean;
18893
18898
  } | {
18894
18899
  addedToolNames?: string[];
18895
18900
  arguments: Record<string, any>;
18896
18901
  callID: string;
18897
18902
  name: string;
18898
18903
  namespace?: string;
18899
- result: {
18900
- content: ({
18904
+ partial?: {
18905
+ content?: ({
18901
18906
  type: "text";
18902
18907
  text: string;
18903
18908
  textSignature?: string;
@@ -18907,9 +18912,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18907
18912
  mimeType: string;
18908
18913
  })[];
18909
18914
  details?: any;
18910
- isError: false;
18911
18915
  };
18912
- status: "completed";
18916
+ status: "running";
18913
18917
  thoughtSignature?: string;
18914
18918
  time: {
18915
18919
  start: number;
@@ -18933,9 +18937,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18933
18937
  mimeType: string;
18934
18938
  })[];
18935
18939
  details?: any;
18936
- isError: true;
18940
+ isError: false;
18937
18941
  };
18938
- status: "error";
18942
+ status: "completed";
18939
18943
  thoughtSignature?: string;
18940
18944
  time: {
18941
18945
  start: number;
@@ -18961,7 +18965,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18961
18965
  details?: any;
18962
18966
  isError: true;
18963
18967
  };
18964
- status: "skipped";
18968
+ status: "error";
18965
18969
  thoughtSignature?: string;
18966
18970
  time: {
18967
18971
  start: number;
@@ -18987,26 +18991,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18987
18991
  details?: any;
18988
18992
  isError: true;
18989
18993
  };
18990
- status: "aborted";
18994
+ status: "skipped";
18991
18995
  thoughtSignature?: string;
18992
18996
  time: {
18993
18997
  start: number;
18994
18998
  end: number;
18995
18999
  };
18996
19000
  type: "toolCall";
18997
- } | {
18998
- type: "thinking";
18999
- thinking: string;
19000
- thinkingSignature?: string;
19001
- redacted?: boolean;
19002
19001
  } | {
19003
19002
  addedToolNames?: string[];
19004
19003
  arguments: Record<string, any>;
19005
19004
  callID: string;
19006
19005
  name: string;
19007
19006
  namespace?: string;
19008
- partial?: {
19009
- content?: ({
19007
+ result: {
19008
+ content: ({
19010
19009
  type: "text";
19011
19010
  text: string;
19012
19011
  textSignature?: string;
@@ -19016,8 +19015,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19016
19015
  mimeType: string;
19017
19016
  })[];
19018
19017
  details?: any;
19018
+ isError: true;
19019
19019
  };
19020
- status: "running";
19020
+ status: "aborted";
19021
19021
  thoughtSignature?: string;
19022
19022
  time: {
19023
19023
  start: number;
@@ -19211,14 +19211,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19211
19211
  type: "image";
19212
19212
  data: string;
19213
19213
  mimeType: string;
19214
+ } | {
19215
+ type: "thinking";
19216
+ thinking: string;
19217
+ thinkingSignature?: string;
19218
+ redacted?: boolean;
19214
19219
  } | {
19215
19220
  addedToolNames?: string[];
19216
19221
  arguments: Record<string, any>;
19217
19222
  callID: string;
19218
19223
  name: string;
19219
19224
  namespace?: string;
19220
- result: {
19221
- content: ({
19225
+ partial?: {
19226
+ content?: ({
19222
19227
  type: "text";
19223
19228
  text: string;
19224
19229
  textSignature?: string;
@@ -19228,9 +19233,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19228
19233
  mimeType: string;
19229
19234
  })[];
19230
19235
  details?: any;
19231
- isError: false;
19232
19236
  };
19233
- status: "completed";
19237
+ status: "running";
19234
19238
  thoughtSignature?: string;
19235
19239
  time: {
19236
19240
  start: number;
@@ -19254,9 +19258,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19254
19258
  mimeType: string;
19255
19259
  })[];
19256
19260
  details?: any;
19257
- isError: true;
19261
+ isError: false;
19258
19262
  };
19259
- status: "error";
19263
+ status: "completed";
19260
19264
  thoughtSignature?: string;
19261
19265
  time: {
19262
19266
  start: number;
@@ -19282,7 +19286,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19282
19286
  details?: any;
19283
19287
  isError: true;
19284
19288
  };
19285
- status: "skipped";
19289
+ status: "error";
19286
19290
  thoughtSignature?: string;
19287
19291
  time: {
19288
19292
  start: number;
@@ -19308,26 +19312,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19308
19312
  details?: any;
19309
19313
  isError: true;
19310
19314
  };
19311
- status: "aborted";
19315
+ status: "skipped";
19312
19316
  thoughtSignature?: string;
19313
19317
  time: {
19314
19318
  start: number;
19315
19319
  end: number;
19316
19320
  };
19317
19321
  type: "toolCall";
19318
- } | {
19319
- type: "thinking";
19320
- thinking: string;
19321
- thinkingSignature?: string;
19322
- redacted?: boolean;
19323
19322
  } | {
19324
19323
  addedToolNames?: string[];
19325
19324
  arguments: Record<string, any>;
19326
19325
  callID: string;
19327
19326
  name: string;
19328
19327
  namespace?: string;
19329
- partial?: {
19330
- content?: ({
19328
+ result: {
19329
+ content: ({
19331
19330
  type: "text";
19332
19331
  text: string;
19333
19332
  textSignature?: string;
@@ -19337,8 +19336,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19337
19336
  mimeType: string;
19338
19337
  })[];
19339
19338
  details?: any;
19339
+ isError: true;
19340
19340
  };
19341
- status: "running";
19341
+ status: "aborted";
19342
19342
  thoughtSignature?: string;
19343
19343
  time: {
19344
19344
  start: number;
@@ -19513,14 +19513,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19513
19513
  type: "image";
19514
19514
  data: string;
19515
19515
  mimeType: string;
19516
+ } | {
19517
+ type: "thinking";
19518
+ thinking: string;
19519
+ thinkingSignature?: string;
19520
+ redacted?: boolean;
19516
19521
  } | {
19517
19522
  addedToolNames?: string[];
19518
19523
  arguments: Record<string, any>;
19519
19524
  callID: string;
19520
19525
  name: string;
19521
19526
  namespace?: string;
19522
- result: {
19523
- content: ({
19527
+ partial?: {
19528
+ content?: ({
19524
19529
  type: "text";
19525
19530
  text: string;
19526
19531
  textSignature?: string;
@@ -19530,9 +19535,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19530
19535
  mimeType: string;
19531
19536
  })[];
19532
19537
  details?: any;
19533
- isError: false;
19534
19538
  };
19535
- status: "completed";
19539
+ status: "running";
19536
19540
  thoughtSignature?: string;
19537
19541
  time: {
19538
19542
  start: number;
@@ -19556,9 +19560,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19556
19560
  mimeType: string;
19557
19561
  })[];
19558
19562
  details?: any;
19559
- isError: true;
19563
+ isError: false;
19560
19564
  };
19561
- status: "error";
19565
+ status: "completed";
19562
19566
  thoughtSignature?: string;
19563
19567
  time: {
19564
19568
  start: number;
@@ -19584,7 +19588,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19584
19588
  details?: any;
19585
19589
  isError: true;
19586
19590
  };
19587
- status: "skipped";
19591
+ status: "error";
19588
19592
  thoughtSignature?: string;
19589
19593
  time: {
19590
19594
  start: number;
@@ -19610,26 +19614,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19610
19614
  details?: any;
19611
19615
  isError: true;
19612
19616
  };
19613
- status: "aborted";
19617
+ status: "skipped";
19614
19618
  thoughtSignature?: string;
19615
19619
  time: {
19616
19620
  start: number;
19617
19621
  end: number;
19618
19622
  };
19619
19623
  type: "toolCall";
19620
- } | {
19621
- type: "thinking";
19622
- thinking: string;
19623
- thinkingSignature?: string;
19624
- redacted?: boolean;
19625
19624
  } | {
19626
19625
  addedToolNames?: string[];
19627
19626
  arguments: Record<string, any>;
19628
19627
  callID: string;
19629
19628
  name: string;
19630
19629
  namespace?: string;
19631
- partial?: {
19632
- content?: ({
19630
+ result: {
19631
+ content: ({
19633
19632
  type: "text";
19634
19633
  text: string;
19635
19634
  textSignature?: string;
@@ -19639,8 +19638,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19639
19638
  mimeType: string;
19640
19639
  })[];
19641
19640
  details?: any;
19641
+ isError: true;
19642
19642
  };
19643
- status: "running";
19643
+ status: "aborted";
19644
19644
  thoughtSignature?: string;
19645
19645
  time: {
19646
19646
  start: number;
@@ -20828,14 +20828,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20828
20828
  type: "image";
20829
20829
  data: string;
20830
20830
  mimeType: string;
20831
+ } | {
20832
+ type: "thinking";
20833
+ thinking: string;
20834
+ thinkingSignature?: string;
20835
+ redacted?: boolean;
20831
20836
  } | {
20832
20837
  addedToolNames?: string[];
20833
20838
  arguments: Record<string, any>;
20834
20839
  callID: string;
20835
20840
  name: string;
20836
20841
  namespace?: string;
20837
- result: {
20838
- content: ({
20842
+ partial?: {
20843
+ content?: ({
20839
20844
  type: "text";
20840
20845
  text: string;
20841
20846
  textSignature?: string;
@@ -20845,9 +20850,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20845
20850
  mimeType: string;
20846
20851
  })[];
20847
20852
  details?: any;
20848
- isError: false;
20849
20853
  };
20850
- status: "completed";
20854
+ status: "running";
20851
20855
  thoughtSignature?: string;
20852
20856
  time: {
20853
20857
  start: number;
@@ -20871,9 +20875,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20871
20875
  mimeType: string;
20872
20876
  })[];
20873
20877
  details?: any;
20874
- isError: true;
20878
+ isError: false;
20875
20879
  };
20876
- status: "error";
20880
+ status: "completed";
20877
20881
  thoughtSignature?: string;
20878
20882
  time: {
20879
20883
  start: number;
@@ -20899,7 +20903,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20899
20903
  details?: any;
20900
20904
  isError: true;
20901
20905
  };
20902
- status: "skipped";
20906
+ status: "error";
20903
20907
  thoughtSignature?: string;
20904
20908
  time: {
20905
20909
  start: number;
@@ -20925,26 +20929,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20925
20929
  details?: any;
20926
20930
  isError: true;
20927
20931
  };
20928
- status: "aborted";
20932
+ status: "skipped";
20929
20933
  thoughtSignature?: string;
20930
20934
  time: {
20931
20935
  start: number;
20932
20936
  end: number;
20933
20937
  };
20934
20938
  type: "toolCall";
20935
- } | {
20936
- type: "thinking";
20937
- thinking: string;
20938
- thinkingSignature?: string;
20939
- redacted?: boolean;
20940
20939
  } | {
20941
20940
  addedToolNames?: string[];
20942
20941
  arguments: Record<string, any>;
20943
20942
  callID: string;
20944
20943
  name: string;
20945
20944
  namespace?: string;
20946
- partial?: {
20947
- content?: ({
20945
+ result: {
20946
+ content: ({
20948
20947
  type: "text";
20949
20948
  text: string;
20950
20949
  textSignature?: string;
@@ -20954,8 +20953,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20954
20953
  mimeType: string;
20955
20954
  })[];
20956
20955
  details?: any;
20956
+ isError: true;
20957
20957
  };
20958
- status: "running";
20958
+ status: "aborted";
20959
20959
  thoughtSignature?: string;
20960
20960
  time: {
20961
20961
  start: number;
@@ -21130,14 +21130,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21130
21130
  type: "image";
21131
21131
  data: string;
21132
21132
  mimeType: string;
21133
+ } | {
21134
+ type: "thinking";
21135
+ thinking: string;
21136
+ thinkingSignature?: string;
21137
+ redacted?: boolean;
21133
21138
  } | {
21134
21139
  addedToolNames?: string[];
21135
21140
  arguments: Record<string, any>;
21136
21141
  callID: string;
21137
21142
  name: string;
21138
21143
  namespace?: string;
21139
- result: {
21140
- content: ({
21144
+ partial?: {
21145
+ content?: ({
21141
21146
  type: "text";
21142
21147
  text: string;
21143
21148
  textSignature?: string;
@@ -21147,9 +21152,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21147
21152
  mimeType: string;
21148
21153
  })[];
21149
21154
  details?: any;
21150
- isError: false;
21151
21155
  };
21152
- status: "completed";
21156
+ status: "running";
21153
21157
  thoughtSignature?: string;
21154
21158
  time: {
21155
21159
  start: number;
@@ -21173,9 +21177,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21173
21177
  mimeType: string;
21174
21178
  })[];
21175
21179
  details?: any;
21176
- isError: true;
21180
+ isError: false;
21177
21181
  };
21178
- status: "error";
21182
+ status: "completed";
21179
21183
  thoughtSignature?: string;
21180
21184
  time: {
21181
21185
  start: number;
@@ -21201,7 +21205,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21201
21205
  details?: any;
21202
21206
  isError: true;
21203
21207
  };
21204
- status: "skipped";
21208
+ status: "error";
21205
21209
  thoughtSignature?: string;
21206
21210
  time: {
21207
21211
  start: number;
@@ -21227,26 +21231,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21227
21231
  details?: any;
21228
21232
  isError: true;
21229
21233
  };
21230
- status: "aborted";
21234
+ status: "skipped";
21231
21235
  thoughtSignature?: string;
21232
21236
  time: {
21233
21237
  start: number;
21234
21238
  end: number;
21235
21239
  };
21236
21240
  type: "toolCall";
21237
- } | {
21238
- type: "thinking";
21239
- thinking: string;
21240
- thinkingSignature?: string;
21241
- redacted?: boolean;
21242
21241
  } | {
21243
21242
  addedToolNames?: string[];
21244
21243
  arguments: Record<string, any>;
21245
21244
  callID: string;
21246
21245
  name: string;
21247
21246
  namespace?: string;
21248
- partial?: {
21249
- content?: ({
21247
+ result: {
21248
+ content: ({
21250
21249
  type: "text";
21251
21250
  text: string;
21252
21251
  textSignature?: string;
@@ -21256,8 +21255,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21256
21255
  mimeType: string;
21257
21256
  })[];
21258
21257
  details?: any;
21258
+ isError: true;
21259
21259
  };
21260
- status: "running";
21260
+ status: "aborted";
21261
21261
  thoughtSignature?: string;
21262
21262
  time: {
21263
21263
  start: number;
@@ -21450,14 +21450,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21450
21450
  type: "image";
21451
21451
  data: string;
21452
21452
  mimeType: string;
21453
+ } | {
21454
+ type: "thinking";
21455
+ thinking: string;
21456
+ thinkingSignature?: string;
21457
+ redacted?: boolean;
21453
21458
  } | {
21454
21459
  addedToolNames?: string[];
21455
21460
  arguments: Record<string, any>;
21456
21461
  callID: string;
21457
21462
  name: string;
21458
21463
  namespace?: string;
21459
- result: {
21460
- content: ({
21464
+ partial?: {
21465
+ content?: ({
21461
21466
  type: "text";
21462
21467
  text: string;
21463
21468
  textSignature?: string;
@@ -21467,9 +21472,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21467
21472
  mimeType: string;
21468
21473
  })[];
21469
21474
  details?: any;
21470
- isError: false;
21471
21475
  };
21472
- status: "completed";
21476
+ status: "running";
21473
21477
  thoughtSignature?: string;
21474
21478
  time: {
21475
21479
  start: number;
@@ -21493,9 +21497,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21493
21497
  mimeType: string;
21494
21498
  })[];
21495
21499
  details?: any;
21496
- isError: true;
21500
+ isError: false;
21497
21501
  };
21498
- status: "error";
21502
+ status: "completed";
21499
21503
  thoughtSignature?: string;
21500
21504
  time: {
21501
21505
  start: number;
@@ -21521,7 +21525,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21521
21525
  details?: any;
21522
21526
  isError: true;
21523
21527
  };
21524
- status: "skipped";
21528
+ status: "error";
21525
21529
  thoughtSignature?: string;
21526
21530
  time: {
21527
21531
  start: number;
@@ -21547,26 +21551,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21547
21551
  details?: any;
21548
21552
  isError: true;
21549
21553
  };
21550
- status: "aborted";
21554
+ status: "skipped";
21551
21555
  thoughtSignature?: string;
21552
21556
  time: {
21553
21557
  start: number;
21554
21558
  end: number;
21555
21559
  };
21556
21560
  type: "toolCall";
21557
- } | {
21558
- type: "thinking";
21559
- thinking: string;
21560
- thinkingSignature?: string;
21561
- redacted?: boolean;
21562
21561
  } | {
21563
21562
  addedToolNames?: string[];
21564
21563
  arguments: Record<string, any>;
21565
21564
  callID: string;
21566
21565
  name: string;
21567
21566
  namespace?: string;
21568
- partial?: {
21569
- content?: ({
21567
+ result: {
21568
+ content: ({
21570
21569
  type: "text";
21571
21570
  text: string;
21572
21571
  textSignature?: string;
@@ -21576,8 +21575,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21576
21575
  mimeType: string;
21577
21576
  })[];
21578
21577
  details?: any;
21578
+ isError: true;
21579
21579
  };
21580
- status: "running";
21580
+ status: "aborted";
21581
21581
  thoughtSignature?: string;
21582
21582
  time: {
21583
21583
  start: number;
@@ -21752,14 +21752,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21752
21752
  type: "image";
21753
21753
  data: string;
21754
21754
  mimeType: string;
21755
+ } | {
21756
+ type: "thinking";
21757
+ thinking: string;
21758
+ thinkingSignature?: string;
21759
+ redacted?: boolean;
21755
21760
  } | {
21756
21761
  addedToolNames?: string[];
21757
21762
  arguments: Record<string, any>;
21758
21763
  callID: string;
21759
21764
  name: string;
21760
21765
  namespace?: string;
21761
- result: {
21762
- content: ({
21766
+ partial?: {
21767
+ content?: ({
21763
21768
  type: "text";
21764
21769
  text: string;
21765
21770
  textSignature?: string;
@@ -21769,9 +21774,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21769
21774
  mimeType: string;
21770
21775
  })[];
21771
21776
  details?: any;
21772
- isError: false;
21773
21777
  };
21774
- status: "completed";
21778
+ status: "running";
21775
21779
  thoughtSignature?: string;
21776
21780
  time: {
21777
21781
  start: number;
@@ -21795,9 +21799,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21795
21799
  mimeType: string;
21796
21800
  })[];
21797
21801
  details?: any;
21798
- isError: true;
21802
+ isError: false;
21799
21803
  };
21800
- status: "error";
21804
+ status: "completed";
21801
21805
  thoughtSignature?: string;
21802
21806
  time: {
21803
21807
  start: number;
@@ -21823,7 +21827,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21823
21827
  details?: any;
21824
21828
  isError: true;
21825
21829
  };
21826
- status: "skipped";
21830
+ status: "error";
21827
21831
  thoughtSignature?: string;
21828
21832
  time: {
21829
21833
  start: number;
@@ -21849,26 +21853,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21849
21853
  details?: any;
21850
21854
  isError: true;
21851
21855
  };
21852
- status: "aborted";
21856
+ status: "skipped";
21853
21857
  thoughtSignature?: string;
21854
21858
  time: {
21855
21859
  start: number;
21856
21860
  end: number;
21857
21861
  };
21858
21862
  type: "toolCall";
21859
- } | {
21860
- type: "thinking";
21861
- thinking: string;
21862
- thinkingSignature?: string;
21863
- redacted?: boolean;
21864
21863
  } | {
21865
21864
  addedToolNames?: string[];
21866
21865
  arguments: Record<string, any>;
21867
21866
  callID: string;
21868
21867
  name: string;
21869
21868
  namespace?: string;
21870
- partial?: {
21871
- content?: ({
21869
+ result: {
21870
+ content: ({
21872
21871
  type: "text";
21873
21872
  text: string;
21874
21873
  textSignature?: string;
@@ -21878,8 +21877,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21878
21877
  mimeType: string;
21879
21878
  })[];
21880
21879
  details?: any;
21880
+ isError: true;
21881
21881
  };
21882
- status: "running";
21882
+ status: "aborted";
21883
21883
  thoughtSignature?: string;
21884
21884
  time: {
21885
21885
  start: number;
@@ -22082,14 +22082,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22082
22082
  type: "image";
22083
22083
  data: string;
22084
22084
  mimeType: string;
22085
+ } | {
22086
+ type: "thinking";
22087
+ thinking: string;
22088
+ thinkingSignature?: string;
22089
+ redacted?: boolean;
22085
22090
  } | {
22086
22091
  addedToolNames?: string[];
22087
22092
  arguments: Record<string, any>;
22088
22093
  callID: string;
22089
22094
  name: string;
22090
22095
  namespace?: string;
22091
- result: {
22092
- content: ({
22096
+ partial?: {
22097
+ content?: ({
22093
22098
  type: "text";
22094
22099
  text: string;
22095
22100
  textSignature?: string;
@@ -22099,9 +22104,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22099
22104
  mimeType: string;
22100
22105
  })[];
22101
22106
  details?: any;
22102
- isError: false;
22103
22107
  };
22104
- status: "completed";
22108
+ status: "running";
22105
22109
  thoughtSignature?: string;
22106
22110
  time: {
22107
22111
  start: number;
@@ -22125,9 +22129,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22125
22129
  mimeType: string;
22126
22130
  })[];
22127
22131
  details?: any;
22128
- isError: true;
22132
+ isError: false;
22129
22133
  };
22130
- status: "error";
22134
+ status: "completed";
22131
22135
  thoughtSignature?: string;
22132
22136
  time: {
22133
22137
  start: number;
@@ -22153,7 +22157,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22153
22157
  details?: any;
22154
22158
  isError: true;
22155
22159
  };
22156
- status: "skipped";
22160
+ status: "error";
22157
22161
  thoughtSignature?: string;
22158
22162
  time: {
22159
22163
  start: number;
@@ -22179,26 +22183,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22179
22183
  details?: any;
22180
22184
  isError: true;
22181
22185
  };
22182
- status: "aborted";
22186
+ status: "skipped";
22183
22187
  thoughtSignature?: string;
22184
22188
  time: {
22185
22189
  start: number;
22186
22190
  end: number;
22187
22191
  };
22188
22192
  type: "toolCall";
22189
- } | {
22190
- type: "thinking";
22191
- thinking: string;
22192
- thinkingSignature?: string;
22193
- redacted?: boolean;
22194
22193
  } | {
22195
22194
  addedToolNames?: string[];
22196
22195
  arguments: Record<string, any>;
22197
22196
  callID: string;
22198
22197
  name: string;
22199
22198
  namespace?: string;
22200
- partial?: {
22201
- content?: ({
22199
+ result: {
22200
+ content: ({
22202
22201
  type: "text";
22203
22202
  text: string;
22204
22203
  textSignature?: string;
@@ -22208,8 +22207,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22208
22207
  mimeType: string;
22209
22208
  })[];
22210
22209
  details?: any;
22210
+ isError: true;
22211
22211
  };
22212
- status: "running";
22212
+ status: "aborted";
22213
22213
  thoughtSignature?: string;
22214
22214
  time: {
22215
22215
  start: number;
@@ -22384,14 +22384,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22384
22384
  type: "image";
22385
22385
  data: string;
22386
22386
  mimeType: string;
22387
+ } | {
22388
+ type: "thinking";
22389
+ thinking: string;
22390
+ thinkingSignature?: string;
22391
+ redacted?: boolean;
22387
22392
  } | {
22388
22393
  addedToolNames?: string[];
22389
22394
  arguments: Record<string, any>;
22390
22395
  callID: string;
22391
22396
  name: string;
22392
22397
  namespace?: string;
22393
- result: {
22394
- content: ({
22398
+ partial?: {
22399
+ content?: ({
22395
22400
  type: "text";
22396
22401
  text: string;
22397
22402
  textSignature?: string;
@@ -22401,9 +22406,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22401
22406
  mimeType: string;
22402
22407
  })[];
22403
22408
  details?: any;
22404
- isError: false;
22405
22409
  };
22406
- status: "completed";
22410
+ status: "running";
22407
22411
  thoughtSignature?: string;
22408
22412
  time: {
22409
22413
  start: number;
@@ -22427,9 +22431,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22427
22431
  mimeType: string;
22428
22432
  })[];
22429
22433
  details?: any;
22430
- isError: true;
22434
+ isError: false;
22431
22435
  };
22432
- status: "error";
22436
+ status: "completed";
22433
22437
  thoughtSignature?: string;
22434
22438
  time: {
22435
22439
  start: number;
@@ -22455,7 +22459,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22455
22459
  details?: any;
22456
22460
  isError: true;
22457
22461
  };
22458
- status: "skipped";
22462
+ status: "error";
22459
22463
  thoughtSignature?: string;
22460
22464
  time: {
22461
22465
  start: number;
@@ -22481,26 +22485,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22481
22485
  details?: any;
22482
22486
  isError: true;
22483
22487
  };
22484
- status: "aborted";
22488
+ status: "skipped";
22485
22489
  thoughtSignature?: string;
22486
22490
  time: {
22487
22491
  start: number;
22488
22492
  end: number;
22489
22493
  };
22490
22494
  type: "toolCall";
22491
- } | {
22492
- type: "thinking";
22493
- thinking: string;
22494
- thinkingSignature?: string;
22495
- redacted?: boolean;
22496
22495
  } | {
22497
22496
  addedToolNames?: string[];
22498
22497
  arguments: Record<string, any>;
22499
22498
  callID: string;
22500
22499
  name: string;
22501
22500
  namespace?: string;
22502
- partial?: {
22503
- content?: ({
22501
+ result: {
22502
+ content: ({
22504
22503
  type: "text";
22505
22504
  text: string;
22506
22505
  textSignature?: string;
@@ -22510,8 +22509,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22510
22509
  mimeType: string;
22511
22510
  })[];
22512
22511
  details?: any;
22512
+ isError: true;
22513
22513
  };
22514
- status: "running";
22514
+ status: "aborted";
22515
22515
  thoughtSignature?: string;
22516
22516
  time: {
22517
22517
  start: number;
@@ -22705,14 +22705,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22705
22705
  type: "image";
22706
22706
  data: string;
22707
22707
  mimeType: string;
22708
+ } | {
22709
+ type: "thinking";
22710
+ thinking: string;
22711
+ thinkingSignature?: string;
22712
+ redacted?: boolean;
22708
22713
  } | {
22709
22714
  addedToolNames?: string[];
22710
22715
  arguments: Record<string, any>;
22711
22716
  callID: string;
22712
22717
  name: string;
22713
22718
  namespace?: string;
22714
- result: {
22715
- content: ({
22719
+ partial?: {
22720
+ content?: ({
22716
22721
  type: "text";
22717
22722
  text: string;
22718
22723
  textSignature?: string;
@@ -22722,9 +22727,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22722
22727
  mimeType: string;
22723
22728
  })[];
22724
22729
  details?: any;
22725
- isError: false;
22726
22730
  };
22727
- status: "completed";
22731
+ status: "running";
22728
22732
  thoughtSignature?: string;
22729
22733
  time: {
22730
22734
  start: number;
@@ -22748,9 +22752,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22748
22752
  mimeType: string;
22749
22753
  })[];
22750
22754
  details?: any;
22751
- isError: true;
22755
+ isError: false;
22752
22756
  };
22753
- status: "error";
22757
+ status: "completed";
22754
22758
  thoughtSignature?: string;
22755
22759
  time: {
22756
22760
  start: number;
@@ -22776,7 +22780,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22776
22780
  details?: any;
22777
22781
  isError: true;
22778
22782
  };
22779
- status: "skipped";
22783
+ status: "error";
22780
22784
  thoughtSignature?: string;
22781
22785
  time: {
22782
22786
  start: number;
@@ -22802,26 +22806,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22802
22806
  details?: any;
22803
22807
  isError: true;
22804
22808
  };
22805
- status: "aborted";
22809
+ status: "skipped";
22806
22810
  thoughtSignature?: string;
22807
22811
  time: {
22808
22812
  start: number;
22809
22813
  end: number;
22810
22814
  };
22811
22815
  type: "toolCall";
22812
- } | {
22813
- type: "thinking";
22814
- thinking: string;
22815
- thinkingSignature?: string;
22816
- redacted?: boolean;
22817
22816
  } | {
22818
22817
  addedToolNames?: string[];
22819
22818
  arguments: Record<string, any>;
22820
22819
  callID: string;
22821
22820
  name: string;
22822
22821
  namespace?: string;
22823
- partial?: {
22824
- content?: ({
22822
+ result: {
22823
+ content: ({
22825
22824
  type: "text";
22826
22825
  text: string;
22827
22826
  textSignature?: string;
@@ -22831,8 +22830,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22831
22830
  mimeType: string;
22832
22831
  })[];
22833
22832
  details?: any;
22833
+ isError: true;
22834
22834
  };
22835
- status: "running";
22835
+ status: "aborted";
22836
22836
  thoughtSignature?: string;
22837
22837
  time: {
22838
22838
  start: number;
@@ -23007,14 +23007,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23007
23007
  type: "image";
23008
23008
  data: string;
23009
23009
  mimeType: string;
23010
+ } | {
23011
+ type: "thinking";
23012
+ thinking: string;
23013
+ thinkingSignature?: string;
23014
+ redacted?: boolean;
23010
23015
  } | {
23011
23016
  addedToolNames?: string[];
23012
23017
  arguments: Record<string, any>;
23013
23018
  callID: string;
23014
23019
  name: string;
23015
23020
  namespace?: string;
23016
- result: {
23017
- content: ({
23021
+ partial?: {
23022
+ content?: ({
23018
23023
  type: "text";
23019
23024
  text: string;
23020
23025
  textSignature?: string;
@@ -23024,9 +23029,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23024
23029
  mimeType: string;
23025
23030
  })[];
23026
23031
  details?: any;
23027
- isError: false;
23028
23032
  };
23029
- status: "completed";
23033
+ status: "running";
23030
23034
  thoughtSignature?: string;
23031
23035
  time: {
23032
23036
  start: number;
@@ -23050,9 +23054,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23050
23054
  mimeType: string;
23051
23055
  })[];
23052
23056
  details?: any;
23053
- isError: true;
23057
+ isError: false;
23054
23058
  };
23055
- status: "error";
23059
+ status: "completed";
23056
23060
  thoughtSignature?: string;
23057
23061
  time: {
23058
23062
  start: number;
@@ -23078,7 +23082,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23078
23082
  details?: any;
23079
23083
  isError: true;
23080
23084
  };
23081
- status: "skipped";
23085
+ status: "error";
23082
23086
  thoughtSignature?: string;
23083
23087
  time: {
23084
23088
  start: number;
@@ -23104,26 +23108,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23104
23108
  details?: any;
23105
23109
  isError: true;
23106
23110
  };
23107
- status: "aborted";
23111
+ status: "skipped";
23108
23112
  thoughtSignature?: string;
23109
23113
  time: {
23110
23114
  start: number;
23111
23115
  end: number;
23112
23116
  };
23113
23117
  type: "toolCall";
23114
- } | {
23115
- type: "thinking";
23116
- thinking: string;
23117
- thinkingSignature?: string;
23118
- redacted?: boolean;
23119
23118
  } | {
23120
23119
  addedToolNames?: string[];
23121
23120
  arguments: Record<string, any>;
23122
23121
  callID: string;
23123
23122
  name: string;
23124
23123
  namespace?: string;
23125
- partial?: {
23126
- content?: ({
23124
+ result: {
23125
+ content: ({
23127
23126
  type: "text";
23128
23127
  text: string;
23129
23128
  textSignature?: string;
@@ -23133,8 +23132,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23133
23132
  mimeType: string;
23134
23133
  })[];
23135
23134
  details?: any;
23135
+ isError: true;
23136
23136
  };
23137
- status: "running";
23137
+ status: "aborted";
23138
23138
  thoughtSignature?: string;
23139
23139
  time: {
23140
23140
  start: number;
@@ -23337,14 +23337,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23337
23337
  type: "image";
23338
23338
  data: string;
23339
23339
  mimeType: string;
23340
+ } | {
23341
+ type: "thinking";
23342
+ thinking: string;
23343
+ thinkingSignature?: string;
23344
+ redacted?: boolean;
23340
23345
  } | {
23341
23346
  addedToolNames?: string[];
23342
23347
  arguments: Record<string, any>;
23343
23348
  callID: string;
23344
23349
  name: string;
23345
23350
  namespace?: string;
23346
- result: {
23347
- content: ({
23351
+ partial?: {
23352
+ content?: ({
23348
23353
  type: "text";
23349
23354
  text: string;
23350
23355
  textSignature?: string;
@@ -23354,9 +23359,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23354
23359
  mimeType: string;
23355
23360
  })[];
23356
23361
  details?: any;
23357
- isError: false;
23358
23362
  };
23359
- status: "completed";
23363
+ status: "running";
23360
23364
  thoughtSignature?: string;
23361
23365
  time: {
23362
23366
  start: number;
@@ -23380,9 +23384,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23380
23384
  mimeType: string;
23381
23385
  })[];
23382
23386
  details?: any;
23383
- isError: true;
23387
+ isError: false;
23384
23388
  };
23385
- status: "error";
23389
+ status: "completed";
23386
23390
  thoughtSignature?: string;
23387
23391
  time: {
23388
23392
  start: number;
@@ -23408,7 +23412,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23408
23412
  details?: any;
23409
23413
  isError: true;
23410
23414
  };
23411
- status: "skipped";
23415
+ status: "error";
23412
23416
  thoughtSignature?: string;
23413
23417
  time: {
23414
23418
  start: number;
@@ -23434,26 +23438,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23434
23438
  details?: any;
23435
23439
  isError: true;
23436
23440
  };
23437
- status: "aborted";
23441
+ status: "skipped";
23438
23442
  thoughtSignature?: string;
23439
23443
  time: {
23440
23444
  start: number;
23441
23445
  end: number;
23442
23446
  };
23443
23447
  type: "toolCall";
23444
- } | {
23445
- type: "thinking";
23446
- thinking: string;
23447
- thinkingSignature?: string;
23448
- redacted?: boolean;
23449
23448
  } | {
23450
23449
  addedToolNames?: string[];
23451
23450
  arguments: Record<string, any>;
23452
23451
  callID: string;
23453
23452
  name: string;
23454
23453
  namespace?: string;
23455
- partial?: {
23456
- content?: ({
23454
+ result: {
23455
+ content: ({
23457
23456
  type: "text";
23458
23457
  text: string;
23459
23458
  textSignature?: string;
@@ -23463,8 +23462,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23463
23462
  mimeType: string;
23464
23463
  })[];
23465
23464
  details?: any;
23465
+ isError: true;
23466
23466
  };
23467
- status: "running";
23467
+ status: "aborted";
23468
23468
  thoughtSignature?: string;
23469
23469
  time: {
23470
23470
  start: number;
@@ -23639,14 +23639,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23639
23639
  type: "image";
23640
23640
  data: string;
23641
23641
  mimeType: string;
23642
+ } | {
23643
+ type: "thinking";
23644
+ thinking: string;
23645
+ thinkingSignature?: string;
23646
+ redacted?: boolean;
23642
23647
  } | {
23643
23648
  addedToolNames?: string[];
23644
23649
  arguments: Record<string, any>;
23645
23650
  callID: string;
23646
23651
  name: string;
23647
23652
  namespace?: string;
23648
- result: {
23649
- content: ({
23653
+ partial?: {
23654
+ content?: ({
23650
23655
  type: "text";
23651
23656
  text: string;
23652
23657
  textSignature?: string;
@@ -23656,9 +23661,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23656
23661
  mimeType: string;
23657
23662
  })[];
23658
23663
  details?: any;
23659
- isError: false;
23660
23664
  };
23661
- status: "completed";
23665
+ status: "running";
23662
23666
  thoughtSignature?: string;
23663
23667
  time: {
23664
23668
  start: number;
@@ -23682,9 +23686,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23682
23686
  mimeType: string;
23683
23687
  })[];
23684
23688
  details?: any;
23685
- isError: true;
23689
+ isError: false;
23686
23690
  };
23687
- status: "error";
23691
+ status: "completed";
23688
23692
  thoughtSignature?: string;
23689
23693
  time: {
23690
23694
  start: number;
@@ -23710,7 +23714,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23710
23714
  details?: any;
23711
23715
  isError: true;
23712
23716
  };
23713
- status: "skipped";
23717
+ status: "error";
23714
23718
  thoughtSignature?: string;
23715
23719
  time: {
23716
23720
  start: number;
@@ -23736,26 +23740,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23736
23740
  details?: any;
23737
23741
  isError: true;
23738
23742
  };
23739
- status: "aborted";
23743
+ status: "skipped";
23740
23744
  thoughtSignature?: string;
23741
23745
  time: {
23742
23746
  start: number;
23743
23747
  end: number;
23744
23748
  };
23745
23749
  type: "toolCall";
23746
- } | {
23747
- type: "thinking";
23748
- thinking: string;
23749
- thinkingSignature?: string;
23750
- redacted?: boolean;
23751
23750
  } | {
23752
23751
  addedToolNames?: string[];
23753
23752
  arguments: Record<string, any>;
23754
23753
  callID: string;
23755
23754
  name: string;
23756
23755
  namespace?: string;
23757
- partial?: {
23758
- content?: ({
23756
+ result: {
23757
+ content: ({
23759
23758
  type: "text";
23760
23759
  text: string;
23761
23760
  textSignature?: string;
@@ -23765,8 +23764,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23765
23764
  mimeType: string;
23766
23765
  })[];
23767
23766
  details?: any;
23767
+ isError: true;
23768
23768
  };
23769
- status: "running";
23769
+ status: "aborted";
23770
23770
  thoughtSignature?: string;
23771
23771
  time: {
23772
23772
  start: number;
@@ -23960,14 +23960,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23960
23960
  type: "image";
23961
23961
  data: string;
23962
23962
  mimeType: string;
23963
+ } | {
23964
+ type: "thinking";
23965
+ thinking: string;
23966
+ thinkingSignature?: string;
23967
+ redacted?: boolean;
23963
23968
  } | {
23964
23969
  addedToolNames?: string[];
23965
23970
  arguments: Record<string, any>;
23966
23971
  callID: string;
23967
23972
  name: string;
23968
23973
  namespace?: string;
23969
- result: {
23970
- content: ({
23974
+ partial?: {
23975
+ content?: ({
23971
23976
  type: "text";
23972
23977
  text: string;
23973
23978
  textSignature?: string;
@@ -23977,9 +23982,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23977
23982
  mimeType: string;
23978
23983
  })[];
23979
23984
  details?: any;
23980
- isError: false;
23981
23985
  };
23982
- status: "completed";
23986
+ status: "running";
23983
23987
  thoughtSignature?: string;
23984
23988
  time: {
23985
23989
  start: number;
@@ -24003,9 +24007,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24003
24007
  mimeType: string;
24004
24008
  })[];
24005
24009
  details?: any;
24006
- isError: true;
24010
+ isError: false;
24007
24011
  };
24008
- status: "error";
24012
+ status: "completed";
24009
24013
  thoughtSignature?: string;
24010
24014
  time: {
24011
24015
  start: number;
@@ -24031,7 +24035,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24031
24035
  details?: any;
24032
24036
  isError: true;
24033
24037
  };
24034
- status: "skipped";
24038
+ status: "error";
24035
24039
  thoughtSignature?: string;
24036
24040
  time: {
24037
24041
  start: number;
@@ -24057,26 +24061,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24057
24061
  details?: any;
24058
24062
  isError: true;
24059
24063
  };
24060
- status: "aborted";
24064
+ status: "skipped";
24061
24065
  thoughtSignature?: string;
24062
24066
  time: {
24063
24067
  start: number;
24064
24068
  end: number;
24065
24069
  };
24066
24070
  type: "toolCall";
24067
- } | {
24068
- type: "thinking";
24069
- thinking: string;
24070
- thinkingSignature?: string;
24071
- redacted?: boolean;
24072
24071
  } | {
24073
24072
  addedToolNames?: string[];
24074
24073
  arguments: Record<string, any>;
24075
24074
  callID: string;
24076
24075
  name: string;
24077
24076
  namespace?: string;
24078
- partial?: {
24079
- content?: ({
24077
+ result: {
24078
+ content: ({
24080
24079
  type: "text";
24081
24080
  text: string;
24082
24081
  textSignature?: string;
@@ -24086,8 +24085,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24086
24085
  mimeType: string;
24087
24086
  })[];
24088
24087
  details?: any;
24088
+ isError: true;
24089
24089
  };
24090
- status: "running";
24090
+ status: "aborted";
24091
24091
  thoughtSignature?: string;
24092
24092
  time: {
24093
24093
  start: number;
@@ -24262,14 +24262,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24262
24262
  type: "image";
24263
24263
  data: string;
24264
24264
  mimeType: string;
24265
+ } | {
24266
+ type: "thinking";
24267
+ thinking: string;
24268
+ thinkingSignature?: string;
24269
+ redacted?: boolean;
24265
24270
  } | {
24266
24271
  addedToolNames?: string[];
24267
24272
  arguments: Record<string, any>;
24268
24273
  callID: string;
24269
24274
  name: string;
24270
24275
  namespace?: string;
24271
- result: {
24272
- content: ({
24276
+ partial?: {
24277
+ content?: ({
24273
24278
  type: "text";
24274
24279
  text: string;
24275
24280
  textSignature?: string;
@@ -24279,9 +24284,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24279
24284
  mimeType: string;
24280
24285
  })[];
24281
24286
  details?: any;
24282
- isError: false;
24283
24287
  };
24284
- status: "completed";
24288
+ status: "running";
24285
24289
  thoughtSignature?: string;
24286
24290
  time: {
24287
24291
  start: number;
@@ -24305,9 +24309,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24305
24309
  mimeType: string;
24306
24310
  })[];
24307
24311
  details?: any;
24308
- isError: true;
24312
+ isError: false;
24309
24313
  };
24310
- status: "error";
24314
+ status: "completed";
24311
24315
  thoughtSignature?: string;
24312
24316
  time: {
24313
24317
  start: number;
@@ -24333,7 +24337,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24333
24337
  details?: any;
24334
24338
  isError: true;
24335
24339
  };
24336
- status: "skipped";
24340
+ status: "error";
24337
24341
  thoughtSignature?: string;
24338
24342
  time: {
24339
24343
  start: number;
@@ -24359,26 +24363,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24359
24363
  details?: any;
24360
24364
  isError: true;
24361
24365
  };
24362
- status: "aborted";
24366
+ status: "skipped";
24363
24367
  thoughtSignature?: string;
24364
24368
  time: {
24365
24369
  start: number;
24366
24370
  end: number;
24367
24371
  };
24368
24372
  type: "toolCall";
24369
- } | {
24370
- type: "thinking";
24371
- thinking: string;
24372
- thinkingSignature?: string;
24373
- redacted?: boolean;
24374
24373
  } | {
24375
24374
  addedToolNames?: string[];
24376
24375
  arguments: Record<string, any>;
24377
24376
  callID: string;
24378
24377
  name: string;
24379
24378
  namespace?: string;
24380
- partial?: {
24381
- content?: ({
24379
+ result: {
24380
+ content: ({
24382
24381
  type: "text";
24383
24382
  text: string;
24384
24383
  textSignature?: string;
@@ -24388,8 +24387,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24388
24387
  mimeType: string;
24389
24388
  })[];
24390
24389
  details?: any;
24390
+ isError: true;
24391
24391
  };
24392
- status: "running";
24392
+ status: "aborted";
24393
24393
  thoughtSignature?: string;
24394
24394
  time: {
24395
24395
  start: number;