@codeworksh/harness 0.3.0-dev.20261019181702 → 0.4.0-dev.20261019193730

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/effect.d.mts CHANGED
@@ -2734,6 +2734,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2734
2734
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2735
2735
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2736
2736
  declare const encodeMessage: (message: {
2737
+ messageId: string;
2738
+ role: "user";
2739
+ time: {
2740
+ created: number;
2741
+ };
2742
+ parts: ({
2743
+ type: "text";
2744
+ text: string;
2745
+ textSignature?: string;
2746
+ } | {
2747
+ type: "image";
2748
+ data: string;
2749
+ mimeType: string;
2750
+ })[];
2751
+ } | {
2737
2752
  role: "assistant";
2738
2753
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2739
2754
  provider: {
@@ -2883,19 +2898,14 @@ declare const encodeMessage: (message: {
2883
2898
  type: "image";
2884
2899
  data: string;
2885
2900
  mimeType: string;
2886
- } | {
2887
- type: "thinking";
2888
- thinking: string;
2889
- thinkingSignature?: string;
2890
- redacted?: boolean;
2891
2901
  } | {
2892
2902
  addedToolNames?: string[];
2893
2903
  arguments: Record<string, any>;
2894
2904
  callID: string;
2895
2905
  name: string;
2896
2906
  namespace?: string;
2897
- partial?: {
2898
- content?: ({
2907
+ result: {
2908
+ content: ({
2899
2909
  type: "text";
2900
2910
  text: string;
2901
2911
  textSignature?: string;
@@ -2905,8 +2915,9 @@ declare const encodeMessage: (message: {
2905
2915
  mimeType: string;
2906
2916
  })[];
2907
2917
  details?: any;
2918
+ isError: false;
2908
2919
  };
2909
- status: "running";
2920
+ status: "completed";
2910
2921
  thoughtSignature?: string;
2911
2922
  time: {
2912
2923
  start: number;
@@ -2930,9 +2941,9 @@ declare const encodeMessage: (message: {
2930
2941
  mimeType: string;
2931
2942
  })[];
2932
2943
  details?: any;
2933
- isError: false;
2944
+ isError: true;
2934
2945
  };
2935
- status: "completed";
2946
+ status: "error";
2936
2947
  thoughtSignature?: string;
2937
2948
  time: {
2938
2949
  start: number;
@@ -2958,7 +2969,7 @@ declare const encodeMessage: (message: {
2958
2969
  details?: any;
2959
2970
  isError: true;
2960
2971
  };
2961
- status: "error";
2972
+ status: "skipped";
2962
2973
  thoughtSignature?: string;
2963
2974
  time: {
2964
2975
  start: number;
@@ -2984,21 +2995,26 @@ declare const encodeMessage: (message: {
2984
2995
  details?: any;
2985
2996
  isError: true;
2986
2997
  };
2987
- status: "skipped";
2998
+ status: "aborted";
2988
2999
  thoughtSignature?: string;
2989
3000
  time: {
2990
3001
  start: number;
2991
3002
  end: number;
2992
3003
  };
2993
3004
  type: "toolCall";
3005
+ } | {
3006
+ type: "thinking";
3007
+ thinking: string;
3008
+ thinkingSignature?: string;
3009
+ redacted?: boolean;
2994
3010
  } | {
2995
3011
  addedToolNames?: string[];
2996
3012
  arguments: Record<string, any>;
2997
3013
  callID: string;
2998
3014
  name: string;
2999
3015
  namespace?: string;
3000
- result: {
3001
- content: ({
3016
+ partial?: {
3017
+ content?: ({
3002
3018
  type: "text";
3003
3019
  text: string;
3004
3020
  textSignature?: string;
@@ -3008,9 +3024,8 @@ declare const encodeMessage: (message: {
3008
3024
  mimeType: string;
3009
3025
  })[];
3010
3026
  details?: any;
3011
- isError: true;
3012
3027
  };
3013
- status: "aborted";
3028
+ status: "running";
3014
3029
  thoughtSignature?: string;
3015
3030
  time: {
3016
3031
  start: number;
@@ -3035,7 +3050,8 @@ declare const encodeMessage: (message: {
3035
3050
  responseId?: string;
3036
3051
  responseModel?: string;
3037
3052
  messageId: string;
3038
- } | {
3053
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3054
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3039
3055
  messageId: string;
3040
3056
  role: "user";
3041
3057
  time: {
@@ -3050,8 +3066,8 @@ declare const encodeMessage: (message: {
3050
3066
  data: string;
3051
3067
  mimeType: string;
3052
3068
  })[];
3053
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3054
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3069
+ }, ContextDecodeError, never>;
3070
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3055
3071
  messageId: string;
3056
3072
  role: "user";
3057
3073
  time: {
@@ -3066,8 +3082,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3066
3082
  data: string;
3067
3083
  mimeType: string;
3068
3084
  })[];
3069
- }, ContextDecodeError, never>;
3070
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3085
+ } | {
3071
3086
  role: "assistant";
3072
3087
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3073
3088
  provider: {
@@ -3217,19 +3232,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3217
3232
  type: "image";
3218
3233
  data: string;
3219
3234
  mimeType: string;
3220
- } | {
3221
- type: "thinking";
3222
- thinking: string;
3223
- thinkingSignature?: string;
3224
- redacted?: boolean;
3225
3235
  } | {
3226
3236
  addedToolNames?: string[];
3227
3237
  arguments: Record<string, any>;
3228
3238
  callID: string;
3229
3239
  name: string;
3230
3240
  namespace?: string;
3231
- partial?: {
3232
- content?: ({
3241
+ result: {
3242
+ content: ({
3233
3243
  type: "text";
3234
3244
  text: string;
3235
3245
  textSignature?: string;
@@ -3239,8 +3249,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3239
3249
  mimeType: string;
3240
3250
  })[];
3241
3251
  details?: any;
3252
+ isError: false;
3242
3253
  };
3243
- status: "running";
3254
+ status: "completed";
3244
3255
  thoughtSignature?: string;
3245
3256
  time: {
3246
3257
  start: number;
@@ -3264,9 +3275,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3264
3275
  mimeType: string;
3265
3276
  })[];
3266
3277
  details?: any;
3267
- isError: false;
3278
+ isError: true;
3268
3279
  };
3269
- status: "completed";
3280
+ status: "error";
3270
3281
  thoughtSignature?: string;
3271
3282
  time: {
3272
3283
  start: number;
@@ -3292,7 +3303,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3292
3303
  details?: any;
3293
3304
  isError: true;
3294
3305
  };
3295
- status: "error";
3306
+ status: "skipped";
3296
3307
  thoughtSignature?: string;
3297
3308
  time: {
3298
3309
  start: number;
@@ -3318,21 +3329,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3318
3329
  details?: any;
3319
3330
  isError: true;
3320
3331
  };
3321
- status: "skipped";
3332
+ status: "aborted";
3322
3333
  thoughtSignature?: string;
3323
3334
  time: {
3324
3335
  start: number;
3325
3336
  end: number;
3326
3337
  };
3327
3338
  type: "toolCall";
3339
+ } | {
3340
+ type: "thinking";
3341
+ thinking: string;
3342
+ thinkingSignature?: string;
3343
+ redacted?: boolean;
3328
3344
  } | {
3329
3345
  addedToolNames?: string[];
3330
3346
  arguments: Record<string, any>;
3331
3347
  callID: string;
3332
3348
  name: string;
3333
3349
  namespace?: string;
3334
- result: {
3335
- content: ({
3350
+ partial?: {
3351
+ content?: ({
3336
3352
  type: "text";
3337
3353
  text: string;
3338
3354
  textSignature?: string;
@@ -3342,9 +3358,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3342
3358
  mimeType: string;
3343
3359
  })[];
3344
3360
  details?: any;
3345
- isError: true;
3346
3361
  };
3347
- status: "aborted";
3362
+ status: "running";
3348
3363
  thoughtSignature?: string;
3349
3364
  time: {
3350
3365
  start: number;
@@ -3369,21 +3384,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3369
3384
  responseId?: string;
3370
3385
  responseModel?: string;
3371
3386
  messageId: string;
3372
- } | {
3373
- messageId: string;
3374
- role: "user";
3375
- time: {
3376
- created: number;
3377
- };
3378
- parts: ({
3379
- type: "text";
3380
- text: string;
3381
- textSignature?: string;
3382
- } | {
3383
- type: "image";
3384
- data: string;
3385
- mimeType: string;
3386
- })[];
3387
3387
  }, ContextDecodeError, never>;
3388
3388
  declare namespace context_d_exports {
3389
3389
  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 };
@@ -4876,19 +4876,14 @@ declare const LLMStarted: Schema.Struct<{
4876
4876
  type: "image";
4877
4877
  data: string;
4878
4878
  mimeType: string;
4879
- } | {
4880
- type: "thinking";
4881
- thinking: string;
4882
- thinkingSignature?: string;
4883
- redacted?: boolean;
4884
4879
  } | {
4885
4880
  addedToolNames?: string[];
4886
4881
  arguments: Record<string, any>;
4887
4882
  callID: string;
4888
4883
  name: string;
4889
4884
  namespace?: string;
4890
- partial?: {
4891
- content?: ({
4885
+ result: {
4886
+ content: ({
4892
4887
  type: "text";
4893
4888
  text: string;
4894
4889
  textSignature?: string;
@@ -4898,8 +4893,9 @@ declare const LLMStarted: Schema.Struct<{
4898
4893
  mimeType: string;
4899
4894
  })[];
4900
4895
  details?: any;
4896
+ isError: false;
4901
4897
  };
4902
- status: "running";
4898
+ status: "completed";
4903
4899
  thoughtSignature?: string;
4904
4900
  time: {
4905
4901
  start: number;
@@ -4923,9 +4919,9 @@ declare const LLMStarted: Schema.Struct<{
4923
4919
  mimeType: string;
4924
4920
  })[];
4925
4921
  details?: any;
4926
- isError: false;
4922
+ isError: true;
4927
4923
  };
4928
- status: "completed";
4924
+ status: "error";
4929
4925
  thoughtSignature?: string;
4930
4926
  time: {
4931
4927
  start: number;
@@ -4951,7 +4947,7 @@ declare const LLMStarted: Schema.Struct<{
4951
4947
  details?: any;
4952
4948
  isError: true;
4953
4949
  };
4954
- status: "error";
4950
+ status: "skipped";
4955
4951
  thoughtSignature?: string;
4956
4952
  time: {
4957
4953
  start: number;
@@ -4977,21 +4973,26 @@ declare const LLMStarted: Schema.Struct<{
4977
4973
  details?: any;
4978
4974
  isError: true;
4979
4975
  };
4980
- status: "skipped";
4976
+ status: "aborted";
4981
4977
  thoughtSignature?: string;
4982
4978
  time: {
4983
4979
  start: number;
4984
4980
  end: number;
4985
4981
  };
4986
4982
  type: "toolCall";
4983
+ } | {
4984
+ type: "thinking";
4985
+ thinking: string;
4986
+ thinkingSignature?: string;
4987
+ redacted?: boolean;
4987
4988
  } | {
4988
4989
  addedToolNames?: string[];
4989
4990
  arguments: Record<string, any>;
4990
4991
  callID: string;
4991
4992
  name: string;
4992
4993
  namespace?: string;
4993
- result: {
4994
- content: ({
4994
+ partial?: {
4995
+ content?: ({
4995
4996
  type: "text";
4996
4997
  text: string;
4997
4998
  textSignature?: string;
@@ -5001,9 +5002,8 @@ declare const LLMStarted: Schema.Struct<{
5001
5002
  mimeType: string;
5002
5003
  })[];
5003
5004
  details?: any;
5004
- isError: true;
5005
5005
  };
5006
- status: "aborted";
5006
+ status: "running";
5007
5007
  thoughtSignature?: string;
5008
5008
  time: {
5009
5009
  start: number;
@@ -5178,19 +5178,14 @@ declare const LLMStarted: Schema.Struct<{
5178
5178
  type: "image";
5179
5179
  data: string;
5180
5180
  mimeType: string;
5181
- } | {
5182
- type: "thinking";
5183
- thinking: string;
5184
- thinkingSignature?: string;
5185
- redacted?: boolean;
5186
5181
  } | {
5187
5182
  addedToolNames?: string[];
5188
5183
  arguments: Record<string, any>;
5189
5184
  callID: string;
5190
5185
  name: string;
5191
5186
  namespace?: string;
5192
- partial?: {
5193
- content?: ({
5187
+ result: {
5188
+ content: ({
5194
5189
  type: "text";
5195
5190
  text: string;
5196
5191
  textSignature?: string;
@@ -5200,8 +5195,9 @@ declare const LLMStarted: Schema.Struct<{
5200
5195
  mimeType: string;
5201
5196
  })[];
5202
5197
  details?: any;
5198
+ isError: false;
5203
5199
  };
5204
- status: "running";
5200
+ status: "completed";
5205
5201
  thoughtSignature?: string;
5206
5202
  time: {
5207
5203
  start: number;
@@ -5225,9 +5221,9 @@ declare const LLMStarted: Schema.Struct<{
5225
5221
  mimeType: string;
5226
5222
  })[];
5227
5223
  details?: any;
5228
- isError: false;
5224
+ isError: true;
5229
5225
  };
5230
- status: "completed";
5226
+ status: "error";
5231
5227
  thoughtSignature?: string;
5232
5228
  time: {
5233
5229
  start: number;
@@ -5253,7 +5249,7 @@ declare const LLMStarted: Schema.Struct<{
5253
5249
  details?: any;
5254
5250
  isError: true;
5255
5251
  };
5256
- status: "error";
5252
+ status: "skipped";
5257
5253
  thoughtSignature?: string;
5258
5254
  time: {
5259
5255
  start: number;
@@ -5279,21 +5275,26 @@ declare const LLMStarted: Schema.Struct<{
5279
5275
  details?: any;
5280
5276
  isError: true;
5281
5277
  };
5282
- status: "skipped";
5278
+ status: "aborted";
5283
5279
  thoughtSignature?: string;
5284
5280
  time: {
5285
5281
  start: number;
5286
5282
  end: number;
5287
5283
  };
5288
5284
  type: "toolCall";
5285
+ } | {
5286
+ type: "thinking";
5287
+ thinking: string;
5288
+ thinkingSignature?: string;
5289
+ redacted?: boolean;
5289
5290
  } | {
5290
5291
  addedToolNames?: string[];
5291
5292
  arguments: Record<string, any>;
5292
5293
  callID: string;
5293
5294
  name: string;
5294
5295
  namespace?: string;
5295
- result: {
5296
- content: ({
5296
+ partial?: {
5297
+ content?: ({
5297
5298
  type: "text";
5298
5299
  text: string;
5299
5300
  textSignature?: string;
@@ -5303,9 +5304,8 @@ declare const LLMStarted: Schema.Struct<{
5303
5304
  mimeType: string;
5304
5305
  })[];
5305
5306
  details?: any;
5306
- isError: true;
5307
5307
  };
5308
- status: "aborted";
5308
+ status: "running";
5309
5309
  thoughtSignature?: string;
5310
5310
  time: {
5311
5311
  start: number;
@@ -5498,19 +5498,14 @@ declare const LLMStarted: Schema.Struct<{
5498
5498
  type: "image";
5499
5499
  data: string;
5500
5500
  mimeType: string;
5501
- } | {
5502
- type: "thinking";
5503
- thinking: string;
5504
- thinkingSignature?: string;
5505
- redacted?: boolean;
5506
5501
  } | {
5507
5502
  addedToolNames?: string[];
5508
5503
  arguments: Record<string, any>;
5509
5504
  callID: string;
5510
5505
  name: string;
5511
5506
  namespace?: string;
5512
- partial?: {
5513
- content?: ({
5507
+ result: {
5508
+ content: ({
5514
5509
  type: "text";
5515
5510
  text: string;
5516
5511
  textSignature?: string;
@@ -5520,8 +5515,9 @@ declare const LLMStarted: Schema.Struct<{
5520
5515
  mimeType: string;
5521
5516
  })[];
5522
5517
  details?: any;
5518
+ isError: false;
5523
5519
  };
5524
- status: "running";
5520
+ status: "completed";
5525
5521
  thoughtSignature?: string;
5526
5522
  time: {
5527
5523
  start: number;
@@ -5545,9 +5541,9 @@ declare const LLMStarted: Schema.Struct<{
5545
5541
  mimeType: string;
5546
5542
  })[];
5547
5543
  details?: any;
5548
- isError: false;
5544
+ isError: true;
5549
5545
  };
5550
- status: "completed";
5546
+ status: "error";
5551
5547
  thoughtSignature?: string;
5552
5548
  time: {
5553
5549
  start: number;
@@ -5573,7 +5569,7 @@ declare const LLMStarted: Schema.Struct<{
5573
5569
  details?: any;
5574
5570
  isError: true;
5575
5571
  };
5576
- status: "error";
5572
+ status: "skipped";
5577
5573
  thoughtSignature?: string;
5578
5574
  time: {
5579
5575
  start: number;
@@ -5599,21 +5595,26 @@ declare const LLMStarted: Schema.Struct<{
5599
5595
  details?: any;
5600
5596
  isError: true;
5601
5597
  };
5602
- status: "skipped";
5598
+ status: "aborted";
5603
5599
  thoughtSignature?: string;
5604
5600
  time: {
5605
5601
  start: number;
5606
5602
  end: number;
5607
5603
  };
5608
5604
  type: "toolCall";
5605
+ } | {
5606
+ type: "thinking";
5607
+ thinking: string;
5608
+ thinkingSignature?: string;
5609
+ redacted?: boolean;
5609
5610
  } | {
5610
5611
  addedToolNames?: string[];
5611
5612
  arguments: Record<string, any>;
5612
5613
  callID: string;
5613
5614
  name: string;
5614
5615
  namespace?: string;
5615
- result: {
5616
- content: ({
5616
+ partial?: {
5617
+ content?: ({
5617
5618
  type: "text";
5618
5619
  text: string;
5619
5620
  textSignature?: string;
@@ -5623,9 +5624,8 @@ declare const LLMStarted: Schema.Struct<{
5623
5624
  mimeType: string;
5624
5625
  })[];
5625
5626
  details?: any;
5626
- isError: true;
5627
5627
  };
5628
- status: "aborted";
5628
+ status: "running";
5629
5629
  thoughtSignature?: string;
5630
5630
  time: {
5631
5631
  start: number;
@@ -5800,19 +5800,14 @@ declare const LLMStarted: Schema.Struct<{
5800
5800
  type: "image";
5801
5801
  data: string;
5802
5802
  mimeType: string;
5803
- } | {
5804
- type: "thinking";
5805
- thinking: string;
5806
- thinkingSignature?: string;
5807
- redacted?: boolean;
5808
5803
  } | {
5809
5804
  addedToolNames?: string[];
5810
5805
  arguments: Record<string, any>;
5811
5806
  callID: string;
5812
5807
  name: string;
5813
5808
  namespace?: string;
5814
- partial?: {
5815
- content?: ({
5809
+ result: {
5810
+ content: ({
5816
5811
  type: "text";
5817
5812
  text: string;
5818
5813
  textSignature?: string;
@@ -5822,8 +5817,9 @@ declare const LLMStarted: Schema.Struct<{
5822
5817
  mimeType: string;
5823
5818
  })[];
5824
5819
  details?: any;
5820
+ isError: false;
5825
5821
  };
5826
- status: "running";
5822
+ status: "completed";
5827
5823
  thoughtSignature?: string;
5828
5824
  time: {
5829
5825
  start: number;
@@ -5847,9 +5843,9 @@ declare const LLMStarted: Schema.Struct<{
5847
5843
  mimeType: string;
5848
5844
  })[];
5849
5845
  details?: any;
5850
- isError: false;
5846
+ isError: true;
5851
5847
  };
5852
- status: "completed";
5848
+ status: "error";
5853
5849
  thoughtSignature?: string;
5854
5850
  time: {
5855
5851
  start: number;
@@ -5875,7 +5871,7 @@ declare const LLMStarted: Schema.Struct<{
5875
5871
  details?: any;
5876
5872
  isError: true;
5877
5873
  };
5878
- status: "error";
5874
+ status: "skipped";
5879
5875
  thoughtSignature?: string;
5880
5876
  time: {
5881
5877
  start: number;
@@ -5901,21 +5897,26 @@ declare const LLMStarted: Schema.Struct<{
5901
5897
  details?: any;
5902
5898
  isError: true;
5903
5899
  };
5904
- status: "skipped";
5900
+ status: "aborted";
5905
5901
  thoughtSignature?: string;
5906
5902
  time: {
5907
5903
  start: number;
5908
5904
  end: number;
5909
5905
  };
5910
5906
  type: "toolCall";
5907
+ } | {
5908
+ type: "thinking";
5909
+ thinking: string;
5910
+ thinkingSignature?: string;
5911
+ redacted?: boolean;
5911
5912
  } | {
5912
5913
  addedToolNames?: string[];
5913
5914
  arguments: Record<string, any>;
5914
5915
  callID: string;
5915
5916
  name: string;
5916
5917
  namespace?: string;
5917
- result: {
5918
- content: ({
5918
+ partial?: {
5919
+ content?: ({
5919
5920
  type: "text";
5920
5921
  text: string;
5921
5922
  textSignature?: string;
@@ -5925,9 +5926,8 @@ declare const LLMStarted: Schema.Struct<{
5925
5926
  mimeType: string;
5926
5927
  })[];
5927
5928
  details?: any;
5928
- isError: true;
5929
5929
  };
5930
- status: "aborted";
5930
+ status: "running";
5931
5931
  thoughtSignature?: string;
5932
5932
  time: {
5933
5933
  start: number;
@@ -6423,19 +6423,14 @@ declare const LLMEnded: Schema.Struct<{
6423
6423
  type: "image";
6424
6424
  data: string;
6425
6425
  mimeType: string;
6426
- } | {
6427
- type: "thinking";
6428
- thinking: string;
6429
- thinkingSignature?: string;
6430
- redacted?: boolean;
6431
6426
  } | {
6432
6427
  addedToolNames?: string[];
6433
6428
  arguments: Record<string, any>;
6434
6429
  callID: string;
6435
6430
  name: string;
6436
6431
  namespace?: string;
6437
- partial?: {
6438
- content?: ({
6432
+ result: {
6433
+ content: ({
6439
6434
  type: "text";
6440
6435
  text: string;
6441
6436
  textSignature?: string;
@@ -6445,8 +6440,9 @@ declare const LLMEnded: Schema.Struct<{
6445
6440
  mimeType: string;
6446
6441
  })[];
6447
6442
  details?: any;
6443
+ isError: false;
6448
6444
  };
6449
- status: "running";
6445
+ status: "completed";
6450
6446
  thoughtSignature?: string;
6451
6447
  time: {
6452
6448
  start: number;
@@ -6470,9 +6466,9 @@ declare const LLMEnded: Schema.Struct<{
6470
6466
  mimeType: string;
6471
6467
  })[];
6472
6468
  details?: any;
6473
- isError: false;
6469
+ isError: true;
6474
6470
  };
6475
- status: "completed";
6471
+ status: "error";
6476
6472
  thoughtSignature?: string;
6477
6473
  time: {
6478
6474
  start: number;
@@ -6498,7 +6494,7 @@ declare const LLMEnded: Schema.Struct<{
6498
6494
  details?: any;
6499
6495
  isError: true;
6500
6496
  };
6501
- status: "error";
6497
+ status: "skipped";
6502
6498
  thoughtSignature?: string;
6503
6499
  time: {
6504
6500
  start: number;
@@ -6524,7 +6520,7 @@ declare const LLMEnded: Schema.Struct<{
6524
6520
  details?: any;
6525
6521
  isError: true;
6526
6522
  };
6527
- status: "skipped";
6523
+ status: "aborted";
6528
6524
  thoughtSignature?: string;
6529
6525
  time: {
6530
6526
  start: number;
@@ -6532,13 +6528,18 @@ declare const LLMEnded: Schema.Struct<{
6532
6528
  };
6533
6529
  type: "toolCall";
6534
6530
  } | {
6535
- addedToolNames?: string[];
6536
- arguments: Record<string, any>;
6537
- callID: string;
6538
- name: string;
6531
+ type: "thinking";
6532
+ thinking: string;
6533
+ thinkingSignature?: string;
6534
+ redacted?: boolean;
6535
+ } | {
6536
+ addedToolNames?: string[];
6537
+ arguments: Record<string, any>;
6538
+ callID: string;
6539
+ name: string;
6539
6540
  namespace?: string;
6540
- result: {
6541
- content: ({
6541
+ partial?: {
6542
+ content?: ({
6542
6543
  type: "text";
6543
6544
  text: string;
6544
6545
  textSignature?: string;
@@ -6548,9 +6549,8 @@ declare const LLMEnded: Schema.Struct<{
6548
6549
  mimeType: string;
6549
6550
  })[];
6550
6551
  details?: any;
6551
- isError: true;
6552
6552
  };
6553
- status: "aborted";
6553
+ status: "running";
6554
6554
  thoughtSignature?: string;
6555
6555
  time: {
6556
6556
  start: number;
@@ -6725,19 +6725,14 @@ declare const LLMEnded: Schema.Struct<{
6725
6725
  type: "image";
6726
6726
  data: string;
6727
6727
  mimeType: string;
6728
- } | {
6729
- type: "thinking";
6730
- thinking: string;
6731
- thinkingSignature?: string;
6732
- redacted?: boolean;
6733
6728
  } | {
6734
6729
  addedToolNames?: string[];
6735
6730
  arguments: Record<string, any>;
6736
6731
  callID: string;
6737
6732
  name: string;
6738
6733
  namespace?: string;
6739
- partial?: {
6740
- content?: ({
6734
+ result: {
6735
+ content: ({
6741
6736
  type: "text";
6742
6737
  text: string;
6743
6738
  textSignature?: string;
@@ -6747,8 +6742,9 @@ declare const LLMEnded: Schema.Struct<{
6747
6742
  mimeType: string;
6748
6743
  })[];
6749
6744
  details?: any;
6745
+ isError: false;
6750
6746
  };
6751
- status: "running";
6747
+ status: "completed";
6752
6748
  thoughtSignature?: string;
6753
6749
  time: {
6754
6750
  start: number;
@@ -6772,9 +6768,9 @@ declare const LLMEnded: Schema.Struct<{
6772
6768
  mimeType: string;
6773
6769
  })[];
6774
6770
  details?: any;
6775
- isError: false;
6771
+ isError: true;
6776
6772
  };
6777
- status: "completed";
6773
+ status: "error";
6778
6774
  thoughtSignature?: string;
6779
6775
  time: {
6780
6776
  start: number;
@@ -6800,7 +6796,7 @@ declare const LLMEnded: Schema.Struct<{
6800
6796
  details?: any;
6801
6797
  isError: true;
6802
6798
  };
6803
- status: "error";
6799
+ status: "skipped";
6804
6800
  thoughtSignature?: string;
6805
6801
  time: {
6806
6802
  start: number;
@@ -6826,21 +6822,26 @@ declare const LLMEnded: Schema.Struct<{
6826
6822
  details?: any;
6827
6823
  isError: true;
6828
6824
  };
6829
- status: "skipped";
6825
+ status: "aborted";
6830
6826
  thoughtSignature?: string;
6831
6827
  time: {
6832
6828
  start: number;
6833
6829
  end: number;
6834
6830
  };
6835
6831
  type: "toolCall";
6832
+ } | {
6833
+ type: "thinking";
6834
+ thinking: string;
6835
+ thinkingSignature?: string;
6836
+ redacted?: boolean;
6836
6837
  } | {
6837
6838
  addedToolNames?: string[];
6838
6839
  arguments: Record<string, any>;
6839
6840
  callID: string;
6840
6841
  name: string;
6841
6842
  namespace?: string;
6842
- result: {
6843
- content: ({
6843
+ partial?: {
6844
+ content?: ({
6844
6845
  type: "text";
6845
6846
  text: string;
6846
6847
  textSignature?: string;
@@ -6850,9 +6851,8 @@ declare const LLMEnded: Schema.Struct<{
6850
6851
  mimeType: string;
6851
6852
  })[];
6852
6853
  details?: any;
6853
- isError: true;
6854
6854
  };
6855
- status: "aborted";
6855
+ status: "running";
6856
6856
  thoughtSignature?: string;
6857
6857
  time: {
6858
6858
  start: number;
@@ -7046,19 +7046,14 @@ declare const LLMEnded: Schema.Struct<{
7046
7046
  type: "image";
7047
7047
  data: string;
7048
7048
  mimeType: string;
7049
- } | {
7050
- type: "thinking";
7051
- thinking: string;
7052
- thinkingSignature?: string;
7053
- redacted?: boolean;
7054
7049
  } | {
7055
7050
  addedToolNames?: string[];
7056
7051
  arguments: Record<string, any>;
7057
7052
  callID: string;
7058
7053
  name: string;
7059
7054
  namespace?: string;
7060
- partial?: {
7061
- content?: ({
7055
+ result: {
7056
+ content: ({
7062
7057
  type: "text";
7063
7058
  text: string;
7064
7059
  textSignature?: string;
@@ -7068,8 +7063,9 @@ declare const LLMEnded: Schema.Struct<{
7068
7063
  mimeType: string;
7069
7064
  })[];
7070
7065
  details?: any;
7066
+ isError: false;
7071
7067
  };
7072
- status: "running";
7068
+ status: "completed";
7073
7069
  thoughtSignature?: string;
7074
7070
  time: {
7075
7071
  start: number;
@@ -7093,9 +7089,9 @@ declare const LLMEnded: Schema.Struct<{
7093
7089
  mimeType: string;
7094
7090
  })[];
7095
7091
  details?: any;
7096
- isError: false;
7092
+ isError: true;
7097
7093
  };
7098
- status: "completed";
7094
+ status: "error";
7099
7095
  thoughtSignature?: string;
7100
7096
  time: {
7101
7097
  start: number;
@@ -7121,7 +7117,7 @@ declare const LLMEnded: Schema.Struct<{
7121
7117
  details?: any;
7122
7118
  isError: true;
7123
7119
  };
7124
- status: "error";
7120
+ status: "skipped";
7125
7121
  thoughtSignature?: string;
7126
7122
  time: {
7127
7123
  start: number;
@@ -7147,21 +7143,26 @@ declare const LLMEnded: Schema.Struct<{
7147
7143
  details?: any;
7148
7144
  isError: true;
7149
7145
  };
7150
- status: "skipped";
7146
+ status: "aborted";
7151
7147
  thoughtSignature?: string;
7152
7148
  time: {
7153
7149
  start: number;
7154
7150
  end: number;
7155
7151
  };
7156
7152
  type: "toolCall";
7153
+ } | {
7154
+ type: "thinking";
7155
+ thinking: string;
7156
+ thinkingSignature?: string;
7157
+ redacted?: boolean;
7157
7158
  } | {
7158
7159
  addedToolNames?: string[];
7159
7160
  arguments: Record<string, any>;
7160
7161
  callID: string;
7161
7162
  name: string;
7162
7163
  namespace?: string;
7163
- result: {
7164
- content: ({
7164
+ partial?: {
7165
+ content?: ({
7165
7166
  type: "text";
7166
7167
  text: string;
7167
7168
  textSignature?: string;
@@ -7171,9 +7172,8 @@ declare const LLMEnded: Schema.Struct<{
7171
7172
  mimeType: string;
7172
7173
  })[];
7173
7174
  details?: any;
7174
- isError: true;
7175
7175
  };
7176
- status: "aborted";
7176
+ status: "running";
7177
7177
  thoughtSignature?: string;
7178
7178
  time: {
7179
7179
  start: number;
@@ -7348,19 +7348,14 @@ declare const LLMEnded: Schema.Struct<{
7348
7348
  type: "image";
7349
7349
  data: string;
7350
7350
  mimeType: string;
7351
- } | {
7352
- type: "thinking";
7353
- thinking: string;
7354
- thinkingSignature?: string;
7355
- redacted?: boolean;
7356
7351
  } | {
7357
7352
  addedToolNames?: string[];
7358
7353
  arguments: Record<string, any>;
7359
7354
  callID: string;
7360
7355
  name: string;
7361
7356
  namespace?: string;
7362
- partial?: {
7363
- content?: ({
7357
+ result: {
7358
+ content: ({
7364
7359
  type: "text";
7365
7360
  text: string;
7366
7361
  textSignature?: string;
@@ -7370,8 +7365,9 @@ declare const LLMEnded: Schema.Struct<{
7370
7365
  mimeType: string;
7371
7366
  })[];
7372
7367
  details?: any;
7368
+ isError: false;
7373
7369
  };
7374
- status: "running";
7370
+ status: "completed";
7375
7371
  thoughtSignature?: string;
7376
7372
  time: {
7377
7373
  start: number;
@@ -7395,9 +7391,9 @@ declare const LLMEnded: Schema.Struct<{
7395
7391
  mimeType: string;
7396
7392
  })[];
7397
7393
  details?: any;
7398
- isError: false;
7394
+ isError: true;
7399
7395
  };
7400
- status: "completed";
7396
+ status: "error";
7401
7397
  thoughtSignature?: string;
7402
7398
  time: {
7403
7399
  start: number;
@@ -7423,7 +7419,7 @@ declare const LLMEnded: Schema.Struct<{
7423
7419
  details?: any;
7424
7420
  isError: true;
7425
7421
  };
7426
- status: "error";
7422
+ status: "skipped";
7427
7423
  thoughtSignature?: string;
7428
7424
  time: {
7429
7425
  start: number;
@@ -7449,21 +7445,26 @@ declare const LLMEnded: Schema.Struct<{
7449
7445
  details?: any;
7450
7446
  isError: true;
7451
7447
  };
7452
- status: "skipped";
7448
+ status: "aborted";
7453
7449
  thoughtSignature?: string;
7454
7450
  time: {
7455
7451
  start: number;
7456
7452
  end: number;
7457
7453
  };
7458
7454
  type: "toolCall";
7455
+ } | {
7456
+ type: "thinking";
7457
+ thinking: string;
7458
+ thinkingSignature?: string;
7459
+ redacted?: boolean;
7459
7460
  } | {
7460
7461
  addedToolNames?: string[];
7461
7462
  arguments: Record<string, any>;
7462
7463
  callID: string;
7463
7464
  name: string;
7464
7465
  namespace?: string;
7465
- result: {
7466
- content: ({
7466
+ partial?: {
7467
+ content?: ({
7467
7468
  type: "text";
7468
7469
  text: string;
7469
7470
  textSignature?: string;
@@ -7473,9 +7474,8 @@ declare const LLMEnded: Schema.Struct<{
7473
7474
  mimeType: string;
7474
7475
  })[];
7475
7476
  details?: any;
7476
- isError: true;
7477
7477
  };
7478
- status: "aborted";
7478
+ status: "running";
7479
7479
  thoughtSignature?: string;
7480
7480
  time: {
7481
7481
  start: number;
@@ -7681,19 +7681,14 @@ declare const LLMFailed: Schema.Struct<{
7681
7681
  type: "image";
7682
7682
  data: string;
7683
7683
  mimeType: string;
7684
- } | {
7685
- type: "thinking";
7686
- thinking: string;
7687
- thinkingSignature?: string;
7688
- redacted?: boolean;
7689
7684
  } | {
7690
7685
  addedToolNames?: string[];
7691
7686
  arguments: Record<string, any>;
7692
7687
  callID: string;
7693
7688
  name: string;
7694
7689
  namespace?: string;
7695
- partial?: {
7696
- content?: ({
7690
+ result: {
7691
+ content: ({
7697
7692
  type: "text";
7698
7693
  text: string;
7699
7694
  textSignature?: string;
@@ -7703,8 +7698,9 @@ declare const LLMFailed: Schema.Struct<{
7703
7698
  mimeType: string;
7704
7699
  })[];
7705
7700
  details?: any;
7701
+ isError: false;
7706
7702
  };
7707
- status: "running";
7703
+ status: "completed";
7708
7704
  thoughtSignature?: string;
7709
7705
  time: {
7710
7706
  start: number;
@@ -7728,9 +7724,9 @@ declare const LLMFailed: Schema.Struct<{
7728
7724
  mimeType: string;
7729
7725
  })[];
7730
7726
  details?: any;
7731
- isError: false;
7727
+ isError: true;
7732
7728
  };
7733
- status: "completed";
7729
+ status: "error";
7734
7730
  thoughtSignature?: string;
7735
7731
  time: {
7736
7732
  start: number;
@@ -7756,7 +7752,7 @@ declare const LLMFailed: Schema.Struct<{
7756
7752
  details?: any;
7757
7753
  isError: true;
7758
7754
  };
7759
- status: "error";
7755
+ status: "skipped";
7760
7756
  thoughtSignature?: string;
7761
7757
  time: {
7762
7758
  start: number;
@@ -7782,21 +7778,26 @@ declare const LLMFailed: Schema.Struct<{
7782
7778
  details?: any;
7783
7779
  isError: true;
7784
7780
  };
7785
- status: "skipped";
7781
+ status: "aborted";
7786
7782
  thoughtSignature?: string;
7787
7783
  time: {
7788
7784
  start: number;
7789
7785
  end: number;
7790
7786
  };
7791
7787
  type: "toolCall";
7788
+ } | {
7789
+ type: "thinking";
7790
+ thinking: string;
7791
+ thinkingSignature?: string;
7792
+ redacted?: boolean;
7792
7793
  } | {
7793
7794
  addedToolNames?: string[];
7794
7795
  arguments: Record<string, any>;
7795
7796
  callID: string;
7796
7797
  name: string;
7797
7798
  namespace?: string;
7798
- result: {
7799
- content: ({
7799
+ partial?: {
7800
+ content?: ({
7800
7801
  type: "text";
7801
7802
  text: string;
7802
7803
  textSignature?: string;
@@ -7806,9 +7807,8 @@ declare const LLMFailed: Schema.Struct<{
7806
7807
  mimeType: string;
7807
7808
  })[];
7808
7809
  details?: any;
7809
- isError: true;
7810
7810
  };
7811
- status: "aborted";
7811
+ status: "running";
7812
7812
  thoughtSignature?: string;
7813
7813
  time: {
7814
7814
  start: number;
@@ -7983,19 +7983,14 @@ declare const LLMFailed: Schema.Struct<{
7983
7983
  type: "image";
7984
7984
  data: string;
7985
7985
  mimeType: string;
7986
- } | {
7987
- type: "thinking";
7988
- thinking: string;
7989
- thinkingSignature?: string;
7990
- redacted?: boolean;
7991
7986
  } | {
7992
7987
  addedToolNames?: string[];
7993
7988
  arguments: Record<string, any>;
7994
7989
  callID: string;
7995
7990
  name: string;
7996
7991
  namespace?: string;
7997
- partial?: {
7998
- content?: ({
7992
+ result: {
7993
+ content: ({
7999
7994
  type: "text";
8000
7995
  text: string;
8001
7996
  textSignature?: string;
@@ -8005,8 +8000,9 @@ declare const LLMFailed: Schema.Struct<{
8005
8000
  mimeType: string;
8006
8001
  })[];
8007
8002
  details?: any;
8003
+ isError: false;
8008
8004
  };
8009
- status: "running";
8005
+ status: "completed";
8010
8006
  thoughtSignature?: string;
8011
8007
  time: {
8012
8008
  start: number;
@@ -8030,9 +8026,9 @@ declare const LLMFailed: Schema.Struct<{
8030
8026
  mimeType: string;
8031
8027
  })[];
8032
8028
  details?: any;
8033
- isError: false;
8029
+ isError: true;
8034
8030
  };
8035
- status: "completed";
8031
+ status: "error";
8036
8032
  thoughtSignature?: string;
8037
8033
  time: {
8038
8034
  start: number;
@@ -8058,7 +8054,7 @@ declare const LLMFailed: Schema.Struct<{
8058
8054
  details?: any;
8059
8055
  isError: true;
8060
8056
  };
8061
- status: "error";
8057
+ status: "skipped";
8062
8058
  thoughtSignature?: string;
8063
8059
  time: {
8064
8060
  start: number;
@@ -8084,21 +8080,26 @@ declare const LLMFailed: Schema.Struct<{
8084
8080
  details?: any;
8085
8081
  isError: true;
8086
8082
  };
8087
- status: "skipped";
8083
+ status: "aborted";
8088
8084
  thoughtSignature?: string;
8089
8085
  time: {
8090
8086
  start: number;
8091
8087
  end: number;
8092
8088
  };
8093
8089
  type: "toolCall";
8090
+ } | {
8091
+ type: "thinking";
8092
+ thinking: string;
8093
+ thinkingSignature?: string;
8094
+ redacted?: boolean;
8094
8095
  } | {
8095
8096
  addedToolNames?: string[];
8096
8097
  arguments: Record<string, any>;
8097
8098
  callID: string;
8098
8099
  name: string;
8099
8100
  namespace?: string;
8100
- result: {
8101
- content: ({
8101
+ partial?: {
8102
+ content?: ({
8102
8103
  type: "text";
8103
8104
  text: string;
8104
8105
  textSignature?: string;
@@ -8108,9 +8109,8 @@ declare const LLMFailed: Schema.Struct<{
8108
8109
  mimeType: string;
8109
8110
  })[];
8110
8111
  details?: any;
8111
- isError: true;
8112
8112
  };
8113
- status: "aborted";
8113
+ status: "running";
8114
8114
  thoughtSignature?: string;
8115
8115
  time: {
8116
8116
  start: number;
@@ -8304,19 +8304,14 @@ declare const LLMFailed: Schema.Struct<{
8304
8304
  type: "image";
8305
8305
  data: string;
8306
8306
  mimeType: string;
8307
- } | {
8308
- type: "thinking";
8309
- thinking: string;
8310
- thinkingSignature?: string;
8311
- redacted?: boolean;
8312
8307
  } | {
8313
8308
  addedToolNames?: string[];
8314
8309
  arguments: Record<string, any>;
8315
8310
  callID: string;
8316
8311
  name: string;
8317
8312
  namespace?: string;
8318
- partial?: {
8319
- content?: ({
8313
+ result: {
8314
+ content: ({
8320
8315
  type: "text";
8321
8316
  text: string;
8322
8317
  textSignature?: string;
@@ -8326,8 +8321,9 @@ declare const LLMFailed: Schema.Struct<{
8326
8321
  mimeType: string;
8327
8322
  })[];
8328
8323
  details?: any;
8324
+ isError: false;
8329
8325
  };
8330
- status: "running";
8326
+ status: "completed";
8331
8327
  thoughtSignature?: string;
8332
8328
  time: {
8333
8329
  start: number;
@@ -8351,9 +8347,9 @@ declare const LLMFailed: Schema.Struct<{
8351
8347
  mimeType: string;
8352
8348
  })[];
8353
8349
  details?: any;
8354
- isError: false;
8350
+ isError: true;
8355
8351
  };
8356
- status: "completed";
8352
+ status: "error";
8357
8353
  thoughtSignature?: string;
8358
8354
  time: {
8359
8355
  start: number;
@@ -8379,7 +8375,7 @@ declare const LLMFailed: Schema.Struct<{
8379
8375
  details?: any;
8380
8376
  isError: true;
8381
8377
  };
8382
- status: "error";
8378
+ status: "skipped";
8383
8379
  thoughtSignature?: string;
8384
8380
  time: {
8385
8381
  start: number;
@@ -8405,21 +8401,26 @@ declare const LLMFailed: Schema.Struct<{
8405
8401
  details?: any;
8406
8402
  isError: true;
8407
8403
  };
8408
- status: "skipped";
8404
+ status: "aborted";
8409
8405
  thoughtSignature?: string;
8410
8406
  time: {
8411
8407
  start: number;
8412
8408
  end: number;
8413
8409
  };
8414
8410
  type: "toolCall";
8411
+ } | {
8412
+ type: "thinking";
8413
+ thinking: string;
8414
+ thinkingSignature?: string;
8415
+ redacted?: boolean;
8415
8416
  } | {
8416
8417
  addedToolNames?: string[];
8417
8418
  arguments: Record<string, any>;
8418
8419
  callID: string;
8419
8420
  name: string;
8420
8421
  namespace?: string;
8421
- result: {
8422
- content: ({
8422
+ partial?: {
8423
+ content?: ({
8423
8424
  type: "text";
8424
8425
  text: string;
8425
8426
  textSignature?: string;
@@ -8429,9 +8430,8 @@ declare const LLMFailed: Schema.Struct<{
8429
8430
  mimeType: string;
8430
8431
  })[];
8431
8432
  details?: any;
8432
- isError: true;
8433
8433
  };
8434
- status: "aborted";
8434
+ status: "running";
8435
8435
  thoughtSignature?: string;
8436
8436
  time: {
8437
8437
  start: number;
@@ -8606,19 +8606,14 @@ declare const LLMFailed: Schema.Struct<{
8606
8606
  type: "image";
8607
8607
  data: string;
8608
8608
  mimeType: string;
8609
- } | {
8610
- type: "thinking";
8611
- thinking: string;
8612
- thinkingSignature?: string;
8613
- redacted?: boolean;
8614
8609
  } | {
8615
8610
  addedToolNames?: string[];
8616
8611
  arguments: Record<string, any>;
8617
8612
  callID: string;
8618
8613
  name: string;
8619
8614
  namespace?: string;
8620
- partial?: {
8621
- content?: ({
8615
+ result: {
8616
+ content: ({
8622
8617
  type: "text";
8623
8618
  text: string;
8624
8619
  textSignature?: string;
@@ -8628,8 +8623,9 @@ declare const LLMFailed: Schema.Struct<{
8628
8623
  mimeType: string;
8629
8624
  })[];
8630
8625
  details?: any;
8626
+ isError: false;
8631
8627
  };
8632
- status: "running";
8628
+ status: "completed";
8633
8629
  thoughtSignature?: string;
8634
8630
  time: {
8635
8631
  start: number;
@@ -8653,9 +8649,9 @@ declare const LLMFailed: Schema.Struct<{
8653
8649
  mimeType: string;
8654
8650
  })[];
8655
8651
  details?: any;
8656
- isError: false;
8652
+ isError: true;
8657
8653
  };
8658
- status: "completed";
8654
+ status: "error";
8659
8655
  thoughtSignature?: string;
8660
8656
  time: {
8661
8657
  start: number;
@@ -8681,7 +8677,7 @@ declare const LLMFailed: Schema.Struct<{
8681
8677
  details?: any;
8682
8678
  isError: true;
8683
8679
  };
8684
- status: "error";
8680
+ status: "skipped";
8685
8681
  thoughtSignature?: string;
8686
8682
  time: {
8687
8683
  start: number;
@@ -8707,21 +8703,26 @@ declare const LLMFailed: Schema.Struct<{
8707
8703
  details?: any;
8708
8704
  isError: true;
8709
8705
  };
8710
- status: "skipped";
8706
+ status: "aborted";
8711
8707
  thoughtSignature?: string;
8712
8708
  time: {
8713
8709
  start: number;
8714
8710
  end: number;
8715
8711
  };
8716
8712
  type: "toolCall";
8713
+ } | {
8714
+ type: "thinking";
8715
+ thinking: string;
8716
+ thinkingSignature?: string;
8717
+ redacted?: boolean;
8717
8718
  } | {
8718
8719
  addedToolNames?: string[];
8719
8720
  arguments: Record<string, any>;
8720
8721
  callID: string;
8721
8722
  name: string;
8722
8723
  namespace?: string;
8723
- result: {
8724
- content: ({
8724
+ partial?: {
8725
+ content?: ({
8725
8726
  type: "text";
8726
8727
  text: string;
8727
8728
  textSignature?: string;
@@ -8731,9 +8732,8 @@ declare const LLMFailed: Schema.Struct<{
8731
8732
  mimeType: string;
8732
8733
  })[];
8733
8734
  details?: any;
8734
- isError: true;
8735
8735
  };
8736
- status: "aborted";
8736
+ status: "running";
8737
8737
  thoughtSignature?: string;
8738
8738
  time: {
8739
8739
  start: number;
@@ -10481,19 +10481,14 @@ declare const Definitions: readonly [Schema.Struct<{
10481
10481
  type: "image";
10482
10482
  data: string;
10483
10483
  mimeType: string;
10484
- } | {
10485
- type: "thinking";
10486
- thinking: string;
10487
- thinkingSignature?: string;
10488
- redacted?: boolean;
10489
10484
  } | {
10490
10485
  addedToolNames?: string[];
10491
10486
  arguments: Record<string, any>;
10492
10487
  callID: string;
10493
10488
  name: string;
10494
10489
  namespace?: string;
10495
- partial?: {
10496
- content?: ({
10490
+ result: {
10491
+ content: ({
10497
10492
  type: "text";
10498
10493
  text: string;
10499
10494
  textSignature?: string;
@@ -10503,8 +10498,9 @@ declare const Definitions: readonly [Schema.Struct<{
10503
10498
  mimeType: string;
10504
10499
  })[];
10505
10500
  details?: any;
10501
+ isError: false;
10506
10502
  };
10507
- status: "running";
10503
+ status: "completed";
10508
10504
  thoughtSignature?: string;
10509
10505
  time: {
10510
10506
  start: number;
@@ -10528,9 +10524,9 @@ declare const Definitions: readonly [Schema.Struct<{
10528
10524
  mimeType: string;
10529
10525
  })[];
10530
10526
  details?: any;
10531
- isError: false;
10527
+ isError: true;
10532
10528
  };
10533
- status: "completed";
10529
+ status: "error";
10534
10530
  thoughtSignature?: string;
10535
10531
  time: {
10536
10532
  start: number;
@@ -10556,7 +10552,7 @@ declare const Definitions: readonly [Schema.Struct<{
10556
10552
  details?: any;
10557
10553
  isError: true;
10558
10554
  };
10559
- status: "error";
10555
+ status: "skipped";
10560
10556
  thoughtSignature?: string;
10561
10557
  time: {
10562
10558
  start: number;
@@ -10582,21 +10578,26 @@ declare const Definitions: readonly [Schema.Struct<{
10582
10578
  details?: any;
10583
10579
  isError: true;
10584
10580
  };
10585
- status: "skipped";
10581
+ status: "aborted";
10586
10582
  thoughtSignature?: string;
10587
10583
  time: {
10588
10584
  start: number;
10589
10585
  end: number;
10590
10586
  };
10591
10587
  type: "toolCall";
10588
+ } | {
10589
+ type: "thinking";
10590
+ thinking: string;
10591
+ thinkingSignature?: string;
10592
+ redacted?: boolean;
10592
10593
  } | {
10593
10594
  addedToolNames?: string[];
10594
10595
  arguments: Record<string, any>;
10595
10596
  callID: string;
10596
10597
  name: string;
10597
10598
  namespace?: string;
10598
- result: {
10599
- content: ({
10599
+ partial?: {
10600
+ content?: ({
10600
10601
  type: "text";
10601
10602
  text: string;
10602
10603
  textSignature?: string;
@@ -10606,9 +10607,8 @@ declare const Definitions: readonly [Schema.Struct<{
10606
10607
  mimeType: string;
10607
10608
  })[];
10608
10609
  details?: any;
10609
- isError: true;
10610
10610
  };
10611
- status: "aborted";
10611
+ status: "running";
10612
10612
  thoughtSignature?: string;
10613
10613
  time: {
10614
10614
  start: number;
@@ -10783,19 +10783,14 @@ declare const Definitions: readonly [Schema.Struct<{
10783
10783
  type: "image";
10784
10784
  data: string;
10785
10785
  mimeType: string;
10786
- } | {
10787
- type: "thinking";
10788
- thinking: string;
10789
- thinkingSignature?: string;
10790
- redacted?: boolean;
10791
10786
  } | {
10792
10787
  addedToolNames?: string[];
10793
10788
  arguments: Record<string, any>;
10794
10789
  callID: string;
10795
10790
  name: string;
10796
10791
  namespace?: string;
10797
- partial?: {
10798
- content?: ({
10792
+ result: {
10793
+ content: ({
10799
10794
  type: "text";
10800
10795
  text: string;
10801
10796
  textSignature?: string;
@@ -10805,8 +10800,9 @@ declare const Definitions: readonly [Schema.Struct<{
10805
10800
  mimeType: string;
10806
10801
  })[];
10807
10802
  details?: any;
10803
+ isError: false;
10808
10804
  };
10809
- status: "running";
10805
+ status: "completed";
10810
10806
  thoughtSignature?: string;
10811
10807
  time: {
10812
10808
  start: number;
@@ -10830,9 +10826,9 @@ declare const Definitions: readonly [Schema.Struct<{
10830
10826
  mimeType: string;
10831
10827
  })[];
10832
10828
  details?: any;
10833
- isError: false;
10829
+ isError: true;
10834
10830
  };
10835
- status: "completed";
10831
+ status: "error";
10836
10832
  thoughtSignature?: string;
10837
10833
  time: {
10838
10834
  start: number;
@@ -10858,7 +10854,7 @@ declare const Definitions: readonly [Schema.Struct<{
10858
10854
  details?: any;
10859
10855
  isError: true;
10860
10856
  };
10861
- status: "error";
10857
+ status: "skipped";
10862
10858
  thoughtSignature?: string;
10863
10859
  time: {
10864
10860
  start: number;
@@ -10884,21 +10880,26 @@ declare const Definitions: readonly [Schema.Struct<{
10884
10880
  details?: any;
10885
10881
  isError: true;
10886
10882
  };
10887
- status: "skipped";
10883
+ status: "aborted";
10888
10884
  thoughtSignature?: string;
10889
10885
  time: {
10890
10886
  start: number;
10891
10887
  end: number;
10892
10888
  };
10893
10889
  type: "toolCall";
10890
+ } | {
10891
+ type: "thinking";
10892
+ thinking: string;
10893
+ thinkingSignature?: string;
10894
+ redacted?: boolean;
10894
10895
  } | {
10895
10896
  addedToolNames?: string[];
10896
10897
  arguments: Record<string, any>;
10897
10898
  callID: string;
10898
10899
  name: string;
10899
10900
  namespace?: string;
10900
- result: {
10901
- content: ({
10901
+ partial?: {
10902
+ content?: ({
10902
10903
  type: "text";
10903
10904
  text: string;
10904
10905
  textSignature?: string;
@@ -10908,9 +10909,8 @@ declare const Definitions: readonly [Schema.Struct<{
10908
10909
  mimeType: string;
10909
10910
  })[];
10910
10911
  details?: any;
10911
- isError: true;
10912
10912
  };
10913
- status: "aborted";
10913
+ status: "running";
10914
10914
  thoughtSignature?: string;
10915
10915
  time: {
10916
10916
  start: number;
@@ -11103,19 +11103,14 @@ declare const Definitions: readonly [Schema.Struct<{
11103
11103
  type: "image";
11104
11104
  data: string;
11105
11105
  mimeType: string;
11106
- } | {
11107
- type: "thinking";
11108
- thinking: string;
11109
- thinkingSignature?: string;
11110
- redacted?: boolean;
11111
11106
  } | {
11112
11107
  addedToolNames?: string[];
11113
11108
  arguments: Record<string, any>;
11114
11109
  callID: string;
11115
11110
  name: string;
11116
11111
  namespace?: string;
11117
- partial?: {
11118
- content?: ({
11112
+ result: {
11113
+ content: ({
11119
11114
  type: "text";
11120
11115
  text: string;
11121
11116
  textSignature?: string;
@@ -11125,8 +11120,9 @@ declare const Definitions: readonly [Schema.Struct<{
11125
11120
  mimeType: string;
11126
11121
  })[];
11127
11122
  details?: any;
11123
+ isError: false;
11128
11124
  };
11129
- status: "running";
11125
+ status: "completed";
11130
11126
  thoughtSignature?: string;
11131
11127
  time: {
11132
11128
  start: number;
@@ -11150,9 +11146,9 @@ declare const Definitions: readonly [Schema.Struct<{
11150
11146
  mimeType: string;
11151
11147
  })[];
11152
11148
  details?: any;
11153
- isError: false;
11149
+ isError: true;
11154
11150
  };
11155
- status: "completed";
11151
+ status: "error";
11156
11152
  thoughtSignature?: string;
11157
11153
  time: {
11158
11154
  start: number;
@@ -11178,7 +11174,7 @@ declare const Definitions: readonly [Schema.Struct<{
11178
11174
  details?: any;
11179
11175
  isError: true;
11180
11176
  };
11181
- status: "error";
11177
+ status: "skipped";
11182
11178
  thoughtSignature?: string;
11183
11179
  time: {
11184
11180
  start: number;
@@ -11204,21 +11200,26 @@ declare const Definitions: readonly [Schema.Struct<{
11204
11200
  details?: any;
11205
11201
  isError: true;
11206
11202
  };
11207
- status: "skipped";
11203
+ status: "aborted";
11208
11204
  thoughtSignature?: string;
11209
11205
  time: {
11210
11206
  start: number;
11211
11207
  end: number;
11212
11208
  };
11213
11209
  type: "toolCall";
11210
+ } | {
11211
+ type: "thinking";
11212
+ thinking: string;
11213
+ thinkingSignature?: string;
11214
+ redacted?: boolean;
11214
11215
  } | {
11215
11216
  addedToolNames?: string[];
11216
11217
  arguments: Record<string, any>;
11217
11218
  callID: string;
11218
11219
  name: string;
11219
11220
  namespace?: string;
11220
- result: {
11221
- content: ({
11221
+ partial?: {
11222
+ content?: ({
11222
11223
  type: "text";
11223
11224
  text: string;
11224
11225
  textSignature?: string;
@@ -11228,9 +11229,8 @@ declare const Definitions: readonly [Schema.Struct<{
11228
11229
  mimeType: string;
11229
11230
  })[];
11230
11231
  details?: any;
11231
- isError: true;
11232
11232
  };
11233
- status: "aborted";
11233
+ status: "running";
11234
11234
  thoughtSignature?: string;
11235
11235
  time: {
11236
11236
  start: number;
@@ -11405,19 +11405,14 @@ declare const Definitions: readonly [Schema.Struct<{
11405
11405
  type: "image";
11406
11406
  data: string;
11407
11407
  mimeType: string;
11408
- } | {
11409
- type: "thinking";
11410
- thinking: string;
11411
- thinkingSignature?: string;
11412
- redacted?: boolean;
11413
11408
  } | {
11414
11409
  addedToolNames?: string[];
11415
11410
  arguments: Record<string, any>;
11416
11411
  callID: string;
11417
11412
  name: string;
11418
11413
  namespace?: string;
11419
- partial?: {
11420
- content?: ({
11414
+ result: {
11415
+ content: ({
11421
11416
  type: "text";
11422
11417
  text: string;
11423
11418
  textSignature?: string;
@@ -11427,8 +11422,9 @@ declare const Definitions: readonly [Schema.Struct<{
11427
11422
  mimeType: string;
11428
11423
  })[];
11429
11424
  details?: any;
11425
+ isError: false;
11430
11426
  };
11431
- status: "running";
11427
+ status: "completed";
11432
11428
  thoughtSignature?: string;
11433
11429
  time: {
11434
11430
  start: number;
@@ -11452,9 +11448,9 @@ declare const Definitions: readonly [Schema.Struct<{
11452
11448
  mimeType: string;
11453
11449
  })[];
11454
11450
  details?: any;
11455
- isError: false;
11451
+ isError: true;
11456
11452
  };
11457
- status: "completed";
11453
+ status: "error";
11458
11454
  thoughtSignature?: string;
11459
11455
  time: {
11460
11456
  start: number;
@@ -11480,7 +11476,7 @@ declare const Definitions: readonly [Schema.Struct<{
11480
11476
  details?: any;
11481
11477
  isError: true;
11482
11478
  };
11483
- status: "error";
11479
+ status: "skipped";
11484
11480
  thoughtSignature?: string;
11485
11481
  time: {
11486
11482
  start: number;
@@ -11506,21 +11502,26 @@ declare const Definitions: readonly [Schema.Struct<{
11506
11502
  details?: any;
11507
11503
  isError: true;
11508
11504
  };
11509
- status: "skipped";
11505
+ status: "aborted";
11510
11506
  thoughtSignature?: string;
11511
11507
  time: {
11512
11508
  start: number;
11513
11509
  end: number;
11514
11510
  };
11515
11511
  type: "toolCall";
11512
+ } | {
11513
+ type: "thinking";
11514
+ thinking: string;
11515
+ thinkingSignature?: string;
11516
+ redacted?: boolean;
11516
11517
  } | {
11517
11518
  addedToolNames?: string[];
11518
11519
  arguments: Record<string, any>;
11519
11520
  callID: string;
11520
11521
  name: string;
11521
11522
  namespace?: string;
11522
- result: {
11523
- content: ({
11523
+ partial?: {
11524
+ content?: ({
11524
11525
  type: "text";
11525
11526
  text: string;
11526
11527
  textSignature?: string;
@@ -11530,9 +11531,8 @@ declare const Definitions: readonly [Schema.Struct<{
11530
11531
  mimeType: string;
11531
11532
  })[];
11532
11533
  details?: any;
11533
- isError: true;
11534
11534
  };
11535
- status: "aborted";
11535
+ status: "running";
11536
11536
  thoughtSignature?: string;
11537
11537
  time: {
11538
11538
  start: number;
@@ -12013,19 +12013,14 @@ declare const Definitions: readonly [Schema.Struct<{
12013
12013
  type: "image";
12014
12014
  data: string;
12015
12015
  mimeType: string;
12016
- } | {
12017
- type: "thinking";
12018
- thinking: string;
12019
- thinkingSignature?: string;
12020
- redacted?: boolean;
12021
12016
  } | {
12022
12017
  addedToolNames?: string[];
12023
12018
  arguments: Record<string, any>;
12024
12019
  callID: string;
12025
12020
  name: string;
12026
12021
  namespace?: string;
12027
- partial?: {
12028
- content?: ({
12022
+ result: {
12023
+ content: ({
12029
12024
  type: "text";
12030
12025
  text: string;
12031
12026
  textSignature?: string;
@@ -12035,8 +12030,9 @@ declare const Definitions: readonly [Schema.Struct<{
12035
12030
  mimeType: string;
12036
12031
  })[];
12037
12032
  details?: any;
12033
+ isError: false;
12038
12034
  };
12039
- status: "running";
12035
+ status: "completed";
12040
12036
  thoughtSignature?: string;
12041
12037
  time: {
12042
12038
  start: number;
@@ -12060,9 +12056,9 @@ declare const Definitions: readonly [Schema.Struct<{
12060
12056
  mimeType: string;
12061
12057
  })[];
12062
12058
  details?: any;
12063
- isError: false;
12059
+ isError: true;
12064
12060
  };
12065
- status: "completed";
12061
+ status: "error";
12066
12062
  thoughtSignature?: string;
12067
12063
  time: {
12068
12064
  start: number;
@@ -12088,7 +12084,7 @@ declare const Definitions: readonly [Schema.Struct<{
12088
12084
  details?: any;
12089
12085
  isError: true;
12090
12086
  };
12091
- status: "error";
12087
+ status: "skipped";
12092
12088
  thoughtSignature?: string;
12093
12089
  time: {
12094
12090
  start: number;
@@ -12114,21 +12110,26 @@ declare const Definitions: readonly [Schema.Struct<{
12114
12110
  details?: any;
12115
12111
  isError: true;
12116
12112
  };
12117
- status: "skipped";
12113
+ status: "aborted";
12118
12114
  thoughtSignature?: string;
12119
12115
  time: {
12120
12116
  start: number;
12121
12117
  end: number;
12122
12118
  };
12123
12119
  type: "toolCall";
12120
+ } | {
12121
+ type: "thinking";
12122
+ thinking: string;
12123
+ thinkingSignature?: string;
12124
+ redacted?: boolean;
12124
12125
  } | {
12125
12126
  addedToolNames?: string[];
12126
12127
  arguments: Record<string, any>;
12127
12128
  callID: string;
12128
12129
  name: string;
12129
12130
  namespace?: string;
12130
- result: {
12131
- content: ({
12131
+ partial?: {
12132
+ content?: ({
12132
12133
  type: "text";
12133
12134
  text: string;
12134
12135
  textSignature?: string;
@@ -12138,9 +12139,8 @@ declare const Definitions: readonly [Schema.Struct<{
12138
12139
  mimeType: string;
12139
12140
  })[];
12140
12141
  details?: any;
12141
- isError: true;
12142
12142
  };
12143
- status: "aborted";
12143
+ status: "running";
12144
12144
  thoughtSignature?: string;
12145
12145
  time: {
12146
12146
  start: number;
@@ -12315,19 +12315,14 @@ declare const Definitions: readonly [Schema.Struct<{
12315
12315
  type: "image";
12316
12316
  data: string;
12317
12317
  mimeType: string;
12318
- } | {
12319
- type: "thinking";
12320
- thinking: string;
12321
- thinkingSignature?: string;
12322
- redacted?: boolean;
12323
12318
  } | {
12324
12319
  addedToolNames?: string[];
12325
12320
  arguments: Record<string, any>;
12326
12321
  callID: string;
12327
12322
  name: string;
12328
12323
  namespace?: string;
12329
- partial?: {
12330
- content?: ({
12324
+ result: {
12325
+ content: ({
12331
12326
  type: "text";
12332
12327
  text: string;
12333
12328
  textSignature?: string;
@@ -12337,8 +12332,9 @@ declare const Definitions: readonly [Schema.Struct<{
12337
12332
  mimeType: string;
12338
12333
  })[];
12339
12334
  details?: any;
12335
+ isError: false;
12340
12336
  };
12341
- status: "running";
12337
+ status: "completed";
12342
12338
  thoughtSignature?: string;
12343
12339
  time: {
12344
12340
  start: number;
@@ -12362,9 +12358,9 @@ declare const Definitions: readonly [Schema.Struct<{
12362
12358
  mimeType: string;
12363
12359
  })[];
12364
12360
  details?: any;
12365
- isError: false;
12361
+ isError: true;
12366
12362
  };
12367
- status: "completed";
12363
+ status: "error";
12368
12364
  thoughtSignature?: string;
12369
12365
  time: {
12370
12366
  start: number;
@@ -12390,7 +12386,7 @@ declare const Definitions: readonly [Schema.Struct<{
12390
12386
  details?: any;
12391
12387
  isError: true;
12392
12388
  };
12393
- status: "error";
12389
+ status: "skipped";
12394
12390
  thoughtSignature?: string;
12395
12391
  time: {
12396
12392
  start: number;
@@ -12416,21 +12412,26 @@ declare const Definitions: readonly [Schema.Struct<{
12416
12412
  details?: any;
12417
12413
  isError: true;
12418
12414
  };
12419
- status: "skipped";
12415
+ status: "aborted";
12420
12416
  thoughtSignature?: string;
12421
12417
  time: {
12422
12418
  start: number;
12423
12419
  end: number;
12424
12420
  };
12425
12421
  type: "toolCall";
12422
+ } | {
12423
+ type: "thinking";
12424
+ thinking: string;
12425
+ thinkingSignature?: string;
12426
+ redacted?: boolean;
12426
12427
  } | {
12427
12428
  addedToolNames?: string[];
12428
12429
  arguments: Record<string, any>;
12429
12430
  callID: string;
12430
12431
  name: string;
12431
12432
  namespace?: string;
12432
- result: {
12433
- content: ({
12433
+ partial?: {
12434
+ content?: ({
12434
12435
  type: "text";
12435
12436
  text: string;
12436
12437
  textSignature?: string;
@@ -12440,9 +12441,8 @@ declare const Definitions: readonly [Schema.Struct<{
12440
12441
  mimeType: string;
12441
12442
  })[];
12442
12443
  details?: any;
12443
- isError: true;
12444
12444
  };
12445
- status: "aborted";
12445
+ status: "running";
12446
12446
  thoughtSignature?: string;
12447
12447
  time: {
12448
12448
  start: number;
@@ -12636,19 +12636,14 @@ declare const Definitions: readonly [Schema.Struct<{
12636
12636
  type: "image";
12637
12637
  data: string;
12638
12638
  mimeType: string;
12639
- } | {
12640
- type: "thinking";
12641
- thinking: string;
12642
- thinkingSignature?: string;
12643
- redacted?: boolean;
12644
12639
  } | {
12645
12640
  addedToolNames?: string[];
12646
12641
  arguments: Record<string, any>;
12647
12642
  callID: string;
12648
12643
  name: string;
12649
12644
  namespace?: string;
12650
- partial?: {
12651
- content?: ({
12645
+ result: {
12646
+ content: ({
12652
12647
  type: "text";
12653
12648
  text: string;
12654
12649
  textSignature?: string;
@@ -12658,8 +12653,9 @@ declare const Definitions: readonly [Schema.Struct<{
12658
12653
  mimeType: string;
12659
12654
  })[];
12660
12655
  details?: any;
12656
+ isError: false;
12661
12657
  };
12662
- status: "running";
12658
+ status: "completed";
12663
12659
  thoughtSignature?: string;
12664
12660
  time: {
12665
12661
  start: number;
@@ -12683,9 +12679,9 @@ declare const Definitions: readonly [Schema.Struct<{
12683
12679
  mimeType: string;
12684
12680
  })[];
12685
12681
  details?: any;
12686
- isError: false;
12682
+ isError: true;
12687
12683
  };
12688
- status: "completed";
12684
+ status: "error";
12689
12685
  thoughtSignature?: string;
12690
12686
  time: {
12691
12687
  start: number;
@@ -12711,7 +12707,7 @@ declare const Definitions: readonly [Schema.Struct<{
12711
12707
  details?: any;
12712
12708
  isError: true;
12713
12709
  };
12714
- status: "error";
12710
+ status: "skipped";
12715
12711
  thoughtSignature?: string;
12716
12712
  time: {
12717
12713
  start: number;
@@ -12737,21 +12733,26 @@ declare const Definitions: readonly [Schema.Struct<{
12737
12733
  details?: any;
12738
12734
  isError: true;
12739
12735
  };
12740
- status: "skipped";
12736
+ status: "aborted";
12741
12737
  thoughtSignature?: string;
12742
12738
  time: {
12743
12739
  start: number;
12744
12740
  end: number;
12745
12741
  };
12746
12742
  type: "toolCall";
12743
+ } | {
12744
+ type: "thinking";
12745
+ thinking: string;
12746
+ thinkingSignature?: string;
12747
+ redacted?: boolean;
12747
12748
  } | {
12748
12749
  addedToolNames?: string[];
12749
12750
  arguments: Record<string, any>;
12750
12751
  callID: string;
12751
12752
  name: string;
12752
12753
  namespace?: string;
12753
- result: {
12754
- content: ({
12754
+ partial?: {
12755
+ content?: ({
12755
12756
  type: "text";
12756
12757
  text: string;
12757
12758
  textSignature?: string;
@@ -12761,9 +12762,8 @@ declare const Definitions: readonly [Schema.Struct<{
12761
12762
  mimeType: string;
12762
12763
  })[];
12763
12764
  details?: any;
12764
- isError: true;
12765
12765
  };
12766
- status: "aborted";
12766
+ status: "running";
12767
12767
  thoughtSignature?: string;
12768
12768
  time: {
12769
12769
  start: number;
@@ -12938,19 +12938,14 @@ declare const Definitions: readonly [Schema.Struct<{
12938
12938
  type: "image";
12939
12939
  data: string;
12940
12940
  mimeType: string;
12941
- } | {
12942
- type: "thinking";
12943
- thinking: string;
12944
- thinkingSignature?: string;
12945
- redacted?: boolean;
12946
12941
  } | {
12947
12942
  addedToolNames?: string[];
12948
12943
  arguments: Record<string, any>;
12949
12944
  callID: string;
12950
12945
  name: string;
12951
12946
  namespace?: string;
12952
- partial?: {
12953
- content?: ({
12947
+ result: {
12948
+ content: ({
12954
12949
  type: "text";
12955
12950
  text: string;
12956
12951
  textSignature?: string;
@@ -12960,8 +12955,9 @@ declare const Definitions: readonly [Schema.Struct<{
12960
12955
  mimeType: string;
12961
12956
  })[];
12962
12957
  details?: any;
12958
+ isError: false;
12963
12959
  };
12964
- status: "running";
12960
+ status: "completed";
12965
12961
  thoughtSignature?: string;
12966
12962
  time: {
12967
12963
  start: number;
@@ -12985,9 +12981,9 @@ declare const Definitions: readonly [Schema.Struct<{
12985
12981
  mimeType: string;
12986
12982
  })[];
12987
12983
  details?: any;
12988
- isError: false;
12984
+ isError: true;
12989
12985
  };
12990
- status: "completed";
12986
+ status: "error";
12991
12987
  thoughtSignature?: string;
12992
12988
  time: {
12993
12989
  start: number;
@@ -13013,7 +13009,7 @@ declare const Definitions: readonly [Schema.Struct<{
13013
13009
  details?: any;
13014
13010
  isError: true;
13015
13011
  };
13016
- status: "error";
13012
+ status: "skipped";
13017
13013
  thoughtSignature?: string;
13018
13014
  time: {
13019
13015
  start: number;
@@ -13039,21 +13035,26 @@ declare const Definitions: readonly [Schema.Struct<{
13039
13035
  details?: any;
13040
13036
  isError: true;
13041
13037
  };
13042
- status: "skipped";
13038
+ status: "aborted";
13043
13039
  thoughtSignature?: string;
13044
13040
  time: {
13045
13041
  start: number;
13046
13042
  end: number;
13047
13043
  };
13048
13044
  type: "toolCall";
13045
+ } | {
13046
+ type: "thinking";
13047
+ thinking: string;
13048
+ thinkingSignature?: string;
13049
+ redacted?: boolean;
13049
13050
  } | {
13050
13051
  addedToolNames?: string[];
13051
13052
  arguments: Record<string, any>;
13052
13053
  callID: string;
13053
13054
  name: string;
13054
13055
  namespace?: string;
13055
- result: {
13056
- content: ({
13056
+ partial?: {
13057
+ content?: ({
13057
13058
  type: "text";
13058
13059
  text: string;
13059
13060
  textSignature?: string;
@@ -13063,9 +13064,8 @@ declare const Definitions: readonly [Schema.Struct<{
13063
13064
  mimeType: string;
13064
13065
  })[];
13065
13066
  details?: any;
13066
- isError: true;
13067
13067
  };
13068
- status: "aborted";
13068
+ status: "running";
13069
13069
  thoughtSignature?: string;
13070
13070
  time: {
13071
13071
  start: number;
@@ -13268,19 +13268,14 @@ declare const Definitions: readonly [Schema.Struct<{
13268
13268
  type: "image";
13269
13269
  data: string;
13270
13270
  mimeType: string;
13271
- } | {
13272
- type: "thinking";
13273
- thinking: string;
13274
- thinkingSignature?: string;
13275
- redacted?: boolean;
13276
13271
  } | {
13277
13272
  addedToolNames?: string[];
13278
13273
  arguments: Record<string, any>;
13279
13274
  callID: string;
13280
13275
  name: string;
13281
13276
  namespace?: string;
13282
- partial?: {
13283
- content?: ({
13277
+ result: {
13278
+ content: ({
13284
13279
  type: "text";
13285
13280
  text: string;
13286
13281
  textSignature?: string;
@@ -13290,8 +13285,9 @@ declare const Definitions: readonly [Schema.Struct<{
13290
13285
  mimeType: string;
13291
13286
  })[];
13292
13287
  details?: any;
13288
+ isError: false;
13293
13289
  };
13294
- status: "running";
13290
+ status: "completed";
13295
13291
  thoughtSignature?: string;
13296
13292
  time: {
13297
13293
  start: number;
@@ -13315,9 +13311,9 @@ declare const Definitions: readonly [Schema.Struct<{
13315
13311
  mimeType: string;
13316
13312
  })[];
13317
13313
  details?: any;
13318
- isError: false;
13314
+ isError: true;
13319
13315
  };
13320
- status: "completed";
13316
+ status: "error";
13321
13317
  thoughtSignature?: string;
13322
13318
  time: {
13323
13319
  start: number;
@@ -13343,7 +13339,7 @@ declare const Definitions: readonly [Schema.Struct<{
13343
13339
  details?: any;
13344
13340
  isError: true;
13345
13341
  };
13346
- status: "error";
13342
+ status: "skipped";
13347
13343
  thoughtSignature?: string;
13348
13344
  time: {
13349
13345
  start: number;
@@ -13369,21 +13365,26 @@ declare const Definitions: readonly [Schema.Struct<{
13369
13365
  details?: any;
13370
13366
  isError: true;
13371
13367
  };
13372
- status: "skipped";
13368
+ status: "aborted";
13373
13369
  thoughtSignature?: string;
13374
13370
  time: {
13375
13371
  start: number;
13376
13372
  end: number;
13377
13373
  };
13378
13374
  type: "toolCall";
13375
+ } | {
13376
+ type: "thinking";
13377
+ thinking: string;
13378
+ thinkingSignature?: string;
13379
+ redacted?: boolean;
13379
13380
  } | {
13380
13381
  addedToolNames?: string[];
13381
13382
  arguments: Record<string, any>;
13382
13383
  callID: string;
13383
13384
  name: string;
13384
13385
  namespace?: string;
13385
- result: {
13386
- content: ({
13386
+ partial?: {
13387
+ content?: ({
13387
13388
  type: "text";
13388
13389
  text: string;
13389
13390
  textSignature?: string;
@@ -13393,9 +13394,8 @@ declare const Definitions: readonly [Schema.Struct<{
13393
13394
  mimeType: string;
13394
13395
  })[];
13395
13396
  details?: any;
13396
- isError: true;
13397
13397
  };
13398
- status: "aborted";
13398
+ status: "running";
13399
13399
  thoughtSignature?: string;
13400
13400
  time: {
13401
13401
  start: number;
@@ -13570,19 +13570,14 @@ declare const Definitions: readonly [Schema.Struct<{
13570
13570
  type: "image";
13571
13571
  data: string;
13572
13572
  mimeType: string;
13573
- } | {
13574
- type: "thinking";
13575
- thinking: string;
13576
- thinkingSignature?: string;
13577
- redacted?: boolean;
13578
13573
  } | {
13579
13574
  addedToolNames?: string[];
13580
13575
  arguments: Record<string, any>;
13581
13576
  callID: string;
13582
13577
  name: string;
13583
13578
  namespace?: string;
13584
- partial?: {
13585
- content?: ({
13579
+ result: {
13580
+ content: ({
13586
13581
  type: "text";
13587
13582
  text: string;
13588
13583
  textSignature?: string;
@@ -13592,8 +13587,9 @@ declare const Definitions: readonly [Schema.Struct<{
13592
13587
  mimeType: string;
13593
13588
  })[];
13594
13589
  details?: any;
13590
+ isError: false;
13595
13591
  };
13596
- status: "running";
13592
+ status: "completed";
13597
13593
  thoughtSignature?: string;
13598
13594
  time: {
13599
13595
  start: number;
@@ -13617,9 +13613,9 @@ declare const Definitions: readonly [Schema.Struct<{
13617
13613
  mimeType: string;
13618
13614
  })[];
13619
13615
  details?: any;
13620
- isError: false;
13616
+ isError: true;
13621
13617
  };
13622
- status: "completed";
13618
+ status: "error";
13623
13619
  thoughtSignature?: string;
13624
13620
  time: {
13625
13621
  start: number;
@@ -13645,7 +13641,7 @@ declare const Definitions: readonly [Schema.Struct<{
13645
13641
  details?: any;
13646
13642
  isError: true;
13647
13643
  };
13648
- status: "error";
13644
+ status: "skipped";
13649
13645
  thoughtSignature?: string;
13650
13646
  time: {
13651
13647
  start: number;
@@ -13671,21 +13667,26 @@ declare const Definitions: readonly [Schema.Struct<{
13671
13667
  details?: any;
13672
13668
  isError: true;
13673
13669
  };
13674
- status: "skipped";
13670
+ status: "aborted";
13675
13671
  thoughtSignature?: string;
13676
13672
  time: {
13677
13673
  start: number;
13678
13674
  end: number;
13679
13675
  };
13680
13676
  type: "toolCall";
13677
+ } | {
13678
+ type: "thinking";
13679
+ thinking: string;
13680
+ thinkingSignature?: string;
13681
+ redacted?: boolean;
13681
13682
  } | {
13682
13683
  addedToolNames?: string[];
13683
13684
  arguments: Record<string, any>;
13684
13685
  callID: string;
13685
13686
  name: string;
13686
13687
  namespace?: string;
13687
- result: {
13688
- content: ({
13688
+ partial?: {
13689
+ content?: ({
13689
13690
  type: "text";
13690
13691
  text: string;
13691
13692
  textSignature?: string;
@@ -13695,9 +13696,8 @@ declare const Definitions: readonly [Schema.Struct<{
13695
13696
  mimeType: string;
13696
13697
  })[];
13697
13698
  details?: any;
13698
- isError: true;
13699
13699
  };
13700
- status: "aborted";
13700
+ status: "running";
13701
13701
  thoughtSignature?: string;
13702
13702
  time: {
13703
13703
  start: number;
@@ -13891,19 +13891,14 @@ declare const Definitions: readonly [Schema.Struct<{
13891
13891
  type: "image";
13892
13892
  data: string;
13893
13893
  mimeType: string;
13894
- } | {
13895
- type: "thinking";
13896
- thinking: string;
13897
- thinkingSignature?: string;
13898
- redacted?: boolean;
13899
13894
  } | {
13900
13895
  addedToolNames?: string[];
13901
13896
  arguments: Record<string, any>;
13902
13897
  callID: string;
13903
13898
  name: string;
13904
13899
  namespace?: string;
13905
- partial?: {
13906
- content?: ({
13900
+ result: {
13901
+ content: ({
13907
13902
  type: "text";
13908
13903
  text: string;
13909
13904
  textSignature?: string;
@@ -13913,8 +13908,9 @@ declare const Definitions: readonly [Schema.Struct<{
13913
13908
  mimeType: string;
13914
13909
  })[];
13915
13910
  details?: any;
13911
+ isError: false;
13916
13912
  };
13917
- status: "running";
13913
+ status: "completed";
13918
13914
  thoughtSignature?: string;
13919
13915
  time: {
13920
13916
  start: number;
@@ -13938,9 +13934,9 @@ declare const Definitions: readonly [Schema.Struct<{
13938
13934
  mimeType: string;
13939
13935
  })[];
13940
13936
  details?: any;
13941
- isError: false;
13937
+ isError: true;
13942
13938
  };
13943
- status: "completed";
13939
+ status: "error";
13944
13940
  thoughtSignature?: string;
13945
13941
  time: {
13946
13942
  start: number;
@@ -13966,7 +13962,7 @@ declare const Definitions: readonly [Schema.Struct<{
13966
13962
  details?: any;
13967
13963
  isError: true;
13968
13964
  };
13969
- status: "error";
13965
+ status: "skipped";
13970
13966
  thoughtSignature?: string;
13971
13967
  time: {
13972
13968
  start: number;
@@ -13992,21 +13988,26 @@ declare const Definitions: readonly [Schema.Struct<{
13992
13988
  details?: any;
13993
13989
  isError: true;
13994
13990
  };
13995
- status: "skipped";
13991
+ status: "aborted";
13996
13992
  thoughtSignature?: string;
13997
13993
  time: {
13998
13994
  start: number;
13999
13995
  end: number;
14000
13996
  };
14001
13997
  type: "toolCall";
13998
+ } | {
13999
+ type: "thinking";
14000
+ thinking: string;
14001
+ thinkingSignature?: string;
14002
+ redacted?: boolean;
14002
14003
  } | {
14003
14004
  addedToolNames?: string[];
14004
14005
  arguments: Record<string, any>;
14005
14006
  callID: string;
14006
14007
  name: string;
14007
14008
  namespace?: string;
14008
- result: {
14009
- content: ({
14009
+ partial?: {
14010
+ content?: ({
14010
14011
  type: "text";
14011
14012
  text: string;
14012
14013
  textSignature?: string;
@@ -14016,9 +14017,8 @@ declare const Definitions: readonly [Schema.Struct<{
14016
14017
  mimeType: string;
14017
14018
  })[];
14018
14019
  details?: any;
14019
- isError: true;
14020
14020
  };
14021
- status: "aborted";
14021
+ status: "running";
14022
14022
  thoughtSignature?: string;
14023
14023
  time: {
14024
14024
  start: number;
@@ -14193,19 +14193,14 @@ declare const Definitions: readonly [Schema.Struct<{
14193
14193
  type: "image";
14194
14194
  data: string;
14195
14195
  mimeType: string;
14196
- } | {
14197
- type: "thinking";
14198
- thinking: string;
14199
- thinkingSignature?: string;
14200
- redacted?: boolean;
14201
14196
  } | {
14202
14197
  addedToolNames?: string[];
14203
14198
  arguments: Record<string, any>;
14204
14199
  callID: string;
14205
14200
  name: string;
14206
14201
  namespace?: string;
14207
- partial?: {
14208
- content?: ({
14202
+ result: {
14203
+ content: ({
14209
14204
  type: "text";
14210
14205
  text: string;
14211
14206
  textSignature?: string;
@@ -14215,8 +14210,9 @@ declare const Definitions: readonly [Schema.Struct<{
14215
14210
  mimeType: string;
14216
14211
  })[];
14217
14212
  details?: any;
14213
+ isError: false;
14218
14214
  };
14219
- status: "running";
14215
+ status: "completed";
14220
14216
  thoughtSignature?: string;
14221
14217
  time: {
14222
14218
  start: number;
@@ -14240,9 +14236,9 @@ declare const Definitions: readonly [Schema.Struct<{
14240
14236
  mimeType: string;
14241
14237
  })[];
14242
14238
  details?: any;
14243
- isError: false;
14239
+ isError: true;
14244
14240
  };
14245
- status: "completed";
14241
+ status: "error";
14246
14242
  thoughtSignature?: string;
14247
14243
  time: {
14248
14244
  start: number;
@@ -14268,7 +14264,7 @@ declare const Definitions: readonly [Schema.Struct<{
14268
14264
  details?: any;
14269
14265
  isError: true;
14270
14266
  };
14271
- status: "error";
14267
+ status: "skipped";
14272
14268
  thoughtSignature?: string;
14273
14269
  time: {
14274
14270
  start: number;
@@ -14294,21 +14290,26 @@ declare const Definitions: readonly [Schema.Struct<{
14294
14290
  details?: any;
14295
14291
  isError: true;
14296
14292
  };
14297
- status: "skipped";
14293
+ status: "aborted";
14298
14294
  thoughtSignature?: string;
14299
14295
  time: {
14300
14296
  start: number;
14301
14297
  end: number;
14302
14298
  };
14303
14299
  type: "toolCall";
14300
+ } | {
14301
+ type: "thinking";
14302
+ thinking: string;
14303
+ thinkingSignature?: string;
14304
+ redacted?: boolean;
14304
14305
  } | {
14305
14306
  addedToolNames?: string[];
14306
14307
  arguments: Record<string, any>;
14307
14308
  callID: string;
14308
14309
  name: string;
14309
14310
  namespace?: string;
14310
- result: {
14311
- content: ({
14311
+ partial?: {
14312
+ content?: ({
14312
14313
  type: "text";
14313
14314
  text: string;
14314
14315
  textSignature?: string;
@@ -14318,9 +14319,8 @@ declare const Definitions: readonly [Schema.Struct<{
14318
14319
  mimeType: string;
14319
14320
  })[];
14320
14321
  details?: any;
14321
- isError: true;
14322
14322
  };
14323
- status: "aborted";
14323
+ status: "running";
14324
14324
  thoughtSignature?: string;
14325
14325
  time: {
14326
14326
  start: number;
@@ -15829,19 +15829,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15829
15829
  type: "image";
15830
15830
  data: string;
15831
15831
  mimeType: string;
15832
- } | {
15833
- type: "thinking";
15834
- thinking: string;
15835
- thinkingSignature?: string;
15836
- redacted?: boolean;
15837
15832
  } | {
15838
15833
  addedToolNames?: string[];
15839
15834
  arguments: Record<string, any>;
15840
15835
  callID: string;
15841
15836
  name: string;
15842
15837
  namespace?: string;
15843
- partial?: {
15844
- content?: ({
15838
+ result: {
15839
+ content: ({
15845
15840
  type: "text";
15846
15841
  text: string;
15847
15842
  textSignature?: string;
@@ -15851,8 +15846,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15851
15846
  mimeType: string;
15852
15847
  })[];
15853
15848
  details?: any;
15849
+ isError: false;
15854
15850
  };
15855
- status: "running";
15851
+ status: "completed";
15856
15852
  thoughtSignature?: string;
15857
15853
  time: {
15858
15854
  start: number;
@@ -15876,9 +15872,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15876
15872
  mimeType: string;
15877
15873
  })[];
15878
15874
  details?: any;
15879
- isError: false;
15875
+ isError: true;
15880
15876
  };
15881
- status: "completed";
15877
+ status: "error";
15882
15878
  thoughtSignature?: string;
15883
15879
  time: {
15884
15880
  start: number;
@@ -15904,7 +15900,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15904
15900
  details?: any;
15905
15901
  isError: true;
15906
15902
  };
15907
- status: "error";
15903
+ status: "skipped";
15908
15904
  thoughtSignature?: string;
15909
15905
  time: {
15910
15906
  start: number;
@@ -15930,21 +15926,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15930
15926
  details?: any;
15931
15927
  isError: true;
15932
15928
  };
15933
- status: "skipped";
15929
+ status: "aborted";
15934
15930
  thoughtSignature?: string;
15935
15931
  time: {
15936
15932
  start: number;
15937
15933
  end: number;
15938
15934
  };
15939
15935
  type: "toolCall";
15936
+ } | {
15937
+ type: "thinking";
15938
+ thinking: string;
15939
+ thinkingSignature?: string;
15940
+ redacted?: boolean;
15940
15941
  } | {
15941
15942
  addedToolNames?: string[];
15942
15943
  arguments: Record<string, any>;
15943
15944
  callID: string;
15944
15945
  name: string;
15945
15946
  namespace?: string;
15946
- result: {
15947
- content: ({
15947
+ partial?: {
15948
+ content?: ({
15948
15949
  type: "text";
15949
15950
  text: string;
15950
15951
  textSignature?: string;
@@ -15954,9 +15955,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15954
15955
  mimeType: string;
15955
15956
  })[];
15956
15957
  details?: any;
15957
- isError: true;
15958
15958
  };
15959
- status: "aborted";
15959
+ status: "running";
15960
15960
  thoughtSignature?: string;
15961
15961
  time: {
15962
15962
  start: number;
@@ -16131,19 +16131,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16131
16131
  type: "image";
16132
16132
  data: string;
16133
16133
  mimeType: string;
16134
- } | {
16135
- type: "thinking";
16136
- thinking: string;
16137
- thinkingSignature?: string;
16138
- redacted?: boolean;
16139
16134
  } | {
16140
16135
  addedToolNames?: string[];
16141
16136
  arguments: Record<string, any>;
16142
16137
  callID: string;
16143
16138
  name: string;
16144
16139
  namespace?: string;
16145
- partial?: {
16146
- content?: ({
16140
+ result: {
16141
+ content: ({
16147
16142
  type: "text";
16148
16143
  text: string;
16149
16144
  textSignature?: string;
@@ -16153,8 +16148,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16153
16148
  mimeType: string;
16154
16149
  })[];
16155
16150
  details?: any;
16151
+ isError: false;
16156
16152
  };
16157
- status: "running";
16153
+ status: "completed";
16158
16154
  thoughtSignature?: string;
16159
16155
  time: {
16160
16156
  start: number;
@@ -16178,9 +16174,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16178
16174
  mimeType: string;
16179
16175
  })[];
16180
16176
  details?: any;
16181
- isError: false;
16177
+ isError: true;
16182
16178
  };
16183
- status: "completed";
16179
+ status: "error";
16184
16180
  thoughtSignature?: string;
16185
16181
  time: {
16186
16182
  start: number;
@@ -16206,7 +16202,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16206
16202
  details?: any;
16207
16203
  isError: true;
16208
16204
  };
16209
- status: "error";
16205
+ status: "skipped";
16210
16206
  thoughtSignature?: string;
16211
16207
  time: {
16212
16208
  start: number;
@@ -16232,21 +16228,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16232
16228
  details?: any;
16233
16229
  isError: true;
16234
16230
  };
16235
- status: "skipped";
16231
+ status: "aborted";
16236
16232
  thoughtSignature?: string;
16237
16233
  time: {
16238
16234
  start: number;
16239
16235
  end: number;
16240
16236
  };
16241
16237
  type: "toolCall";
16238
+ } | {
16239
+ type: "thinking";
16240
+ thinking: string;
16241
+ thinkingSignature?: string;
16242
+ redacted?: boolean;
16242
16243
  } | {
16243
16244
  addedToolNames?: string[];
16244
16245
  arguments: Record<string, any>;
16245
16246
  callID: string;
16246
16247
  name: string;
16247
16248
  namespace?: string;
16248
- result: {
16249
- content: ({
16249
+ partial?: {
16250
+ content?: ({
16250
16251
  type: "text";
16251
16252
  text: string;
16252
16253
  textSignature?: string;
@@ -16256,9 +16257,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16256
16257
  mimeType: string;
16257
16258
  })[];
16258
16259
  details?: any;
16259
- isError: true;
16260
16260
  };
16261
- status: "aborted";
16261
+ status: "running";
16262
16262
  thoughtSignature?: string;
16263
16263
  time: {
16264
16264
  start: number;
@@ -16451,19 +16451,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16451
16451
  type: "image";
16452
16452
  data: string;
16453
16453
  mimeType: string;
16454
- } | {
16455
- type: "thinking";
16456
- thinking: string;
16457
- thinkingSignature?: string;
16458
- redacted?: boolean;
16459
16454
  } | {
16460
16455
  addedToolNames?: string[];
16461
16456
  arguments: Record<string, any>;
16462
16457
  callID: string;
16463
16458
  name: string;
16464
16459
  namespace?: string;
16465
- partial?: {
16466
- content?: ({
16460
+ result: {
16461
+ content: ({
16467
16462
  type: "text";
16468
16463
  text: string;
16469
16464
  textSignature?: string;
@@ -16473,8 +16468,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16473
16468
  mimeType: string;
16474
16469
  })[];
16475
16470
  details?: any;
16471
+ isError: false;
16476
16472
  };
16477
- status: "running";
16473
+ status: "completed";
16478
16474
  thoughtSignature?: string;
16479
16475
  time: {
16480
16476
  start: number;
@@ -16498,9 +16494,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16498
16494
  mimeType: string;
16499
16495
  })[];
16500
16496
  details?: any;
16501
- isError: false;
16497
+ isError: true;
16502
16498
  };
16503
- status: "completed";
16499
+ status: "error";
16504
16500
  thoughtSignature?: string;
16505
16501
  time: {
16506
16502
  start: number;
@@ -16526,7 +16522,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16526
16522
  details?: any;
16527
16523
  isError: true;
16528
16524
  };
16529
- status: "error";
16525
+ status: "skipped";
16530
16526
  thoughtSignature?: string;
16531
16527
  time: {
16532
16528
  start: number;
@@ -16552,21 +16548,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16552
16548
  details?: any;
16553
16549
  isError: true;
16554
16550
  };
16555
- status: "skipped";
16551
+ status: "aborted";
16556
16552
  thoughtSignature?: string;
16557
16553
  time: {
16558
16554
  start: number;
16559
16555
  end: number;
16560
16556
  };
16561
16557
  type: "toolCall";
16558
+ } | {
16559
+ type: "thinking";
16560
+ thinking: string;
16561
+ thinkingSignature?: string;
16562
+ redacted?: boolean;
16562
16563
  } | {
16563
16564
  addedToolNames?: string[];
16564
16565
  arguments: Record<string, any>;
16565
16566
  callID: string;
16566
16567
  name: string;
16567
16568
  namespace?: string;
16568
- result: {
16569
- content: ({
16569
+ partial?: {
16570
+ content?: ({
16570
16571
  type: "text";
16571
16572
  text: string;
16572
16573
  textSignature?: string;
@@ -16576,9 +16577,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16576
16577
  mimeType: string;
16577
16578
  })[];
16578
16579
  details?: any;
16579
- isError: true;
16580
16580
  };
16581
- status: "aborted";
16581
+ status: "running";
16582
16582
  thoughtSignature?: string;
16583
16583
  time: {
16584
16584
  start: number;
@@ -16753,19 +16753,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16753
16753
  type: "image";
16754
16754
  data: string;
16755
16755
  mimeType: string;
16756
- } | {
16757
- type: "thinking";
16758
- thinking: string;
16759
- thinkingSignature?: string;
16760
- redacted?: boolean;
16761
16756
  } | {
16762
16757
  addedToolNames?: string[];
16763
16758
  arguments: Record<string, any>;
16764
16759
  callID: string;
16765
16760
  name: string;
16766
16761
  namespace?: string;
16767
- partial?: {
16768
- content?: ({
16762
+ result: {
16763
+ content: ({
16769
16764
  type: "text";
16770
16765
  text: string;
16771
16766
  textSignature?: string;
@@ -16775,8 +16770,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16775
16770
  mimeType: string;
16776
16771
  })[];
16777
16772
  details?: any;
16773
+ isError: false;
16778
16774
  };
16779
- status: "running";
16775
+ status: "completed";
16780
16776
  thoughtSignature?: string;
16781
16777
  time: {
16782
16778
  start: number;
@@ -16800,9 +16796,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16800
16796
  mimeType: string;
16801
16797
  })[];
16802
16798
  details?: any;
16803
- isError: false;
16799
+ isError: true;
16804
16800
  };
16805
- status: "completed";
16801
+ status: "error";
16806
16802
  thoughtSignature?: string;
16807
16803
  time: {
16808
16804
  start: number;
@@ -16828,7 +16824,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16828
16824
  details?: any;
16829
16825
  isError: true;
16830
16826
  };
16831
- status: "error";
16827
+ status: "skipped";
16832
16828
  thoughtSignature?: string;
16833
16829
  time: {
16834
16830
  start: number;
@@ -16854,21 +16850,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16854
16850
  details?: any;
16855
16851
  isError: true;
16856
16852
  };
16857
- status: "skipped";
16853
+ status: "aborted";
16858
16854
  thoughtSignature?: string;
16859
16855
  time: {
16860
16856
  start: number;
16861
16857
  end: number;
16862
16858
  };
16863
16859
  type: "toolCall";
16860
+ } | {
16861
+ type: "thinking";
16862
+ thinking: string;
16863
+ thinkingSignature?: string;
16864
+ redacted?: boolean;
16864
16865
  } | {
16865
16866
  addedToolNames?: string[];
16866
16867
  arguments: Record<string, any>;
16867
16868
  callID: string;
16868
16869
  name: string;
16869
16870
  namespace?: string;
16870
- result: {
16871
- content: ({
16871
+ partial?: {
16872
+ content?: ({
16872
16873
  type: "text";
16873
16874
  text: string;
16874
16875
  textSignature?: string;
@@ -16878,9 +16879,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16878
16879
  mimeType: string;
16879
16880
  })[];
16880
16881
  details?: any;
16881
- isError: true;
16882
16882
  };
16883
- status: "aborted";
16883
+ status: "running";
16884
16884
  thoughtSignature?: string;
16885
16885
  time: {
16886
16886
  start: number;
@@ -17361,19 +17361,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17361
17361
  type: "image";
17362
17362
  data: string;
17363
17363
  mimeType: string;
17364
- } | {
17365
- type: "thinking";
17366
- thinking: string;
17367
- thinkingSignature?: string;
17368
- redacted?: boolean;
17369
17364
  } | {
17370
17365
  addedToolNames?: string[];
17371
17366
  arguments: Record<string, any>;
17372
17367
  callID: string;
17373
17368
  name: string;
17374
17369
  namespace?: string;
17375
- partial?: {
17376
- content?: ({
17370
+ result: {
17371
+ content: ({
17377
17372
  type: "text";
17378
17373
  text: string;
17379
17374
  textSignature?: string;
@@ -17383,8 +17378,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17383
17378
  mimeType: string;
17384
17379
  })[];
17385
17380
  details?: any;
17381
+ isError: false;
17386
17382
  };
17387
- status: "running";
17383
+ status: "completed";
17388
17384
  thoughtSignature?: string;
17389
17385
  time: {
17390
17386
  start: number;
@@ -17408,9 +17404,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17408
17404
  mimeType: string;
17409
17405
  })[];
17410
17406
  details?: any;
17411
- isError: false;
17407
+ isError: true;
17412
17408
  };
17413
- status: "completed";
17409
+ status: "error";
17414
17410
  thoughtSignature?: string;
17415
17411
  time: {
17416
17412
  start: number;
@@ -17436,7 +17432,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17436
17432
  details?: any;
17437
17433
  isError: true;
17438
17434
  };
17439
- status: "error";
17435
+ status: "skipped";
17440
17436
  thoughtSignature?: string;
17441
17437
  time: {
17442
17438
  start: number;
@@ -17462,21 +17458,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17462
17458
  details?: any;
17463
17459
  isError: true;
17464
17460
  };
17465
- status: "skipped";
17461
+ status: "aborted";
17466
17462
  thoughtSignature?: string;
17467
17463
  time: {
17468
17464
  start: number;
17469
17465
  end: number;
17470
17466
  };
17471
17467
  type: "toolCall";
17468
+ } | {
17469
+ type: "thinking";
17470
+ thinking: string;
17471
+ thinkingSignature?: string;
17472
+ redacted?: boolean;
17472
17473
  } | {
17473
17474
  addedToolNames?: string[];
17474
17475
  arguments: Record<string, any>;
17475
17476
  callID: string;
17476
17477
  name: string;
17477
17478
  namespace?: string;
17478
- result: {
17479
- content: ({
17479
+ partial?: {
17480
+ content?: ({
17480
17481
  type: "text";
17481
17482
  text: string;
17482
17483
  textSignature?: string;
@@ -17486,9 +17487,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17486
17487
  mimeType: string;
17487
17488
  })[];
17488
17489
  details?: any;
17489
- isError: true;
17490
17490
  };
17491
- status: "aborted";
17491
+ status: "running";
17492
17492
  thoughtSignature?: string;
17493
17493
  time: {
17494
17494
  start: number;
@@ -17663,19 +17663,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17663
17663
  type: "image";
17664
17664
  data: string;
17665
17665
  mimeType: string;
17666
- } | {
17667
- type: "thinking";
17668
- thinking: string;
17669
- thinkingSignature?: string;
17670
- redacted?: boolean;
17671
17666
  } | {
17672
17667
  addedToolNames?: string[];
17673
17668
  arguments: Record<string, any>;
17674
17669
  callID: string;
17675
17670
  name: string;
17676
17671
  namespace?: string;
17677
- partial?: {
17678
- content?: ({
17672
+ result: {
17673
+ content: ({
17679
17674
  type: "text";
17680
17675
  text: string;
17681
17676
  textSignature?: string;
@@ -17685,8 +17680,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17685
17680
  mimeType: string;
17686
17681
  })[];
17687
17682
  details?: any;
17683
+ isError: false;
17688
17684
  };
17689
- status: "running";
17685
+ status: "completed";
17690
17686
  thoughtSignature?: string;
17691
17687
  time: {
17692
17688
  start: number;
@@ -17710,9 +17706,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17710
17706
  mimeType: string;
17711
17707
  })[];
17712
17708
  details?: any;
17713
- isError: false;
17709
+ isError: true;
17714
17710
  };
17715
- status: "completed";
17711
+ status: "error";
17716
17712
  thoughtSignature?: string;
17717
17713
  time: {
17718
17714
  start: number;
@@ -17738,7 +17734,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17738
17734
  details?: any;
17739
17735
  isError: true;
17740
17736
  };
17741
- status: "error";
17737
+ status: "skipped";
17742
17738
  thoughtSignature?: string;
17743
17739
  time: {
17744
17740
  start: number;
@@ -17764,21 +17760,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17764
17760
  details?: any;
17765
17761
  isError: true;
17766
17762
  };
17767
- status: "skipped";
17763
+ status: "aborted";
17768
17764
  thoughtSignature?: string;
17769
17765
  time: {
17770
17766
  start: number;
17771
17767
  end: number;
17772
17768
  };
17773
17769
  type: "toolCall";
17770
+ } | {
17771
+ type: "thinking";
17772
+ thinking: string;
17773
+ thinkingSignature?: string;
17774
+ redacted?: boolean;
17774
17775
  } | {
17775
17776
  addedToolNames?: string[];
17776
17777
  arguments: Record<string, any>;
17777
17778
  callID: string;
17778
17779
  name: string;
17779
17780
  namespace?: string;
17780
- result: {
17781
- content: ({
17781
+ partial?: {
17782
+ content?: ({
17782
17783
  type: "text";
17783
17784
  text: string;
17784
17785
  textSignature?: string;
@@ -17788,9 +17789,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17788
17789
  mimeType: string;
17789
17790
  })[];
17790
17791
  details?: any;
17791
- isError: true;
17792
17792
  };
17793
- status: "aborted";
17793
+ status: "running";
17794
17794
  thoughtSignature?: string;
17795
17795
  time: {
17796
17796
  start: number;
@@ -17984,19 +17984,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17984
17984
  type: "image";
17985
17985
  data: string;
17986
17986
  mimeType: string;
17987
- } | {
17988
- type: "thinking";
17989
- thinking: string;
17990
- thinkingSignature?: string;
17991
- redacted?: boolean;
17992
17987
  } | {
17993
17988
  addedToolNames?: string[];
17994
17989
  arguments: Record<string, any>;
17995
17990
  callID: string;
17996
17991
  name: string;
17997
17992
  namespace?: string;
17998
- partial?: {
17999
- content?: ({
17993
+ result: {
17994
+ content: ({
18000
17995
  type: "text";
18001
17996
  text: string;
18002
17997
  textSignature?: string;
@@ -18006,8 +18001,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18006
18001
  mimeType: string;
18007
18002
  })[];
18008
18003
  details?: any;
18004
+ isError: false;
18009
18005
  };
18010
- status: "running";
18006
+ status: "completed";
18011
18007
  thoughtSignature?: string;
18012
18008
  time: {
18013
18009
  start: number;
@@ -18031,9 +18027,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18031
18027
  mimeType: string;
18032
18028
  })[];
18033
18029
  details?: any;
18034
- isError: false;
18030
+ isError: true;
18035
18031
  };
18036
- status: "completed";
18032
+ status: "error";
18037
18033
  thoughtSignature?: string;
18038
18034
  time: {
18039
18035
  start: number;
@@ -18059,7 +18055,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18059
18055
  details?: any;
18060
18056
  isError: true;
18061
18057
  };
18062
- status: "error";
18058
+ status: "skipped";
18063
18059
  thoughtSignature?: string;
18064
18060
  time: {
18065
18061
  start: number;
@@ -18085,21 +18081,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18085
18081
  details?: any;
18086
18082
  isError: true;
18087
18083
  };
18088
- status: "skipped";
18084
+ status: "aborted";
18089
18085
  thoughtSignature?: string;
18090
18086
  time: {
18091
18087
  start: number;
18092
18088
  end: number;
18093
18089
  };
18094
18090
  type: "toolCall";
18091
+ } | {
18092
+ type: "thinking";
18093
+ thinking: string;
18094
+ thinkingSignature?: string;
18095
+ redacted?: boolean;
18095
18096
  } | {
18096
18097
  addedToolNames?: string[];
18097
18098
  arguments: Record<string, any>;
18098
18099
  callID: string;
18099
18100
  name: string;
18100
18101
  namespace?: string;
18101
- result: {
18102
- content: ({
18102
+ partial?: {
18103
+ content?: ({
18103
18104
  type: "text";
18104
18105
  text: string;
18105
18106
  textSignature?: string;
@@ -18109,9 +18110,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18109
18110
  mimeType: string;
18110
18111
  })[];
18111
18112
  details?: any;
18112
- isError: true;
18113
18113
  };
18114
- status: "aborted";
18114
+ status: "running";
18115
18115
  thoughtSignature?: string;
18116
18116
  time: {
18117
18117
  start: number;
@@ -18286,19 +18286,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18286
18286
  type: "image";
18287
18287
  data: string;
18288
18288
  mimeType: string;
18289
- } | {
18290
- type: "thinking";
18291
- thinking: string;
18292
- thinkingSignature?: string;
18293
- redacted?: boolean;
18294
18289
  } | {
18295
18290
  addedToolNames?: string[];
18296
18291
  arguments: Record<string, any>;
18297
18292
  callID: string;
18298
18293
  name: string;
18299
18294
  namespace?: string;
18300
- partial?: {
18301
- content?: ({
18295
+ result: {
18296
+ content: ({
18302
18297
  type: "text";
18303
18298
  text: string;
18304
18299
  textSignature?: string;
@@ -18308,8 +18303,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18308
18303
  mimeType: string;
18309
18304
  })[];
18310
18305
  details?: any;
18306
+ isError: false;
18311
18307
  };
18312
- status: "running";
18308
+ status: "completed";
18313
18309
  thoughtSignature?: string;
18314
18310
  time: {
18315
18311
  start: number;
@@ -18333,9 +18329,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18333
18329
  mimeType: string;
18334
18330
  })[];
18335
18331
  details?: any;
18336
- isError: false;
18332
+ isError: true;
18337
18333
  };
18338
- status: "completed";
18334
+ status: "error";
18339
18335
  thoughtSignature?: string;
18340
18336
  time: {
18341
18337
  start: number;
@@ -18361,7 +18357,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18361
18357
  details?: any;
18362
18358
  isError: true;
18363
18359
  };
18364
- status: "error";
18360
+ status: "skipped";
18365
18361
  thoughtSignature?: string;
18366
18362
  time: {
18367
18363
  start: number;
@@ -18387,21 +18383,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18387
18383
  details?: any;
18388
18384
  isError: true;
18389
18385
  };
18390
- status: "skipped";
18386
+ status: "aborted";
18391
18387
  thoughtSignature?: string;
18392
18388
  time: {
18393
18389
  start: number;
18394
18390
  end: number;
18395
18391
  };
18396
18392
  type: "toolCall";
18393
+ } | {
18394
+ type: "thinking";
18395
+ thinking: string;
18396
+ thinkingSignature?: string;
18397
+ redacted?: boolean;
18397
18398
  } | {
18398
18399
  addedToolNames?: string[];
18399
18400
  arguments: Record<string, any>;
18400
18401
  callID: string;
18401
18402
  name: string;
18402
18403
  namespace?: string;
18403
- result: {
18404
- content: ({
18404
+ partial?: {
18405
+ content?: ({
18405
18406
  type: "text";
18406
18407
  text: string;
18407
18408
  textSignature?: string;
@@ -18411,9 +18412,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18411
18412
  mimeType: string;
18412
18413
  })[];
18413
18414
  details?: any;
18414
- isError: true;
18415
18415
  };
18416
- status: "aborted";
18416
+ status: "running";
18417
18417
  thoughtSignature?: string;
18418
18418
  time: {
18419
18419
  start: number;
@@ -18616,19 +18616,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18616
18616
  type: "image";
18617
18617
  data: string;
18618
18618
  mimeType: string;
18619
- } | {
18620
- type: "thinking";
18621
- thinking: string;
18622
- thinkingSignature?: string;
18623
- redacted?: boolean;
18624
18619
  } | {
18625
18620
  addedToolNames?: string[];
18626
18621
  arguments: Record<string, any>;
18627
18622
  callID: string;
18628
18623
  name: string;
18629
18624
  namespace?: string;
18630
- partial?: {
18631
- content?: ({
18625
+ result: {
18626
+ content: ({
18632
18627
  type: "text";
18633
18628
  text: string;
18634
18629
  textSignature?: string;
@@ -18638,8 +18633,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18638
18633
  mimeType: string;
18639
18634
  })[];
18640
18635
  details?: any;
18636
+ isError: false;
18641
18637
  };
18642
- status: "running";
18638
+ status: "completed";
18643
18639
  thoughtSignature?: string;
18644
18640
  time: {
18645
18641
  start: number;
@@ -18663,9 +18659,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18663
18659
  mimeType: string;
18664
18660
  })[];
18665
18661
  details?: any;
18666
- isError: false;
18662
+ isError: true;
18667
18663
  };
18668
- status: "completed";
18664
+ status: "error";
18669
18665
  thoughtSignature?: string;
18670
18666
  time: {
18671
18667
  start: number;
@@ -18691,7 +18687,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18691
18687
  details?: any;
18692
18688
  isError: true;
18693
18689
  };
18694
- status: "error";
18690
+ status: "skipped";
18695
18691
  thoughtSignature?: string;
18696
18692
  time: {
18697
18693
  start: number;
@@ -18717,21 +18713,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18717
18713
  details?: any;
18718
18714
  isError: true;
18719
18715
  };
18720
- status: "skipped";
18716
+ status: "aborted";
18721
18717
  thoughtSignature?: string;
18722
18718
  time: {
18723
18719
  start: number;
18724
18720
  end: number;
18725
18721
  };
18726
18722
  type: "toolCall";
18723
+ } | {
18724
+ type: "thinking";
18725
+ thinking: string;
18726
+ thinkingSignature?: string;
18727
+ redacted?: boolean;
18727
18728
  } | {
18728
18729
  addedToolNames?: string[];
18729
18730
  arguments: Record<string, any>;
18730
18731
  callID: string;
18731
18732
  name: string;
18732
18733
  namespace?: string;
18733
- result: {
18734
- content: ({
18734
+ partial?: {
18735
+ content?: ({
18735
18736
  type: "text";
18736
18737
  text: string;
18737
18738
  textSignature?: string;
@@ -18741,9 +18742,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18741
18742
  mimeType: string;
18742
18743
  })[];
18743
18744
  details?: any;
18744
- isError: true;
18745
18745
  };
18746
- status: "aborted";
18746
+ status: "running";
18747
18747
  thoughtSignature?: string;
18748
18748
  time: {
18749
18749
  start: number;
@@ -18918,19 +18918,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18918
18918
  type: "image";
18919
18919
  data: string;
18920
18920
  mimeType: string;
18921
- } | {
18922
- type: "thinking";
18923
- thinking: string;
18924
- thinkingSignature?: string;
18925
- redacted?: boolean;
18926
18921
  } | {
18927
18922
  addedToolNames?: string[];
18928
18923
  arguments: Record<string, any>;
18929
18924
  callID: string;
18930
18925
  name: string;
18931
18926
  namespace?: string;
18932
- partial?: {
18933
- content?: ({
18927
+ result: {
18928
+ content: ({
18934
18929
  type: "text";
18935
18930
  text: string;
18936
18931
  textSignature?: string;
@@ -18940,8 +18935,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18940
18935
  mimeType: string;
18941
18936
  })[];
18942
18937
  details?: any;
18938
+ isError: false;
18943
18939
  };
18944
- status: "running";
18940
+ status: "completed";
18945
18941
  thoughtSignature?: string;
18946
18942
  time: {
18947
18943
  start: number;
@@ -18965,9 +18961,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18965
18961
  mimeType: string;
18966
18962
  })[];
18967
18963
  details?: any;
18968
- isError: false;
18964
+ isError: true;
18969
18965
  };
18970
- status: "completed";
18966
+ status: "error";
18971
18967
  thoughtSignature?: string;
18972
18968
  time: {
18973
18969
  start: number;
@@ -18993,7 +18989,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18993
18989
  details?: any;
18994
18990
  isError: true;
18995
18991
  };
18996
- status: "error";
18992
+ status: "skipped";
18997
18993
  thoughtSignature?: string;
18998
18994
  time: {
18999
18995
  start: number;
@@ -19019,21 +19015,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19019
19015
  details?: any;
19020
19016
  isError: true;
19021
19017
  };
19022
- status: "skipped";
19018
+ status: "aborted";
19023
19019
  thoughtSignature?: string;
19024
19020
  time: {
19025
19021
  start: number;
19026
19022
  end: number;
19027
19023
  };
19028
19024
  type: "toolCall";
19025
+ } | {
19026
+ type: "thinking";
19027
+ thinking: string;
19028
+ thinkingSignature?: string;
19029
+ redacted?: boolean;
19029
19030
  } | {
19030
19031
  addedToolNames?: string[];
19031
19032
  arguments: Record<string, any>;
19032
19033
  callID: string;
19033
19034
  name: string;
19034
19035
  namespace?: string;
19035
- result: {
19036
- content: ({
19036
+ partial?: {
19037
+ content?: ({
19037
19038
  type: "text";
19038
19039
  text: string;
19039
19040
  textSignature?: string;
@@ -19043,9 +19044,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19043
19044
  mimeType: string;
19044
19045
  })[];
19045
19046
  details?: any;
19046
- isError: true;
19047
19047
  };
19048
- status: "aborted";
19048
+ status: "running";
19049
19049
  thoughtSignature?: string;
19050
19050
  time: {
19051
19051
  start: number;
@@ -19239,19 +19239,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19239
19239
  type: "image";
19240
19240
  data: string;
19241
19241
  mimeType: string;
19242
- } | {
19243
- type: "thinking";
19244
- thinking: string;
19245
- thinkingSignature?: string;
19246
- redacted?: boolean;
19247
19242
  } | {
19248
19243
  addedToolNames?: string[];
19249
19244
  arguments: Record<string, any>;
19250
19245
  callID: string;
19251
19246
  name: string;
19252
19247
  namespace?: string;
19253
- partial?: {
19254
- content?: ({
19248
+ result: {
19249
+ content: ({
19255
19250
  type: "text";
19256
19251
  text: string;
19257
19252
  textSignature?: string;
@@ -19261,8 +19256,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19261
19256
  mimeType: string;
19262
19257
  })[];
19263
19258
  details?: any;
19259
+ isError: false;
19264
19260
  };
19265
- status: "running";
19261
+ status: "completed";
19266
19262
  thoughtSignature?: string;
19267
19263
  time: {
19268
19264
  start: number;
@@ -19286,9 +19282,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19286
19282
  mimeType: string;
19287
19283
  })[];
19288
19284
  details?: any;
19289
- isError: false;
19285
+ isError: true;
19290
19286
  };
19291
- status: "completed";
19287
+ status: "error";
19292
19288
  thoughtSignature?: string;
19293
19289
  time: {
19294
19290
  start: number;
@@ -19314,7 +19310,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19314
19310
  details?: any;
19315
19311
  isError: true;
19316
19312
  };
19317
- status: "error";
19313
+ status: "skipped";
19318
19314
  thoughtSignature?: string;
19319
19315
  time: {
19320
19316
  start: number;
@@ -19340,21 +19336,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19340
19336
  details?: any;
19341
19337
  isError: true;
19342
19338
  };
19343
- status: "skipped";
19339
+ status: "aborted";
19344
19340
  thoughtSignature?: string;
19345
19341
  time: {
19346
19342
  start: number;
19347
19343
  end: number;
19348
19344
  };
19349
19345
  type: "toolCall";
19346
+ } | {
19347
+ type: "thinking";
19348
+ thinking: string;
19349
+ thinkingSignature?: string;
19350
+ redacted?: boolean;
19350
19351
  } | {
19351
19352
  addedToolNames?: string[];
19352
19353
  arguments: Record<string, any>;
19353
19354
  callID: string;
19354
19355
  name: string;
19355
19356
  namespace?: string;
19356
- result: {
19357
- content: ({
19357
+ partial?: {
19358
+ content?: ({
19358
19359
  type: "text";
19359
19360
  text: string;
19360
19361
  textSignature?: string;
@@ -19364,9 +19365,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19364
19365
  mimeType: string;
19365
19366
  })[];
19366
19367
  details?: any;
19367
- isError: true;
19368
19368
  };
19369
- status: "aborted";
19369
+ status: "running";
19370
19370
  thoughtSignature?: string;
19371
19371
  time: {
19372
19372
  start: number;
@@ -19541,19 +19541,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19541
19541
  type: "image";
19542
19542
  data: string;
19543
19543
  mimeType: string;
19544
- } | {
19545
- type: "thinking";
19546
- thinking: string;
19547
- thinkingSignature?: string;
19548
- redacted?: boolean;
19549
19544
  } | {
19550
19545
  addedToolNames?: string[];
19551
19546
  arguments: Record<string, any>;
19552
19547
  callID: string;
19553
19548
  name: string;
19554
19549
  namespace?: string;
19555
- partial?: {
19556
- content?: ({
19550
+ result: {
19551
+ content: ({
19557
19552
  type: "text";
19558
19553
  text: string;
19559
19554
  textSignature?: string;
@@ -19563,8 +19558,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19563
19558
  mimeType: string;
19564
19559
  })[];
19565
19560
  details?: any;
19561
+ isError: false;
19566
19562
  };
19567
- status: "running";
19563
+ status: "completed";
19568
19564
  thoughtSignature?: string;
19569
19565
  time: {
19570
19566
  start: number;
@@ -19588,9 +19584,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19588
19584
  mimeType: string;
19589
19585
  })[];
19590
19586
  details?: any;
19591
- isError: false;
19587
+ isError: true;
19592
19588
  };
19593
- status: "completed";
19589
+ status: "error";
19594
19590
  thoughtSignature?: string;
19595
19591
  time: {
19596
19592
  start: number;
@@ -19616,7 +19612,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19616
19612
  details?: any;
19617
19613
  isError: true;
19618
19614
  };
19619
- status: "error";
19615
+ status: "skipped";
19620
19616
  thoughtSignature?: string;
19621
19617
  time: {
19622
19618
  start: number;
@@ -19642,21 +19638,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19642
19638
  details?: any;
19643
19639
  isError: true;
19644
19640
  };
19645
- status: "skipped";
19641
+ status: "aborted";
19646
19642
  thoughtSignature?: string;
19647
19643
  time: {
19648
19644
  start: number;
19649
19645
  end: number;
19650
19646
  };
19651
19647
  type: "toolCall";
19648
+ } | {
19649
+ type: "thinking";
19650
+ thinking: string;
19651
+ thinkingSignature?: string;
19652
+ redacted?: boolean;
19652
19653
  } | {
19653
19654
  addedToolNames?: string[];
19654
19655
  arguments: Record<string, any>;
19655
19656
  callID: string;
19656
19657
  name: string;
19657
19658
  namespace?: string;
19658
- result: {
19659
- content: ({
19659
+ partial?: {
19660
+ content?: ({
19660
19661
  type: "text";
19661
19662
  text: string;
19662
19663
  textSignature?: string;
@@ -19666,9 +19667,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19666
19667
  mimeType: string;
19667
19668
  })[];
19668
19669
  details?: any;
19669
- isError: true;
19670
19670
  };
19671
- status: "aborted";
19671
+ status: "running";
19672
19672
  thoughtSignature?: string;
19673
19673
  time: {
19674
19674
  start: number;
@@ -20856,19 +20856,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20856
20856
  type: "image";
20857
20857
  data: string;
20858
20858
  mimeType: string;
20859
- } | {
20860
- type: "thinking";
20861
- thinking: string;
20862
- thinkingSignature?: string;
20863
- redacted?: boolean;
20864
20859
  } | {
20865
20860
  addedToolNames?: string[];
20866
20861
  arguments: Record<string, any>;
20867
20862
  callID: string;
20868
20863
  name: string;
20869
20864
  namespace?: string;
20870
- partial?: {
20871
- content?: ({
20865
+ result: {
20866
+ content: ({
20872
20867
  type: "text";
20873
20868
  text: string;
20874
20869
  textSignature?: string;
@@ -20878,8 +20873,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20878
20873
  mimeType: string;
20879
20874
  })[];
20880
20875
  details?: any;
20876
+ isError: false;
20881
20877
  };
20882
- status: "running";
20878
+ status: "completed";
20883
20879
  thoughtSignature?: string;
20884
20880
  time: {
20885
20881
  start: number;
@@ -20903,9 +20899,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20903
20899
  mimeType: string;
20904
20900
  })[];
20905
20901
  details?: any;
20906
- isError: false;
20902
+ isError: true;
20907
20903
  };
20908
- status: "completed";
20904
+ status: "error";
20909
20905
  thoughtSignature?: string;
20910
20906
  time: {
20911
20907
  start: number;
@@ -20931,7 +20927,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20931
20927
  details?: any;
20932
20928
  isError: true;
20933
20929
  };
20934
- status: "error";
20930
+ status: "skipped";
20935
20931
  thoughtSignature?: string;
20936
20932
  time: {
20937
20933
  start: number;
@@ -20957,21 +20953,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20957
20953
  details?: any;
20958
20954
  isError: true;
20959
20955
  };
20960
- status: "skipped";
20956
+ status: "aborted";
20961
20957
  thoughtSignature?: string;
20962
20958
  time: {
20963
20959
  start: number;
20964
20960
  end: number;
20965
20961
  };
20966
20962
  type: "toolCall";
20963
+ } | {
20964
+ type: "thinking";
20965
+ thinking: string;
20966
+ thinkingSignature?: string;
20967
+ redacted?: boolean;
20967
20968
  } | {
20968
20969
  addedToolNames?: string[];
20969
20970
  arguments: Record<string, any>;
20970
20971
  callID: string;
20971
20972
  name: string;
20972
20973
  namespace?: string;
20973
- result: {
20974
- content: ({
20974
+ partial?: {
20975
+ content?: ({
20975
20976
  type: "text";
20976
20977
  text: string;
20977
20978
  textSignature?: string;
@@ -20981,9 +20982,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20981
20982
  mimeType: string;
20982
20983
  })[];
20983
20984
  details?: any;
20984
- isError: true;
20985
20985
  };
20986
- status: "aborted";
20986
+ status: "running";
20987
20987
  thoughtSignature?: string;
20988
20988
  time: {
20989
20989
  start: number;
@@ -21158,19 +21158,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21158
21158
  type: "image";
21159
21159
  data: string;
21160
21160
  mimeType: string;
21161
- } | {
21162
- type: "thinking";
21163
- thinking: string;
21164
- thinkingSignature?: string;
21165
- redacted?: boolean;
21166
21161
  } | {
21167
21162
  addedToolNames?: string[];
21168
21163
  arguments: Record<string, any>;
21169
21164
  callID: string;
21170
21165
  name: string;
21171
21166
  namespace?: string;
21172
- partial?: {
21173
- content?: ({
21167
+ result: {
21168
+ content: ({
21174
21169
  type: "text";
21175
21170
  text: string;
21176
21171
  textSignature?: string;
@@ -21180,8 +21175,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21180
21175
  mimeType: string;
21181
21176
  })[];
21182
21177
  details?: any;
21178
+ isError: false;
21183
21179
  };
21184
- status: "running";
21180
+ status: "completed";
21185
21181
  thoughtSignature?: string;
21186
21182
  time: {
21187
21183
  start: number;
@@ -21205,9 +21201,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21205
21201
  mimeType: string;
21206
21202
  })[];
21207
21203
  details?: any;
21208
- isError: false;
21204
+ isError: true;
21209
21205
  };
21210
- status: "completed";
21206
+ status: "error";
21211
21207
  thoughtSignature?: string;
21212
21208
  time: {
21213
21209
  start: number;
@@ -21233,7 +21229,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21233
21229
  details?: any;
21234
21230
  isError: true;
21235
21231
  };
21236
- status: "error";
21232
+ status: "skipped";
21237
21233
  thoughtSignature?: string;
21238
21234
  time: {
21239
21235
  start: number;
@@ -21259,21 +21255,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21259
21255
  details?: any;
21260
21256
  isError: true;
21261
21257
  };
21262
- status: "skipped";
21258
+ status: "aborted";
21263
21259
  thoughtSignature?: string;
21264
21260
  time: {
21265
21261
  start: number;
21266
21262
  end: number;
21267
21263
  };
21268
21264
  type: "toolCall";
21265
+ } | {
21266
+ type: "thinking";
21267
+ thinking: string;
21268
+ thinkingSignature?: string;
21269
+ redacted?: boolean;
21269
21270
  } | {
21270
21271
  addedToolNames?: string[];
21271
21272
  arguments: Record<string, any>;
21272
21273
  callID: string;
21273
21274
  name: string;
21274
21275
  namespace?: string;
21275
- result: {
21276
- content: ({
21276
+ partial?: {
21277
+ content?: ({
21277
21278
  type: "text";
21278
21279
  text: string;
21279
21280
  textSignature?: string;
@@ -21283,9 +21284,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21283
21284
  mimeType: string;
21284
21285
  })[];
21285
21286
  details?: any;
21286
- isError: true;
21287
21287
  };
21288
- status: "aborted";
21288
+ status: "running";
21289
21289
  thoughtSignature?: string;
21290
21290
  time: {
21291
21291
  start: number;
@@ -21478,19 +21478,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21478
21478
  type: "image";
21479
21479
  data: string;
21480
21480
  mimeType: string;
21481
- } | {
21482
- type: "thinking";
21483
- thinking: string;
21484
- thinkingSignature?: string;
21485
- redacted?: boolean;
21486
21481
  } | {
21487
21482
  addedToolNames?: string[];
21488
21483
  arguments: Record<string, any>;
21489
21484
  callID: string;
21490
21485
  name: string;
21491
21486
  namespace?: string;
21492
- partial?: {
21493
- content?: ({
21487
+ result: {
21488
+ content: ({
21494
21489
  type: "text";
21495
21490
  text: string;
21496
21491
  textSignature?: string;
@@ -21500,8 +21495,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21500
21495
  mimeType: string;
21501
21496
  })[];
21502
21497
  details?: any;
21498
+ isError: false;
21503
21499
  };
21504
- status: "running";
21500
+ status: "completed";
21505
21501
  thoughtSignature?: string;
21506
21502
  time: {
21507
21503
  start: number;
@@ -21525,9 +21521,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21525
21521
  mimeType: string;
21526
21522
  })[];
21527
21523
  details?: any;
21528
- isError: false;
21524
+ isError: true;
21529
21525
  };
21530
- status: "completed";
21526
+ status: "error";
21531
21527
  thoughtSignature?: string;
21532
21528
  time: {
21533
21529
  start: number;
@@ -21553,7 +21549,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21553
21549
  details?: any;
21554
21550
  isError: true;
21555
21551
  };
21556
- status: "error";
21552
+ status: "skipped";
21557
21553
  thoughtSignature?: string;
21558
21554
  time: {
21559
21555
  start: number;
@@ -21579,21 +21575,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21579
21575
  details?: any;
21580
21576
  isError: true;
21581
21577
  };
21582
- status: "skipped";
21578
+ status: "aborted";
21583
21579
  thoughtSignature?: string;
21584
21580
  time: {
21585
21581
  start: number;
21586
21582
  end: number;
21587
21583
  };
21588
21584
  type: "toolCall";
21585
+ } | {
21586
+ type: "thinking";
21587
+ thinking: string;
21588
+ thinkingSignature?: string;
21589
+ redacted?: boolean;
21589
21590
  } | {
21590
21591
  addedToolNames?: string[];
21591
21592
  arguments: Record<string, any>;
21592
21593
  callID: string;
21593
21594
  name: string;
21594
21595
  namespace?: string;
21595
- result: {
21596
- content: ({
21596
+ partial?: {
21597
+ content?: ({
21597
21598
  type: "text";
21598
21599
  text: string;
21599
21600
  textSignature?: string;
@@ -21603,9 +21604,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21603
21604
  mimeType: string;
21604
21605
  })[];
21605
21606
  details?: any;
21606
- isError: true;
21607
21607
  };
21608
- status: "aborted";
21608
+ status: "running";
21609
21609
  thoughtSignature?: string;
21610
21610
  time: {
21611
21611
  start: number;
@@ -21780,19 +21780,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21780
21780
  type: "image";
21781
21781
  data: string;
21782
21782
  mimeType: string;
21783
- } | {
21784
- type: "thinking";
21785
- thinking: string;
21786
- thinkingSignature?: string;
21787
- redacted?: boolean;
21788
21783
  } | {
21789
21784
  addedToolNames?: string[];
21790
21785
  arguments: Record<string, any>;
21791
21786
  callID: string;
21792
21787
  name: string;
21793
21788
  namespace?: string;
21794
- partial?: {
21795
- content?: ({
21789
+ result: {
21790
+ content: ({
21796
21791
  type: "text";
21797
21792
  text: string;
21798
21793
  textSignature?: string;
@@ -21802,8 +21797,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21802
21797
  mimeType: string;
21803
21798
  })[];
21804
21799
  details?: any;
21800
+ isError: false;
21805
21801
  };
21806
- status: "running";
21802
+ status: "completed";
21807
21803
  thoughtSignature?: string;
21808
21804
  time: {
21809
21805
  start: number;
@@ -21827,9 +21823,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21827
21823
  mimeType: string;
21828
21824
  })[];
21829
21825
  details?: any;
21830
- isError: false;
21826
+ isError: true;
21831
21827
  };
21832
- status: "completed";
21828
+ status: "error";
21833
21829
  thoughtSignature?: string;
21834
21830
  time: {
21835
21831
  start: number;
@@ -21855,7 +21851,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21855
21851
  details?: any;
21856
21852
  isError: true;
21857
21853
  };
21858
- status: "error";
21854
+ status: "skipped";
21859
21855
  thoughtSignature?: string;
21860
21856
  time: {
21861
21857
  start: number;
@@ -21881,21 +21877,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21881
21877
  details?: any;
21882
21878
  isError: true;
21883
21879
  };
21884
- status: "skipped";
21880
+ status: "aborted";
21885
21881
  thoughtSignature?: string;
21886
21882
  time: {
21887
21883
  start: number;
21888
21884
  end: number;
21889
21885
  };
21890
21886
  type: "toolCall";
21887
+ } | {
21888
+ type: "thinking";
21889
+ thinking: string;
21890
+ thinkingSignature?: string;
21891
+ redacted?: boolean;
21891
21892
  } | {
21892
21893
  addedToolNames?: string[];
21893
21894
  arguments: Record<string, any>;
21894
21895
  callID: string;
21895
21896
  name: string;
21896
21897
  namespace?: string;
21897
- result: {
21898
- content: ({
21898
+ partial?: {
21899
+ content?: ({
21899
21900
  type: "text";
21900
21901
  text: string;
21901
21902
  textSignature?: string;
@@ -21905,9 +21906,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21905
21906
  mimeType: string;
21906
21907
  })[];
21907
21908
  details?: any;
21908
- isError: true;
21909
21909
  };
21910
- status: "aborted";
21910
+ status: "running";
21911
21911
  thoughtSignature?: string;
21912
21912
  time: {
21913
21913
  start: number;
@@ -22110,19 +22110,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22110
22110
  type: "image";
22111
22111
  data: string;
22112
22112
  mimeType: string;
22113
- } | {
22114
- type: "thinking";
22115
- thinking: string;
22116
- thinkingSignature?: string;
22117
- redacted?: boolean;
22118
22113
  } | {
22119
22114
  addedToolNames?: string[];
22120
22115
  arguments: Record<string, any>;
22121
22116
  callID: string;
22122
22117
  name: string;
22123
22118
  namespace?: string;
22124
- partial?: {
22125
- content?: ({
22119
+ result: {
22120
+ content: ({
22126
22121
  type: "text";
22127
22122
  text: string;
22128
22123
  textSignature?: string;
@@ -22132,8 +22127,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22132
22127
  mimeType: string;
22133
22128
  })[];
22134
22129
  details?: any;
22130
+ isError: false;
22135
22131
  };
22136
- status: "running";
22132
+ status: "completed";
22137
22133
  thoughtSignature?: string;
22138
22134
  time: {
22139
22135
  start: number;
@@ -22157,9 +22153,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22157
22153
  mimeType: string;
22158
22154
  })[];
22159
22155
  details?: any;
22160
- isError: false;
22156
+ isError: true;
22161
22157
  };
22162
- status: "completed";
22158
+ status: "error";
22163
22159
  thoughtSignature?: string;
22164
22160
  time: {
22165
22161
  start: number;
@@ -22185,7 +22181,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22185
22181
  details?: any;
22186
22182
  isError: true;
22187
22183
  };
22188
- status: "error";
22184
+ status: "skipped";
22189
22185
  thoughtSignature?: string;
22190
22186
  time: {
22191
22187
  start: number;
@@ -22211,21 +22207,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22211
22207
  details?: any;
22212
22208
  isError: true;
22213
22209
  };
22214
- status: "skipped";
22210
+ status: "aborted";
22215
22211
  thoughtSignature?: string;
22216
22212
  time: {
22217
22213
  start: number;
22218
22214
  end: number;
22219
22215
  };
22220
22216
  type: "toolCall";
22217
+ } | {
22218
+ type: "thinking";
22219
+ thinking: string;
22220
+ thinkingSignature?: string;
22221
+ redacted?: boolean;
22221
22222
  } | {
22222
22223
  addedToolNames?: string[];
22223
22224
  arguments: Record<string, any>;
22224
22225
  callID: string;
22225
22226
  name: string;
22226
22227
  namespace?: string;
22227
- result: {
22228
- content: ({
22228
+ partial?: {
22229
+ content?: ({
22229
22230
  type: "text";
22230
22231
  text: string;
22231
22232
  textSignature?: string;
@@ -22235,9 +22236,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22235
22236
  mimeType: string;
22236
22237
  })[];
22237
22238
  details?: any;
22238
- isError: true;
22239
22239
  };
22240
- status: "aborted";
22240
+ status: "running";
22241
22241
  thoughtSignature?: string;
22242
22242
  time: {
22243
22243
  start: number;
@@ -22412,19 +22412,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22412
22412
  type: "image";
22413
22413
  data: string;
22414
22414
  mimeType: string;
22415
- } | {
22416
- type: "thinking";
22417
- thinking: string;
22418
- thinkingSignature?: string;
22419
- redacted?: boolean;
22420
22415
  } | {
22421
22416
  addedToolNames?: string[];
22422
22417
  arguments: Record<string, any>;
22423
22418
  callID: string;
22424
22419
  name: string;
22425
22420
  namespace?: string;
22426
- partial?: {
22427
- content?: ({
22421
+ result: {
22422
+ content: ({
22428
22423
  type: "text";
22429
22424
  text: string;
22430
22425
  textSignature?: string;
@@ -22434,8 +22429,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22434
22429
  mimeType: string;
22435
22430
  })[];
22436
22431
  details?: any;
22432
+ isError: false;
22437
22433
  };
22438
- status: "running";
22434
+ status: "completed";
22439
22435
  thoughtSignature?: string;
22440
22436
  time: {
22441
22437
  start: number;
@@ -22459,9 +22455,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22459
22455
  mimeType: string;
22460
22456
  })[];
22461
22457
  details?: any;
22462
- isError: false;
22458
+ isError: true;
22463
22459
  };
22464
- status: "completed";
22460
+ status: "error";
22465
22461
  thoughtSignature?: string;
22466
22462
  time: {
22467
22463
  start: number;
@@ -22487,7 +22483,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22487
22483
  details?: any;
22488
22484
  isError: true;
22489
22485
  };
22490
- status: "error";
22486
+ status: "skipped";
22491
22487
  thoughtSignature?: string;
22492
22488
  time: {
22493
22489
  start: number;
@@ -22513,21 +22509,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22513
22509
  details?: any;
22514
22510
  isError: true;
22515
22511
  };
22516
- status: "skipped";
22512
+ status: "aborted";
22517
22513
  thoughtSignature?: string;
22518
22514
  time: {
22519
22515
  start: number;
22520
22516
  end: number;
22521
22517
  };
22522
22518
  type: "toolCall";
22519
+ } | {
22520
+ type: "thinking";
22521
+ thinking: string;
22522
+ thinkingSignature?: string;
22523
+ redacted?: boolean;
22523
22524
  } | {
22524
22525
  addedToolNames?: string[];
22525
22526
  arguments: Record<string, any>;
22526
22527
  callID: string;
22527
22528
  name: string;
22528
22529
  namespace?: string;
22529
- result: {
22530
- content: ({
22530
+ partial?: {
22531
+ content?: ({
22531
22532
  type: "text";
22532
22533
  text: string;
22533
22534
  textSignature?: string;
@@ -22537,9 +22538,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22537
22538
  mimeType: string;
22538
22539
  })[];
22539
22540
  details?: any;
22540
- isError: true;
22541
22541
  };
22542
- status: "aborted";
22542
+ status: "running";
22543
22543
  thoughtSignature?: string;
22544
22544
  time: {
22545
22545
  start: number;
@@ -22733,19 +22733,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22733
22733
  type: "image";
22734
22734
  data: string;
22735
22735
  mimeType: string;
22736
- } | {
22737
- type: "thinking";
22738
- thinking: string;
22739
- thinkingSignature?: string;
22740
- redacted?: boolean;
22741
22736
  } | {
22742
22737
  addedToolNames?: string[];
22743
22738
  arguments: Record<string, any>;
22744
22739
  callID: string;
22745
22740
  name: string;
22746
22741
  namespace?: string;
22747
- partial?: {
22748
- content?: ({
22742
+ result: {
22743
+ content: ({
22749
22744
  type: "text";
22750
22745
  text: string;
22751
22746
  textSignature?: string;
@@ -22755,8 +22750,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22755
22750
  mimeType: string;
22756
22751
  })[];
22757
22752
  details?: any;
22753
+ isError: false;
22758
22754
  };
22759
- status: "running";
22755
+ status: "completed";
22760
22756
  thoughtSignature?: string;
22761
22757
  time: {
22762
22758
  start: number;
@@ -22780,9 +22776,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22780
22776
  mimeType: string;
22781
22777
  })[];
22782
22778
  details?: any;
22783
- isError: false;
22779
+ isError: true;
22784
22780
  };
22785
- status: "completed";
22781
+ status: "error";
22786
22782
  thoughtSignature?: string;
22787
22783
  time: {
22788
22784
  start: number;
@@ -22808,7 +22804,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22808
22804
  details?: any;
22809
22805
  isError: true;
22810
22806
  };
22811
- status: "error";
22807
+ status: "skipped";
22812
22808
  thoughtSignature?: string;
22813
22809
  time: {
22814
22810
  start: number;
@@ -22834,21 +22830,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22834
22830
  details?: any;
22835
22831
  isError: true;
22836
22832
  };
22837
- status: "skipped";
22833
+ status: "aborted";
22838
22834
  thoughtSignature?: string;
22839
22835
  time: {
22840
22836
  start: number;
22841
22837
  end: number;
22842
22838
  };
22843
22839
  type: "toolCall";
22840
+ } | {
22841
+ type: "thinking";
22842
+ thinking: string;
22843
+ thinkingSignature?: string;
22844
+ redacted?: boolean;
22844
22845
  } | {
22845
22846
  addedToolNames?: string[];
22846
22847
  arguments: Record<string, any>;
22847
22848
  callID: string;
22848
22849
  name: string;
22849
22850
  namespace?: string;
22850
- result: {
22851
- content: ({
22851
+ partial?: {
22852
+ content?: ({
22852
22853
  type: "text";
22853
22854
  text: string;
22854
22855
  textSignature?: string;
@@ -22858,9 +22859,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22858
22859
  mimeType: string;
22859
22860
  })[];
22860
22861
  details?: any;
22861
- isError: true;
22862
22862
  };
22863
- status: "aborted";
22863
+ status: "running";
22864
22864
  thoughtSignature?: string;
22865
22865
  time: {
22866
22866
  start: number;
@@ -23035,19 +23035,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23035
23035
  type: "image";
23036
23036
  data: string;
23037
23037
  mimeType: string;
23038
- } | {
23039
- type: "thinking";
23040
- thinking: string;
23041
- thinkingSignature?: string;
23042
- redacted?: boolean;
23043
23038
  } | {
23044
23039
  addedToolNames?: string[];
23045
23040
  arguments: Record<string, any>;
23046
23041
  callID: string;
23047
23042
  name: string;
23048
23043
  namespace?: string;
23049
- partial?: {
23050
- content?: ({
23044
+ result: {
23045
+ content: ({
23051
23046
  type: "text";
23052
23047
  text: string;
23053
23048
  textSignature?: string;
@@ -23057,8 +23052,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23057
23052
  mimeType: string;
23058
23053
  })[];
23059
23054
  details?: any;
23055
+ isError: false;
23060
23056
  };
23061
- status: "running";
23057
+ status: "completed";
23062
23058
  thoughtSignature?: string;
23063
23059
  time: {
23064
23060
  start: number;
@@ -23082,9 +23078,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23082
23078
  mimeType: string;
23083
23079
  })[];
23084
23080
  details?: any;
23085
- isError: false;
23081
+ isError: true;
23086
23082
  };
23087
- status: "completed";
23083
+ status: "error";
23088
23084
  thoughtSignature?: string;
23089
23085
  time: {
23090
23086
  start: number;
@@ -23110,7 +23106,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23110
23106
  details?: any;
23111
23107
  isError: true;
23112
23108
  };
23113
- status: "error";
23109
+ status: "skipped";
23114
23110
  thoughtSignature?: string;
23115
23111
  time: {
23116
23112
  start: number;
@@ -23136,21 +23132,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23136
23132
  details?: any;
23137
23133
  isError: true;
23138
23134
  };
23139
- status: "skipped";
23135
+ status: "aborted";
23140
23136
  thoughtSignature?: string;
23141
23137
  time: {
23142
23138
  start: number;
23143
23139
  end: number;
23144
23140
  };
23145
23141
  type: "toolCall";
23142
+ } | {
23143
+ type: "thinking";
23144
+ thinking: string;
23145
+ thinkingSignature?: string;
23146
+ redacted?: boolean;
23146
23147
  } | {
23147
23148
  addedToolNames?: string[];
23148
23149
  arguments: Record<string, any>;
23149
23150
  callID: string;
23150
23151
  name: string;
23151
23152
  namespace?: string;
23152
- result: {
23153
- content: ({
23153
+ partial?: {
23154
+ content?: ({
23154
23155
  type: "text";
23155
23156
  text: string;
23156
23157
  textSignature?: string;
@@ -23160,9 +23161,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23160
23161
  mimeType: string;
23161
23162
  })[];
23162
23163
  details?: any;
23163
- isError: true;
23164
23164
  };
23165
- status: "aborted";
23165
+ status: "running";
23166
23166
  thoughtSignature?: string;
23167
23167
  time: {
23168
23168
  start: number;
@@ -23365,19 +23365,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23365
23365
  type: "image";
23366
23366
  data: string;
23367
23367
  mimeType: string;
23368
- } | {
23369
- type: "thinking";
23370
- thinking: string;
23371
- thinkingSignature?: string;
23372
- redacted?: boolean;
23373
23368
  } | {
23374
23369
  addedToolNames?: string[];
23375
23370
  arguments: Record<string, any>;
23376
23371
  callID: string;
23377
23372
  name: string;
23378
23373
  namespace?: string;
23379
- partial?: {
23380
- content?: ({
23374
+ result: {
23375
+ content: ({
23381
23376
  type: "text";
23382
23377
  text: string;
23383
23378
  textSignature?: string;
@@ -23387,8 +23382,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23387
23382
  mimeType: string;
23388
23383
  })[];
23389
23384
  details?: any;
23385
+ isError: false;
23390
23386
  };
23391
- status: "running";
23387
+ status: "completed";
23392
23388
  thoughtSignature?: string;
23393
23389
  time: {
23394
23390
  start: number;
@@ -23412,9 +23408,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23412
23408
  mimeType: string;
23413
23409
  })[];
23414
23410
  details?: any;
23415
- isError: false;
23411
+ isError: true;
23416
23412
  };
23417
- status: "completed";
23413
+ status: "error";
23418
23414
  thoughtSignature?: string;
23419
23415
  time: {
23420
23416
  start: number;
@@ -23440,7 +23436,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23440
23436
  details?: any;
23441
23437
  isError: true;
23442
23438
  };
23443
- status: "error";
23439
+ status: "skipped";
23444
23440
  thoughtSignature?: string;
23445
23441
  time: {
23446
23442
  start: number;
@@ -23466,21 +23462,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23466
23462
  details?: any;
23467
23463
  isError: true;
23468
23464
  };
23469
- status: "skipped";
23465
+ status: "aborted";
23470
23466
  thoughtSignature?: string;
23471
23467
  time: {
23472
23468
  start: number;
23473
23469
  end: number;
23474
23470
  };
23475
23471
  type: "toolCall";
23472
+ } | {
23473
+ type: "thinking";
23474
+ thinking: string;
23475
+ thinkingSignature?: string;
23476
+ redacted?: boolean;
23476
23477
  } | {
23477
23478
  addedToolNames?: string[];
23478
23479
  arguments: Record<string, any>;
23479
23480
  callID: string;
23480
23481
  name: string;
23481
23482
  namespace?: string;
23482
- result: {
23483
- content: ({
23483
+ partial?: {
23484
+ content?: ({
23484
23485
  type: "text";
23485
23486
  text: string;
23486
23487
  textSignature?: string;
@@ -23490,9 +23491,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23490
23491
  mimeType: string;
23491
23492
  })[];
23492
23493
  details?: any;
23493
- isError: true;
23494
23494
  };
23495
- status: "aborted";
23495
+ status: "running";
23496
23496
  thoughtSignature?: string;
23497
23497
  time: {
23498
23498
  start: number;
@@ -23667,19 +23667,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23667
23667
  type: "image";
23668
23668
  data: string;
23669
23669
  mimeType: string;
23670
- } | {
23671
- type: "thinking";
23672
- thinking: string;
23673
- thinkingSignature?: string;
23674
- redacted?: boolean;
23675
23670
  } | {
23676
23671
  addedToolNames?: string[];
23677
23672
  arguments: Record<string, any>;
23678
23673
  callID: string;
23679
23674
  name: string;
23680
23675
  namespace?: string;
23681
- partial?: {
23682
- content?: ({
23676
+ result: {
23677
+ content: ({
23683
23678
  type: "text";
23684
23679
  text: string;
23685
23680
  textSignature?: string;
@@ -23689,8 +23684,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23689
23684
  mimeType: string;
23690
23685
  })[];
23691
23686
  details?: any;
23687
+ isError: false;
23692
23688
  };
23693
- status: "running";
23689
+ status: "completed";
23694
23690
  thoughtSignature?: string;
23695
23691
  time: {
23696
23692
  start: number;
@@ -23714,9 +23710,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23714
23710
  mimeType: string;
23715
23711
  })[];
23716
23712
  details?: any;
23717
- isError: false;
23713
+ isError: true;
23718
23714
  };
23719
- status: "completed";
23715
+ status: "error";
23720
23716
  thoughtSignature?: string;
23721
23717
  time: {
23722
23718
  start: number;
@@ -23742,7 +23738,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23742
23738
  details?: any;
23743
23739
  isError: true;
23744
23740
  };
23745
- status: "error";
23741
+ status: "skipped";
23746
23742
  thoughtSignature?: string;
23747
23743
  time: {
23748
23744
  start: number;
@@ -23768,21 +23764,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23768
23764
  details?: any;
23769
23765
  isError: true;
23770
23766
  };
23771
- status: "skipped";
23767
+ status: "aborted";
23772
23768
  thoughtSignature?: string;
23773
23769
  time: {
23774
23770
  start: number;
23775
23771
  end: number;
23776
23772
  };
23777
23773
  type: "toolCall";
23774
+ } | {
23775
+ type: "thinking";
23776
+ thinking: string;
23777
+ thinkingSignature?: string;
23778
+ redacted?: boolean;
23778
23779
  } | {
23779
23780
  addedToolNames?: string[];
23780
23781
  arguments: Record<string, any>;
23781
23782
  callID: string;
23782
23783
  name: string;
23783
23784
  namespace?: string;
23784
- result: {
23785
- content: ({
23785
+ partial?: {
23786
+ content?: ({
23786
23787
  type: "text";
23787
23788
  text: string;
23788
23789
  textSignature?: string;
@@ -23792,9 +23793,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23792
23793
  mimeType: string;
23793
23794
  })[];
23794
23795
  details?: any;
23795
- isError: true;
23796
23796
  };
23797
- status: "aborted";
23797
+ status: "running";
23798
23798
  thoughtSignature?: string;
23799
23799
  time: {
23800
23800
  start: number;
@@ -23988,19 +23988,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23988
23988
  type: "image";
23989
23989
  data: string;
23990
23990
  mimeType: string;
23991
- } | {
23992
- type: "thinking";
23993
- thinking: string;
23994
- thinkingSignature?: string;
23995
- redacted?: boolean;
23996
23991
  } | {
23997
23992
  addedToolNames?: string[];
23998
23993
  arguments: Record<string, any>;
23999
23994
  callID: string;
24000
23995
  name: string;
24001
23996
  namespace?: string;
24002
- partial?: {
24003
- content?: ({
23997
+ result: {
23998
+ content: ({
24004
23999
  type: "text";
24005
24000
  text: string;
24006
24001
  textSignature?: string;
@@ -24010,8 +24005,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24010
24005
  mimeType: string;
24011
24006
  })[];
24012
24007
  details?: any;
24008
+ isError: false;
24013
24009
  };
24014
- status: "running";
24010
+ status: "completed";
24015
24011
  thoughtSignature?: string;
24016
24012
  time: {
24017
24013
  start: number;
@@ -24035,9 +24031,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24035
24031
  mimeType: string;
24036
24032
  })[];
24037
24033
  details?: any;
24038
- isError: false;
24034
+ isError: true;
24039
24035
  };
24040
- status: "completed";
24036
+ status: "error";
24041
24037
  thoughtSignature?: string;
24042
24038
  time: {
24043
24039
  start: number;
@@ -24063,7 +24059,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24063
24059
  details?: any;
24064
24060
  isError: true;
24065
24061
  };
24066
- status: "error";
24062
+ status: "skipped";
24067
24063
  thoughtSignature?: string;
24068
24064
  time: {
24069
24065
  start: number;
@@ -24089,21 +24085,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24089
24085
  details?: any;
24090
24086
  isError: true;
24091
24087
  };
24092
- status: "skipped";
24088
+ status: "aborted";
24093
24089
  thoughtSignature?: string;
24094
24090
  time: {
24095
24091
  start: number;
24096
24092
  end: number;
24097
24093
  };
24098
24094
  type: "toolCall";
24095
+ } | {
24096
+ type: "thinking";
24097
+ thinking: string;
24098
+ thinkingSignature?: string;
24099
+ redacted?: boolean;
24099
24100
  } | {
24100
24101
  addedToolNames?: string[];
24101
24102
  arguments: Record<string, any>;
24102
24103
  callID: string;
24103
24104
  name: string;
24104
24105
  namespace?: string;
24105
- result: {
24106
- content: ({
24106
+ partial?: {
24107
+ content?: ({
24107
24108
  type: "text";
24108
24109
  text: string;
24109
24110
  textSignature?: string;
@@ -24113,9 +24114,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24113
24114
  mimeType: string;
24114
24115
  })[];
24115
24116
  details?: any;
24116
- isError: true;
24117
24117
  };
24118
- status: "aborted";
24118
+ status: "running";
24119
24119
  thoughtSignature?: string;
24120
24120
  time: {
24121
24121
  start: number;
@@ -24290,19 +24290,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24290
24290
  type: "image";
24291
24291
  data: string;
24292
24292
  mimeType: string;
24293
- } | {
24294
- type: "thinking";
24295
- thinking: string;
24296
- thinkingSignature?: string;
24297
- redacted?: boolean;
24298
24293
  } | {
24299
24294
  addedToolNames?: string[];
24300
24295
  arguments: Record<string, any>;
24301
24296
  callID: string;
24302
24297
  name: string;
24303
24298
  namespace?: string;
24304
- partial?: {
24305
- content?: ({
24299
+ result: {
24300
+ content: ({
24306
24301
  type: "text";
24307
24302
  text: string;
24308
24303
  textSignature?: string;
@@ -24312,8 +24307,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24312
24307
  mimeType: string;
24313
24308
  })[];
24314
24309
  details?: any;
24310
+ isError: false;
24315
24311
  };
24316
- status: "running";
24312
+ status: "completed";
24317
24313
  thoughtSignature?: string;
24318
24314
  time: {
24319
24315
  start: number;
@@ -24337,9 +24333,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24337
24333
  mimeType: string;
24338
24334
  })[];
24339
24335
  details?: any;
24340
- isError: false;
24336
+ isError: true;
24341
24337
  };
24342
- status: "completed";
24338
+ status: "error";
24343
24339
  thoughtSignature?: string;
24344
24340
  time: {
24345
24341
  start: number;
@@ -24365,7 +24361,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24365
24361
  details?: any;
24366
24362
  isError: true;
24367
24363
  };
24368
- status: "error";
24364
+ status: "skipped";
24369
24365
  thoughtSignature?: string;
24370
24366
  time: {
24371
24367
  start: number;
@@ -24391,21 +24387,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24391
24387
  details?: any;
24392
24388
  isError: true;
24393
24389
  };
24394
- status: "skipped";
24390
+ status: "aborted";
24395
24391
  thoughtSignature?: string;
24396
24392
  time: {
24397
24393
  start: number;
24398
24394
  end: number;
24399
24395
  };
24400
24396
  type: "toolCall";
24397
+ } | {
24398
+ type: "thinking";
24399
+ thinking: string;
24400
+ thinkingSignature?: string;
24401
+ redacted?: boolean;
24401
24402
  } | {
24402
24403
  addedToolNames?: string[];
24403
24404
  arguments: Record<string, any>;
24404
24405
  callID: string;
24405
24406
  name: string;
24406
24407
  namespace?: string;
24407
- result: {
24408
- content: ({
24408
+ partial?: {
24409
+ content?: ({
24409
24410
  type: "text";
24410
24411
  text: string;
24411
24412
  textSignature?: string;
@@ -24415,9 +24416,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24415
24416
  mimeType: string;
24416
24417
  })[];
24417
24418
  details?: any;
24418
- isError: true;
24419
24419
  };
24420
- status: "aborted";
24420
+ status: "running";
24421
24421
  thoughtSignature?: string;
24422
24422
  time: {
24423
24423
  start: number;