@codeworksh/harness 0.3.0-canary.41.1.g5c48db0a → 0.3.0-canary.42.1.gf2cf72a9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/effect.d.mts +820 -820
  2. package/package.json +3 -3
package/effect.d.mts CHANGED
@@ -2733,21 +2733,6 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2733
2733
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2734
2734
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2735
2735
  declare const encodeMessage: (message: {
2736
- messageId: string;
2737
- role: "user";
2738
- time: {
2739
- created: number;
2740
- };
2741
- parts: ({
2742
- type: "text";
2743
- text: string;
2744
- textSignature?: string;
2745
- } | {
2746
- type: "image";
2747
- data: string;
2748
- mimeType: string;
2749
- })[];
2750
- } | {
2751
2736
  role: "assistant";
2752
2737
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2753
2738
  provider: {
@@ -2897,14 +2882,19 @@ declare const encodeMessage: (message: {
2897
2882
  type: "image";
2898
2883
  data: string;
2899
2884
  mimeType: string;
2885
+ } | {
2886
+ type: "thinking";
2887
+ thinking: string;
2888
+ thinkingSignature?: string;
2889
+ redacted?: boolean;
2900
2890
  } | {
2901
2891
  addedToolNames?: string[];
2902
2892
  arguments: Record<string, any>;
2903
2893
  callID: string;
2904
2894
  name: string;
2905
2895
  namespace?: string;
2906
- result: {
2907
- content: ({
2896
+ partial?: {
2897
+ content?: ({
2908
2898
  type: "text";
2909
2899
  text: string;
2910
2900
  textSignature?: string;
@@ -2914,9 +2904,8 @@ declare const encodeMessage: (message: {
2914
2904
  mimeType: string;
2915
2905
  })[];
2916
2906
  details?: any;
2917
- isError: false;
2918
2907
  };
2919
- status: "completed";
2908
+ status: "running";
2920
2909
  thoughtSignature?: string;
2921
2910
  time: {
2922
2911
  start: number;
@@ -2940,9 +2929,9 @@ declare const encodeMessage: (message: {
2940
2929
  mimeType: string;
2941
2930
  })[];
2942
2931
  details?: any;
2943
- isError: true;
2932
+ isError: false;
2944
2933
  };
2945
- status: "error";
2934
+ status: "completed";
2946
2935
  thoughtSignature?: string;
2947
2936
  time: {
2948
2937
  start: number;
@@ -2968,7 +2957,7 @@ declare const encodeMessage: (message: {
2968
2957
  details?: any;
2969
2958
  isError: true;
2970
2959
  };
2971
- status: "skipped";
2960
+ status: "error";
2972
2961
  thoughtSignature?: string;
2973
2962
  time: {
2974
2963
  start: number;
@@ -2994,26 +2983,21 @@ declare const encodeMessage: (message: {
2994
2983
  details?: any;
2995
2984
  isError: true;
2996
2985
  };
2997
- status: "aborted";
2986
+ status: "skipped";
2998
2987
  thoughtSignature?: string;
2999
2988
  time: {
3000
2989
  start: number;
3001
2990
  end: number;
3002
2991
  };
3003
2992
  type: "toolCall";
3004
- } | {
3005
- type: "thinking";
3006
- thinking: string;
3007
- thinkingSignature?: string;
3008
- redacted?: boolean;
3009
2993
  } | {
3010
2994
  addedToolNames?: string[];
3011
2995
  arguments: Record<string, any>;
3012
2996
  callID: string;
3013
2997
  name: string;
3014
2998
  namespace?: string;
3015
- partial?: {
3016
- content?: ({
2999
+ result: {
3000
+ content: ({
3017
3001
  type: "text";
3018
3002
  text: string;
3019
3003
  textSignature?: string;
@@ -3023,8 +3007,9 @@ declare const encodeMessage: (message: {
3023
3007
  mimeType: string;
3024
3008
  })[];
3025
3009
  details?: any;
3010
+ isError: true;
3026
3011
  };
3027
- status: "running";
3012
+ status: "aborted";
3028
3013
  thoughtSignature?: string;
3029
3014
  time: {
3030
3015
  start: number;
@@ -3049,8 +3034,7 @@ declare const encodeMessage: (message: {
3049
3034
  responseId?: string;
3050
3035
  responseModel?: string;
3051
3036
  messageId: string;
3052
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3053
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3037
+ } | {
3054
3038
  messageId: string;
3055
3039
  role: "user";
3056
3040
  time: {
@@ -3065,8 +3049,8 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3065
3049
  data: string;
3066
3050
  mimeType: string;
3067
3051
  })[];
3068
- }, ContextDecodeError, never>;
3069
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3052
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3053
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3070
3054
  messageId: string;
3071
3055
  role: "user";
3072
3056
  time: {
@@ -3081,7 +3065,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3081
3065
  data: string;
3082
3066
  mimeType: string;
3083
3067
  })[];
3084
- } | {
3068
+ }, ContextDecodeError, never>;
3069
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3085
3070
  role: "assistant";
3086
3071
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3087
3072
  provider: {
@@ -3231,14 +3216,19 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3231
3216
  type: "image";
3232
3217
  data: string;
3233
3218
  mimeType: string;
3219
+ } | {
3220
+ type: "thinking";
3221
+ thinking: string;
3222
+ thinkingSignature?: string;
3223
+ redacted?: boolean;
3234
3224
  } | {
3235
3225
  addedToolNames?: string[];
3236
3226
  arguments: Record<string, any>;
3237
3227
  callID: string;
3238
3228
  name: string;
3239
3229
  namespace?: string;
3240
- result: {
3241
- content: ({
3230
+ partial?: {
3231
+ content?: ({
3242
3232
  type: "text";
3243
3233
  text: string;
3244
3234
  textSignature?: string;
@@ -3248,9 +3238,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3248
3238
  mimeType: string;
3249
3239
  })[];
3250
3240
  details?: any;
3251
- isError: false;
3252
3241
  };
3253
- status: "completed";
3242
+ status: "running";
3254
3243
  thoughtSignature?: string;
3255
3244
  time: {
3256
3245
  start: number;
@@ -3274,9 +3263,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3274
3263
  mimeType: string;
3275
3264
  })[];
3276
3265
  details?: any;
3277
- isError: true;
3266
+ isError: false;
3278
3267
  };
3279
- status: "error";
3268
+ status: "completed";
3280
3269
  thoughtSignature?: string;
3281
3270
  time: {
3282
3271
  start: number;
@@ -3302,7 +3291,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3302
3291
  details?: any;
3303
3292
  isError: true;
3304
3293
  };
3305
- status: "skipped";
3294
+ status: "error";
3306
3295
  thoughtSignature?: string;
3307
3296
  time: {
3308
3297
  start: number;
@@ -3328,26 +3317,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3328
3317
  details?: any;
3329
3318
  isError: true;
3330
3319
  };
3331
- status: "aborted";
3320
+ status: "skipped";
3332
3321
  thoughtSignature?: string;
3333
3322
  time: {
3334
3323
  start: number;
3335
3324
  end: number;
3336
3325
  };
3337
3326
  type: "toolCall";
3338
- } | {
3339
- type: "thinking";
3340
- thinking: string;
3341
- thinkingSignature?: string;
3342
- redacted?: boolean;
3343
3327
  } | {
3344
3328
  addedToolNames?: string[];
3345
3329
  arguments: Record<string, any>;
3346
3330
  callID: string;
3347
3331
  name: string;
3348
3332
  namespace?: string;
3349
- partial?: {
3350
- content?: ({
3333
+ result: {
3334
+ content: ({
3351
3335
  type: "text";
3352
3336
  text: string;
3353
3337
  textSignature?: string;
@@ -3357,8 +3341,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3357
3341
  mimeType: string;
3358
3342
  })[];
3359
3343
  details?: any;
3344
+ isError: true;
3360
3345
  };
3361
- status: "running";
3346
+ status: "aborted";
3362
3347
  thoughtSignature?: string;
3363
3348
  time: {
3364
3349
  start: number;
@@ -3383,6 +3368,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3383
3368
  responseId?: string;
3384
3369
  responseModel?: string;
3385
3370
  messageId: string;
3371
+ } | {
3372
+ messageId: string;
3373
+ role: "user";
3374
+ time: {
3375
+ created: number;
3376
+ };
3377
+ parts: ({
3378
+ type: "text";
3379
+ text: string;
3380
+ textSignature?: string;
3381
+ } | {
3382
+ type: "image";
3383
+ data: string;
3384
+ mimeType: string;
3385
+ })[];
3386
3386
  }, ContextDecodeError, never>;
3387
3387
  declare namespace context_d_exports {
3388
3388
  export { context_d_exports as Context, assemble_d_exports as ContextAssembly, codec_d_exports as ContextCodec, ContextDecodeError, ContextEncodeError, ContextInvariantError, ContextReadError, EncodedMessage, Interface$1 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$4 as layer, validateUserMessage };
@@ -4873,14 +4873,19 @@ declare const LLMStarted: Schema.Struct<{
4873
4873
  type: "image";
4874
4874
  data: string;
4875
4875
  mimeType: string;
4876
+ } | {
4877
+ type: "thinking";
4878
+ thinking: string;
4879
+ thinkingSignature?: string;
4880
+ redacted?: boolean;
4876
4881
  } | {
4877
4882
  addedToolNames?: string[];
4878
4883
  arguments: Record<string, any>;
4879
4884
  callID: string;
4880
4885
  name: string;
4881
4886
  namespace?: string;
4882
- result: {
4883
- content: ({
4887
+ partial?: {
4888
+ content?: ({
4884
4889
  type: "text";
4885
4890
  text: string;
4886
4891
  textSignature?: string;
@@ -4890,9 +4895,8 @@ declare const LLMStarted: Schema.Struct<{
4890
4895
  mimeType: string;
4891
4896
  })[];
4892
4897
  details?: any;
4893
- isError: false;
4894
4898
  };
4895
- status: "completed";
4899
+ status: "running";
4896
4900
  thoughtSignature?: string;
4897
4901
  time: {
4898
4902
  start: number;
@@ -4916,9 +4920,9 @@ declare const LLMStarted: Schema.Struct<{
4916
4920
  mimeType: string;
4917
4921
  })[];
4918
4922
  details?: any;
4919
- isError: true;
4923
+ isError: false;
4920
4924
  };
4921
- status: "error";
4925
+ status: "completed";
4922
4926
  thoughtSignature?: string;
4923
4927
  time: {
4924
4928
  start: number;
@@ -4944,7 +4948,7 @@ declare const LLMStarted: Schema.Struct<{
4944
4948
  details?: any;
4945
4949
  isError: true;
4946
4950
  };
4947
- status: "skipped";
4951
+ status: "error";
4948
4952
  thoughtSignature?: string;
4949
4953
  time: {
4950
4954
  start: number;
@@ -4970,26 +4974,21 @@ declare const LLMStarted: Schema.Struct<{
4970
4974
  details?: any;
4971
4975
  isError: true;
4972
4976
  };
4973
- status: "aborted";
4977
+ status: "skipped";
4974
4978
  thoughtSignature?: string;
4975
4979
  time: {
4976
4980
  start: number;
4977
4981
  end: number;
4978
4982
  };
4979
4983
  type: "toolCall";
4980
- } | {
4981
- type: "thinking";
4982
- thinking: string;
4983
- thinkingSignature?: string;
4984
- redacted?: boolean;
4985
4984
  } | {
4986
4985
  addedToolNames?: string[];
4987
4986
  arguments: Record<string, any>;
4988
4987
  callID: string;
4989
4988
  name: string;
4990
4989
  namespace?: string;
4991
- partial?: {
4992
- content?: ({
4990
+ result: {
4991
+ content: ({
4993
4992
  type: "text";
4994
4993
  text: string;
4995
4994
  textSignature?: string;
@@ -4999,8 +4998,9 @@ declare const LLMStarted: Schema.Struct<{
4999
4998
  mimeType: string;
5000
4999
  })[];
5001
5000
  details?: any;
5001
+ isError: true;
5002
5002
  };
5003
- status: "running";
5003
+ status: "aborted";
5004
5004
  thoughtSignature?: string;
5005
5005
  time: {
5006
5006
  start: number;
@@ -5175,14 +5175,19 @@ declare const LLMStarted: Schema.Struct<{
5175
5175
  type: "image";
5176
5176
  data: string;
5177
5177
  mimeType: string;
5178
+ } | {
5179
+ type: "thinking";
5180
+ thinking: string;
5181
+ thinkingSignature?: string;
5182
+ redacted?: boolean;
5178
5183
  } | {
5179
5184
  addedToolNames?: string[];
5180
5185
  arguments: Record<string, any>;
5181
5186
  callID: string;
5182
5187
  name: string;
5183
5188
  namespace?: string;
5184
- result: {
5185
- content: ({
5189
+ partial?: {
5190
+ content?: ({
5186
5191
  type: "text";
5187
5192
  text: string;
5188
5193
  textSignature?: string;
@@ -5192,9 +5197,8 @@ declare const LLMStarted: Schema.Struct<{
5192
5197
  mimeType: string;
5193
5198
  })[];
5194
5199
  details?: any;
5195
- isError: false;
5196
5200
  };
5197
- status: "completed";
5201
+ status: "running";
5198
5202
  thoughtSignature?: string;
5199
5203
  time: {
5200
5204
  start: number;
@@ -5218,9 +5222,9 @@ declare const LLMStarted: Schema.Struct<{
5218
5222
  mimeType: string;
5219
5223
  })[];
5220
5224
  details?: any;
5221
- isError: true;
5225
+ isError: false;
5222
5226
  };
5223
- status: "error";
5227
+ status: "completed";
5224
5228
  thoughtSignature?: string;
5225
5229
  time: {
5226
5230
  start: number;
@@ -5246,7 +5250,7 @@ declare const LLMStarted: Schema.Struct<{
5246
5250
  details?: any;
5247
5251
  isError: true;
5248
5252
  };
5249
- status: "skipped";
5253
+ status: "error";
5250
5254
  thoughtSignature?: string;
5251
5255
  time: {
5252
5256
  start: number;
@@ -5272,26 +5276,21 @@ declare const LLMStarted: Schema.Struct<{
5272
5276
  details?: any;
5273
5277
  isError: true;
5274
5278
  };
5275
- status: "aborted";
5279
+ status: "skipped";
5276
5280
  thoughtSignature?: string;
5277
5281
  time: {
5278
5282
  start: number;
5279
5283
  end: number;
5280
5284
  };
5281
5285
  type: "toolCall";
5282
- } | {
5283
- type: "thinking";
5284
- thinking: string;
5285
- thinkingSignature?: string;
5286
- redacted?: boolean;
5287
5286
  } | {
5288
5287
  addedToolNames?: string[];
5289
5288
  arguments: Record<string, any>;
5290
5289
  callID: string;
5291
5290
  name: string;
5292
5291
  namespace?: string;
5293
- partial?: {
5294
- content?: ({
5292
+ result: {
5293
+ content: ({
5295
5294
  type: "text";
5296
5295
  text: string;
5297
5296
  textSignature?: string;
@@ -5301,8 +5300,9 @@ declare const LLMStarted: Schema.Struct<{
5301
5300
  mimeType: string;
5302
5301
  })[];
5303
5302
  details?: any;
5303
+ isError: true;
5304
5304
  };
5305
- status: "running";
5305
+ status: "aborted";
5306
5306
  thoughtSignature?: string;
5307
5307
  time: {
5308
5308
  start: number;
@@ -5495,14 +5495,19 @@ declare const LLMStarted: Schema.Struct<{
5495
5495
  type: "image";
5496
5496
  data: string;
5497
5497
  mimeType: string;
5498
+ } | {
5499
+ type: "thinking";
5500
+ thinking: string;
5501
+ thinkingSignature?: string;
5502
+ redacted?: boolean;
5498
5503
  } | {
5499
5504
  addedToolNames?: string[];
5500
5505
  arguments: Record<string, any>;
5501
5506
  callID: string;
5502
5507
  name: string;
5503
5508
  namespace?: string;
5504
- result: {
5505
- content: ({
5509
+ partial?: {
5510
+ content?: ({
5506
5511
  type: "text";
5507
5512
  text: string;
5508
5513
  textSignature?: string;
@@ -5512,9 +5517,8 @@ declare const LLMStarted: Schema.Struct<{
5512
5517
  mimeType: string;
5513
5518
  })[];
5514
5519
  details?: any;
5515
- isError: false;
5516
5520
  };
5517
- status: "completed";
5521
+ status: "running";
5518
5522
  thoughtSignature?: string;
5519
5523
  time: {
5520
5524
  start: number;
@@ -5538,9 +5542,9 @@ declare const LLMStarted: Schema.Struct<{
5538
5542
  mimeType: string;
5539
5543
  })[];
5540
5544
  details?: any;
5541
- isError: true;
5545
+ isError: false;
5542
5546
  };
5543
- status: "error";
5547
+ status: "completed";
5544
5548
  thoughtSignature?: string;
5545
5549
  time: {
5546
5550
  start: number;
@@ -5566,7 +5570,7 @@ declare const LLMStarted: Schema.Struct<{
5566
5570
  details?: any;
5567
5571
  isError: true;
5568
5572
  };
5569
- status: "skipped";
5573
+ status: "error";
5570
5574
  thoughtSignature?: string;
5571
5575
  time: {
5572
5576
  start: number;
@@ -5592,26 +5596,21 @@ declare const LLMStarted: Schema.Struct<{
5592
5596
  details?: any;
5593
5597
  isError: true;
5594
5598
  };
5595
- status: "aborted";
5599
+ status: "skipped";
5596
5600
  thoughtSignature?: string;
5597
5601
  time: {
5598
5602
  start: number;
5599
5603
  end: number;
5600
5604
  };
5601
5605
  type: "toolCall";
5602
- } | {
5603
- type: "thinking";
5604
- thinking: string;
5605
- thinkingSignature?: string;
5606
- redacted?: boolean;
5607
5606
  } | {
5608
5607
  addedToolNames?: string[];
5609
5608
  arguments: Record<string, any>;
5610
5609
  callID: string;
5611
5610
  name: string;
5612
5611
  namespace?: string;
5613
- partial?: {
5614
- content?: ({
5612
+ result: {
5613
+ content: ({
5615
5614
  type: "text";
5616
5615
  text: string;
5617
5616
  textSignature?: string;
@@ -5621,8 +5620,9 @@ declare const LLMStarted: Schema.Struct<{
5621
5620
  mimeType: string;
5622
5621
  })[];
5623
5622
  details?: any;
5623
+ isError: true;
5624
5624
  };
5625
- status: "running";
5625
+ status: "aborted";
5626
5626
  thoughtSignature?: string;
5627
5627
  time: {
5628
5628
  start: number;
@@ -5797,14 +5797,19 @@ declare const LLMStarted: Schema.Struct<{
5797
5797
  type: "image";
5798
5798
  data: string;
5799
5799
  mimeType: string;
5800
+ } | {
5801
+ type: "thinking";
5802
+ thinking: string;
5803
+ thinkingSignature?: string;
5804
+ redacted?: boolean;
5800
5805
  } | {
5801
5806
  addedToolNames?: string[];
5802
5807
  arguments: Record<string, any>;
5803
5808
  callID: string;
5804
5809
  name: string;
5805
5810
  namespace?: string;
5806
- result: {
5807
- content: ({
5811
+ partial?: {
5812
+ content?: ({
5808
5813
  type: "text";
5809
5814
  text: string;
5810
5815
  textSignature?: string;
@@ -5814,9 +5819,8 @@ declare const LLMStarted: Schema.Struct<{
5814
5819
  mimeType: string;
5815
5820
  })[];
5816
5821
  details?: any;
5817
- isError: false;
5818
5822
  };
5819
- status: "completed";
5823
+ status: "running";
5820
5824
  thoughtSignature?: string;
5821
5825
  time: {
5822
5826
  start: number;
@@ -5840,9 +5844,9 @@ declare const LLMStarted: Schema.Struct<{
5840
5844
  mimeType: string;
5841
5845
  })[];
5842
5846
  details?: any;
5843
- isError: true;
5847
+ isError: false;
5844
5848
  };
5845
- status: "error";
5849
+ status: "completed";
5846
5850
  thoughtSignature?: string;
5847
5851
  time: {
5848
5852
  start: number;
@@ -5868,7 +5872,7 @@ declare const LLMStarted: Schema.Struct<{
5868
5872
  details?: any;
5869
5873
  isError: true;
5870
5874
  };
5871
- status: "skipped";
5875
+ status: "error";
5872
5876
  thoughtSignature?: string;
5873
5877
  time: {
5874
5878
  start: number;
@@ -5894,26 +5898,21 @@ declare const LLMStarted: Schema.Struct<{
5894
5898
  details?: any;
5895
5899
  isError: true;
5896
5900
  };
5897
- status: "aborted";
5901
+ status: "skipped";
5898
5902
  thoughtSignature?: string;
5899
5903
  time: {
5900
5904
  start: number;
5901
5905
  end: number;
5902
5906
  };
5903
5907
  type: "toolCall";
5904
- } | {
5905
- type: "thinking";
5906
- thinking: string;
5907
- thinkingSignature?: string;
5908
- redacted?: boolean;
5909
5908
  } | {
5910
5909
  addedToolNames?: string[];
5911
5910
  arguments: Record<string, any>;
5912
5911
  callID: string;
5913
5912
  name: string;
5914
5913
  namespace?: string;
5915
- partial?: {
5916
- content?: ({
5914
+ result: {
5915
+ content: ({
5917
5916
  type: "text";
5918
5917
  text: string;
5919
5918
  textSignature?: string;
@@ -5923,8 +5922,9 @@ declare const LLMStarted: Schema.Struct<{
5923
5922
  mimeType: string;
5924
5923
  })[];
5925
5924
  details?: any;
5925
+ isError: true;
5926
5926
  };
5927
- status: "running";
5927
+ status: "aborted";
5928
5928
  thoughtSignature?: string;
5929
5929
  time: {
5930
5930
  start: number;
@@ -6420,14 +6420,19 @@ declare const LLMEnded: Schema.Struct<{
6420
6420
  type: "image";
6421
6421
  data: string;
6422
6422
  mimeType: string;
6423
+ } | {
6424
+ type: "thinking";
6425
+ thinking: string;
6426
+ thinkingSignature?: string;
6427
+ redacted?: boolean;
6423
6428
  } | {
6424
6429
  addedToolNames?: string[];
6425
6430
  arguments: Record<string, any>;
6426
6431
  callID: string;
6427
6432
  name: string;
6428
6433
  namespace?: string;
6429
- result: {
6430
- content: ({
6434
+ partial?: {
6435
+ content?: ({
6431
6436
  type: "text";
6432
6437
  text: string;
6433
6438
  textSignature?: string;
@@ -6437,9 +6442,8 @@ declare const LLMEnded: Schema.Struct<{
6437
6442
  mimeType: string;
6438
6443
  })[];
6439
6444
  details?: any;
6440
- isError: false;
6441
6445
  };
6442
- status: "completed";
6446
+ status: "running";
6443
6447
  thoughtSignature?: string;
6444
6448
  time: {
6445
6449
  start: number;
@@ -6463,9 +6467,9 @@ declare const LLMEnded: Schema.Struct<{
6463
6467
  mimeType: string;
6464
6468
  })[];
6465
6469
  details?: any;
6466
- isError: true;
6470
+ isError: false;
6467
6471
  };
6468
- status: "error";
6472
+ status: "completed";
6469
6473
  thoughtSignature?: string;
6470
6474
  time: {
6471
6475
  start: number;
@@ -6491,7 +6495,7 @@ declare const LLMEnded: Schema.Struct<{
6491
6495
  details?: any;
6492
6496
  isError: true;
6493
6497
  };
6494
- status: "skipped";
6498
+ status: "error";
6495
6499
  thoughtSignature?: string;
6496
6500
  time: {
6497
6501
  start: number;
@@ -6517,26 +6521,21 @@ declare const LLMEnded: Schema.Struct<{
6517
6521
  details?: any;
6518
6522
  isError: true;
6519
6523
  };
6520
- status: "aborted";
6524
+ status: "skipped";
6521
6525
  thoughtSignature?: string;
6522
6526
  time: {
6523
6527
  start: number;
6524
6528
  end: number;
6525
6529
  };
6526
6530
  type: "toolCall";
6527
- } | {
6528
- type: "thinking";
6529
- thinking: string;
6530
- thinkingSignature?: string;
6531
- redacted?: boolean;
6532
6531
  } | {
6533
6532
  addedToolNames?: string[];
6534
6533
  arguments: Record<string, any>;
6535
6534
  callID: string;
6536
6535
  name: string;
6537
6536
  namespace?: string;
6538
- partial?: {
6539
- content?: ({
6537
+ result: {
6538
+ content: ({
6540
6539
  type: "text";
6541
6540
  text: string;
6542
6541
  textSignature?: string;
@@ -6546,8 +6545,9 @@ declare const LLMEnded: Schema.Struct<{
6546
6545
  mimeType: string;
6547
6546
  })[];
6548
6547
  details?: any;
6548
+ isError: true;
6549
6549
  };
6550
- status: "running";
6550
+ status: "aborted";
6551
6551
  thoughtSignature?: string;
6552
6552
  time: {
6553
6553
  start: number;
@@ -6722,14 +6722,19 @@ declare const LLMEnded: Schema.Struct<{
6722
6722
  type: "image";
6723
6723
  data: string;
6724
6724
  mimeType: string;
6725
+ } | {
6726
+ type: "thinking";
6727
+ thinking: string;
6728
+ thinkingSignature?: string;
6729
+ redacted?: boolean;
6725
6730
  } | {
6726
6731
  addedToolNames?: string[];
6727
6732
  arguments: Record<string, any>;
6728
6733
  callID: string;
6729
6734
  name: string;
6730
6735
  namespace?: string;
6731
- result: {
6732
- content: ({
6736
+ partial?: {
6737
+ content?: ({
6733
6738
  type: "text";
6734
6739
  text: string;
6735
6740
  textSignature?: string;
@@ -6739,9 +6744,8 @@ declare const LLMEnded: Schema.Struct<{
6739
6744
  mimeType: string;
6740
6745
  })[];
6741
6746
  details?: any;
6742
- isError: false;
6743
6747
  };
6744
- status: "completed";
6748
+ status: "running";
6745
6749
  thoughtSignature?: string;
6746
6750
  time: {
6747
6751
  start: number;
@@ -6765,9 +6769,9 @@ declare const LLMEnded: Schema.Struct<{
6765
6769
  mimeType: string;
6766
6770
  })[];
6767
6771
  details?: any;
6768
- isError: true;
6772
+ isError: false;
6769
6773
  };
6770
- status: "error";
6774
+ status: "completed";
6771
6775
  thoughtSignature?: string;
6772
6776
  time: {
6773
6777
  start: number;
@@ -6793,7 +6797,7 @@ declare const LLMEnded: Schema.Struct<{
6793
6797
  details?: any;
6794
6798
  isError: true;
6795
6799
  };
6796
- status: "skipped";
6800
+ status: "error";
6797
6801
  thoughtSignature?: string;
6798
6802
  time: {
6799
6803
  start: number;
@@ -6819,26 +6823,21 @@ declare const LLMEnded: Schema.Struct<{
6819
6823
  details?: any;
6820
6824
  isError: true;
6821
6825
  };
6822
- status: "aborted";
6826
+ status: "skipped";
6823
6827
  thoughtSignature?: string;
6824
6828
  time: {
6825
6829
  start: number;
6826
6830
  end: number;
6827
6831
  };
6828
6832
  type: "toolCall";
6829
- } | {
6830
- type: "thinking";
6831
- thinking: string;
6832
- thinkingSignature?: string;
6833
- redacted?: boolean;
6834
6833
  } | {
6835
6834
  addedToolNames?: string[];
6836
6835
  arguments: Record<string, any>;
6837
6836
  callID: string;
6838
6837
  name: string;
6839
6838
  namespace?: string;
6840
- partial?: {
6841
- content?: ({
6839
+ result: {
6840
+ content: ({
6842
6841
  type: "text";
6843
6842
  text: string;
6844
6843
  textSignature?: string;
@@ -6848,8 +6847,9 @@ declare const LLMEnded: Schema.Struct<{
6848
6847
  mimeType: string;
6849
6848
  })[];
6850
6849
  details?: any;
6850
+ isError: true;
6851
6851
  };
6852
- status: "running";
6852
+ status: "aborted";
6853
6853
  thoughtSignature?: string;
6854
6854
  time: {
6855
6855
  start: number;
@@ -7043,14 +7043,19 @@ declare const LLMEnded: Schema.Struct<{
7043
7043
  type: "image";
7044
7044
  data: string;
7045
7045
  mimeType: string;
7046
+ } | {
7047
+ type: "thinking";
7048
+ thinking: string;
7049
+ thinkingSignature?: string;
7050
+ redacted?: boolean;
7046
7051
  } | {
7047
7052
  addedToolNames?: string[];
7048
7053
  arguments: Record<string, any>;
7049
7054
  callID: string;
7050
7055
  name: string;
7051
7056
  namespace?: string;
7052
- result: {
7053
- content: ({
7057
+ partial?: {
7058
+ content?: ({
7054
7059
  type: "text";
7055
7060
  text: string;
7056
7061
  textSignature?: string;
@@ -7060,9 +7065,8 @@ declare const LLMEnded: Schema.Struct<{
7060
7065
  mimeType: string;
7061
7066
  })[];
7062
7067
  details?: any;
7063
- isError: false;
7064
7068
  };
7065
- status: "completed";
7069
+ status: "running";
7066
7070
  thoughtSignature?: string;
7067
7071
  time: {
7068
7072
  start: number;
@@ -7086,9 +7090,9 @@ declare const LLMEnded: Schema.Struct<{
7086
7090
  mimeType: string;
7087
7091
  })[];
7088
7092
  details?: any;
7089
- isError: true;
7093
+ isError: false;
7090
7094
  };
7091
- status: "error";
7095
+ status: "completed";
7092
7096
  thoughtSignature?: string;
7093
7097
  time: {
7094
7098
  start: number;
@@ -7114,7 +7118,7 @@ declare const LLMEnded: Schema.Struct<{
7114
7118
  details?: any;
7115
7119
  isError: true;
7116
7120
  };
7117
- status: "skipped";
7121
+ status: "error";
7118
7122
  thoughtSignature?: string;
7119
7123
  time: {
7120
7124
  start: number;
@@ -7140,26 +7144,21 @@ declare const LLMEnded: Schema.Struct<{
7140
7144
  details?: any;
7141
7145
  isError: true;
7142
7146
  };
7143
- status: "aborted";
7147
+ status: "skipped";
7144
7148
  thoughtSignature?: string;
7145
7149
  time: {
7146
7150
  start: number;
7147
7151
  end: number;
7148
7152
  };
7149
7153
  type: "toolCall";
7150
- } | {
7151
- type: "thinking";
7152
- thinking: string;
7153
- thinkingSignature?: string;
7154
- redacted?: boolean;
7155
7154
  } | {
7156
7155
  addedToolNames?: string[];
7157
7156
  arguments: Record<string, any>;
7158
7157
  callID: string;
7159
7158
  name: string;
7160
7159
  namespace?: string;
7161
- partial?: {
7162
- content?: ({
7160
+ result: {
7161
+ content: ({
7163
7162
  type: "text";
7164
7163
  text: string;
7165
7164
  textSignature?: string;
@@ -7169,8 +7168,9 @@ declare const LLMEnded: Schema.Struct<{
7169
7168
  mimeType: string;
7170
7169
  })[];
7171
7170
  details?: any;
7171
+ isError: true;
7172
7172
  };
7173
- status: "running";
7173
+ status: "aborted";
7174
7174
  thoughtSignature?: string;
7175
7175
  time: {
7176
7176
  start: number;
@@ -7345,14 +7345,19 @@ declare const LLMEnded: Schema.Struct<{
7345
7345
  type: "image";
7346
7346
  data: string;
7347
7347
  mimeType: string;
7348
+ } | {
7349
+ type: "thinking";
7350
+ thinking: string;
7351
+ thinkingSignature?: string;
7352
+ redacted?: boolean;
7348
7353
  } | {
7349
7354
  addedToolNames?: string[];
7350
7355
  arguments: Record<string, any>;
7351
7356
  callID: string;
7352
7357
  name: string;
7353
7358
  namespace?: string;
7354
- result: {
7355
- content: ({
7359
+ partial?: {
7360
+ content?: ({
7356
7361
  type: "text";
7357
7362
  text: string;
7358
7363
  textSignature?: string;
@@ -7362,9 +7367,8 @@ declare const LLMEnded: Schema.Struct<{
7362
7367
  mimeType: string;
7363
7368
  })[];
7364
7369
  details?: any;
7365
- isError: false;
7366
7370
  };
7367
- status: "completed";
7371
+ status: "running";
7368
7372
  thoughtSignature?: string;
7369
7373
  time: {
7370
7374
  start: number;
@@ -7388,9 +7392,9 @@ declare const LLMEnded: Schema.Struct<{
7388
7392
  mimeType: string;
7389
7393
  })[];
7390
7394
  details?: any;
7391
- isError: true;
7395
+ isError: false;
7392
7396
  };
7393
- status: "error";
7397
+ status: "completed";
7394
7398
  thoughtSignature?: string;
7395
7399
  time: {
7396
7400
  start: number;
@@ -7416,7 +7420,7 @@ declare const LLMEnded: Schema.Struct<{
7416
7420
  details?: any;
7417
7421
  isError: true;
7418
7422
  };
7419
- status: "skipped";
7423
+ status: "error";
7420
7424
  thoughtSignature?: string;
7421
7425
  time: {
7422
7426
  start: number;
@@ -7442,26 +7446,21 @@ declare const LLMEnded: Schema.Struct<{
7442
7446
  details?: any;
7443
7447
  isError: true;
7444
7448
  };
7445
- status: "aborted";
7449
+ status: "skipped";
7446
7450
  thoughtSignature?: string;
7447
7451
  time: {
7448
7452
  start: number;
7449
7453
  end: number;
7450
7454
  };
7451
7455
  type: "toolCall";
7452
- } | {
7453
- type: "thinking";
7454
- thinking: string;
7455
- thinkingSignature?: string;
7456
- redacted?: boolean;
7457
7456
  } | {
7458
7457
  addedToolNames?: string[];
7459
7458
  arguments: Record<string, any>;
7460
7459
  callID: string;
7461
7460
  name: string;
7462
7461
  namespace?: string;
7463
- partial?: {
7464
- content?: ({
7462
+ result: {
7463
+ content: ({
7465
7464
  type: "text";
7466
7465
  text: string;
7467
7466
  textSignature?: string;
@@ -7471,8 +7470,9 @@ declare const LLMEnded: Schema.Struct<{
7471
7470
  mimeType: string;
7472
7471
  })[];
7473
7472
  details?: any;
7473
+ isError: true;
7474
7474
  };
7475
- status: "running";
7475
+ status: "aborted";
7476
7476
  thoughtSignature?: string;
7477
7477
  time: {
7478
7478
  start: number;
@@ -7678,14 +7678,19 @@ declare const LLMFailed: Schema.Struct<{
7678
7678
  type: "image";
7679
7679
  data: string;
7680
7680
  mimeType: string;
7681
+ } | {
7682
+ type: "thinking";
7683
+ thinking: string;
7684
+ thinkingSignature?: string;
7685
+ redacted?: boolean;
7681
7686
  } | {
7682
7687
  addedToolNames?: string[];
7683
7688
  arguments: Record<string, any>;
7684
7689
  callID: string;
7685
7690
  name: string;
7686
7691
  namespace?: string;
7687
- result: {
7688
- content: ({
7692
+ partial?: {
7693
+ content?: ({
7689
7694
  type: "text";
7690
7695
  text: string;
7691
7696
  textSignature?: string;
@@ -7695,9 +7700,8 @@ declare const LLMFailed: Schema.Struct<{
7695
7700
  mimeType: string;
7696
7701
  })[];
7697
7702
  details?: any;
7698
- isError: false;
7699
7703
  };
7700
- status: "completed";
7704
+ status: "running";
7701
7705
  thoughtSignature?: string;
7702
7706
  time: {
7703
7707
  start: number;
@@ -7721,9 +7725,9 @@ declare const LLMFailed: Schema.Struct<{
7721
7725
  mimeType: string;
7722
7726
  })[];
7723
7727
  details?: any;
7724
- isError: true;
7728
+ isError: false;
7725
7729
  };
7726
- status: "error";
7730
+ status: "completed";
7727
7731
  thoughtSignature?: string;
7728
7732
  time: {
7729
7733
  start: number;
@@ -7749,7 +7753,7 @@ declare const LLMFailed: Schema.Struct<{
7749
7753
  details?: any;
7750
7754
  isError: true;
7751
7755
  };
7752
- status: "skipped";
7756
+ status: "error";
7753
7757
  thoughtSignature?: string;
7754
7758
  time: {
7755
7759
  start: number;
@@ -7775,26 +7779,21 @@ declare const LLMFailed: Schema.Struct<{
7775
7779
  details?: any;
7776
7780
  isError: true;
7777
7781
  };
7778
- status: "aborted";
7782
+ status: "skipped";
7779
7783
  thoughtSignature?: string;
7780
7784
  time: {
7781
7785
  start: number;
7782
7786
  end: number;
7783
7787
  };
7784
7788
  type: "toolCall";
7785
- } | {
7786
- type: "thinking";
7787
- thinking: string;
7788
- thinkingSignature?: string;
7789
- redacted?: boolean;
7790
7789
  } | {
7791
7790
  addedToolNames?: string[];
7792
7791
  arguments: Record<string, any>;
7793
7792
  callID: string;
7794
7793
  name: string;
7795
7794
  namespace?: string;
7796
- partial?: {
7797
- content?: ({
7795
+ result: {
7796
+ content: ({
7798
7797
  type: "text";
7799
7798
  text: string;
7800
7799
  textSignature?: string;
@@ -7804,8 +7803,9 @@ declare const LLMFailed: Schema.Struct<{
7804
7803
  mimeType: string;
7805
7804
  })[];
7806
7805
  details?: any;
7806
+ isError: true;
7807
7807
  };
7808
- status: "running";
7808
+ status: "aborted";
7809
7809
  thoughtSignature?: string;
7810
7810
  time: {
7811
7811
  start: number;
@@ -7980,14 +7980,19 @@ declare const LLMFailed: Schema.Struct<{
7980
7980
  type: "image";
7981
7981
  data: string;
7982
7982
  mimeType: string;
7983
+ } | {
7984
+ type: "thinking";
7985
+ thinking: string;
7986
+ thinkingSignature?: string;
7987
+ redacted?: boolean;
7983
7988
  } | {
7984
7989
  addedToolNames?: string[];
7985
7990
  arguments: Record<string, any>;
7986
7991
  callID: string;
7987
7992
  name: string;
7988
7993
  namespace?: string;
7989
- result: {
7990
- content: ({
7994
+ partial?: {
7995
+ content?: ({
7991
7996
  type: "text";
7992
7997
  text: string;
7993
7998
  textSignature?: string;
@@ -7997,9 +8002,8 @@ declare const LLMFailed: Schema.Struct<{
7997
8002
  mimeType: string;
7998
8003
  })[];
7999
8004
  details?: any;
8000
- isError: false;
8001
8005
  };
8002
- status: "completed";
8006
+ status: "running";
8003
8007
  thoughtSignature?: string;
8004
8008
  time: {
8005
8009
  start: number;
@@ -8023,9 +8027,9 @@ declare const LLMFailed: Schema.Struct<{
8023
8027
  mimeType: string;
8024
8028
  })[];
8025
8029
  details?: any;
8026
- isError: true;
8030
+ isError: false;
8027
8031
  };
8028
- status: "error";
8032
+ status: "completed";
8029
8033
  thoughtSignature?: string;
8030
8034
  time: {
8031
8035
  start: number;
@@ -8051,7 +8055,7 @@ declare const LLMFailed: Schema.Struct<{
8051
8055
  details?: any;
8052
8056
  isError: true;
8053
8057
  };
8054
- status: "skipped";
8058
+ status: "error";
8055
8059
  thoughtSignature?: string;
8056
8060
  time: {
8057
8061
  start: number;
@@ -8077,26 +8081,21 @@ declare const LLMFailed: Schema.Struct<{
8077
8081
  details?: any;
8078
8082
  isError: true;
8079
8083
  };
8080
- status: "aborted";
8084
+ status: "skipped";
8081
8085
  thoughtSignature?: string;
8082
8086
  time: {
8083
8087
  start: number;
8084
8088
  end: number;
8085
8089
  };
8086
8090
  type: "toolCall";
8087
- } | {
8088
- type: "thinking";
8089
- thinking: string;
8090
- thinkingSignature?: string;
8091
- redacted?: boolean;
8092
8091
  } | {
8093
8092
  addedToolNames?: string[];
8094
8093
  arguments: Record<string, any>;
8095
8094
  callID: string;
8096
8095
  name: string;
8097
8096
  namespace?: string;
8098
- partial?: {
8099
- content?: ({
8097
+ result: {
8098
+ content: ({
8100
8099
  type: "text";
8101
8100
  text: string;
8102
8101
  textSignature?: string;
@@ -8106,8 +8105,9 @@ declare const LLMFailed: Schema.Struct<{
8106
8105
  mimeType: string;
8107
8106
  })[];
8108
8107
  details?: any;
8108
+ isError: true;
8109
8109
  };
8110
- status: "running";
8110
+ status: "aborted";
8111
8111
  thoughtSignature?: string;
8112
8112
  time: {
8113
8113
  start: number;
@@ -8301,14 +8301,19 @@ declare const LLMFailed: Schema.Struct<{
8301
8301
  type: "image";
8302
8302
  data: string;
8303
8303
  mimeType: string;
8304
+ } | {
8305
+ type: "thinking";
8306
+ thinking: string;
8307
+ thinkingSignature?: string;
8308
+ redacted?: boolean;
8304
8309
  } | {
8305
8310
  addedToolNames?: string[];
8306
8311
  arguments: Record<string, any>;
8307
8312
  callID: string;
8308
8313
  name: string;
8309
8314
  namespace?: string;
8310
- result: {
8311
- content: ({
8315
+ partial?: {
8316
+ content?: ({
8312
8317
  type: "text";
8313
8318
  text: string;
8314
8319
  textSignature?: string;
@@ -8318,9 +8323,8 @@ declare const LLMFailed: Schema.Struct<{
8318
8323
  mimeType: string;
8319
8324
  })[];
8320
8325
  details?: any;
8321
- isError: false;
8322
8326
  };
8323
- status: "completed";
8327
+ status: "running";
8324
8328
  thoughtSignature?: string;
8325
8329
  time: {
8326
8330
  start: number;
@@ -8344,9 +8348,9 @@ declare const LLMFailed: Schema.Struct<{
8344
8348
  mimeType: string;
8345
8349
  })[];
8346
8350
  details?: any;
8347
- isError: true;
8351
+ isError: false;
8348
8352
  };
8349
- status: "error";
8353
+ status: "completed";
8350
8354
  thoughtSignature?: string;
8351
8355
  time: {
8352
8356
  start: number;
@@ -8372,7 +8376,7 @@ declare const LLMFailed: Schema.Struct<{
8372
8376
  details?: any;
8373
8377
  isError: true;
8374
8378
  };
8375
- status: "skipped";
8379
+ status: "error";
8376
8380
  thoughtSignature?: string;
8377
8381
  time: {
8378
8382
  start: number;
@@ -8398,26 +8402,21 @@ declare const LLMFailed: Schema.Struct<{
8398
8402
  details?: any;
8399
8403
  isError: true;
8400
8404
  };
8401
- status: "aborted";
8405
+ status: "skipped";
8402
8406
  thoughtSignature?: string;
8403
8407
  time: {
8404
8408
  start: number;
8405
8409
  end: number;
8406
8410
  };
8407
8411
  type: "toolCall";
8408
- } | {
8409
- type: "thinking";
8410
- thinking: string;
8411
- thinkingSignature?: string;
8412
- redacted?: boolean;
8413
8412
  } | {
8414
8413
  addedToolNames?: string[];
8415
8414
  arguments: Record<string, any>;
8416
8415
  callID: string;
8417
8416
  name: string;
8418
8417
  namespace?: string;
8419
- partial?: {
8420
- content?: ({
8418
+ result: {
8419
+ content: ({
8421
8420
  type: "text";
8422
8421
  text: string;
8423
8422
  textSignature?: string;
@@ -8427,8 +8426,9 @@ declare const LLMFailed: Schema.Struct<{
8427
8426
  mimeType: string;
8428
8427
  })[];
8429
8428
  details?: any;
8429
+ isError: true;
8430
8430
  };
8431
- status: "running";
8431
+ status: "aborted";
8432
8432
  thoughtSignature?: string;
8433
8433
  time: {
8434
8434
  start: number;
@@ -8603,14 +8603,19 @@ declare const LLMFailed: Schema.Struct<{
8603
8603
  type: "image";
8604
8604
  data: string;
8605
8605
  mimeType: string;
8606
+ } | {
8607
+ type: "thinking";
8608
+ thinking: string;
8609
+ thinkingSignature?: string;
8610
+ redacted?: boolean;
8606
8611
  } | {
8607
8612
  addedToolNames?: string[];
8608
8613
  arguments: Record<string, any>;
8609
8614
  callID: string;
8610
8615
  name: string;
8611
8616
  namespace?: string;
8612
- result: {
8613
- content: ({
8617
+ partial?: {
8618
+ content?: ({
8614
8619
  type: "text";
8615
8620
  text: string;
8616
8621
  textSignature?: string;
@@ -8620,9 +8625,8 @@ declare const LLMFailed: Schema.Struct<{
8620
8625
  mimeType: string;
8621
8626
  })[];
8622
8627
  details?: any;
8623
- isError: false;
8624
8628
  };
8625
- status: "completed";
8629
+ status: "running";
8626
8630
  thoughtSignature?: string;
8627
8631
  time: {
8628
8632
  start: number;
@@ -8646,9 +8650,9 @@ declare const LLMFailed: Schema.Struct<{
8646
8650
  mimeType: string;
8647
8651
  })[];
8648
8652
  details?: any;
8649
- isError: true;
8653
+ isError: false;
8650
8654
  };
8651
- status: "error";
8655
+ status: "completed";
8652
8656
  thoughtSignature?: string;
8653
8657
  time: {
8654
8658
  start: number;
@@ -8674,7 +8678,7 @@ declare const LLMFailed: Schema.Struct<{
8674
8678
  details?: any;
8675
8679
  isError: true;
8676
8680
  };
8677
- status: "skipped";
8681
+ status: "error";
8678
8682
  thoughtSignature?: string;
8679
8683
  time: {
8680
8684
  start: number;
@@ -8700,26 +8704,21 @@ declare const LLMFailed: Schema.Struct<{
8700
8704
  details?: any;
8701
8705
  isError: true;
8702
8706
  };
8703
- status: "aborted";
8707
+ status: "skipped";
8704
8708
  thoughtSignature?: string;
8705
8709
  time: {
8706
8710
  start: number;
8707
8711
  end: number;
8708
8712
  };
8709
8713
  type: "toolCall";
8710
- } | {
8711
- type: "thinking";
8712
- thinking: string;
8713
- thinkingSignature?: string;
8714
- redacted?: boolean;
8715
8714
  } | {
8716
8715
  addedToolNames?: string[];
8717
8716
  arguments: Record<string, any>;
8718
8717
  callID: string;
8719
8718
  name: string;
8720
8719
  namespace?: string;
8721
- partial?: {
8722
- content?: ({
8720
+ result: {
8721
+ content: ({
8723
8722
  type: "text";
8724
8723
  text: string;
8725
8724
  textSignature?: string;
@@ -8729,8 +8728,9 @@ declare const LLMFailed: Schema.Struct<{
8729
8728
  mimeType: string;
8730
8729
  })[];
8731
8730
  details?: any;
8731
+ isError: true;
8732
8732
  };
8733
- status: "running";
8733
+ status: "aborted";
8734
8734
  thoughtSignature?: string;
8735
8735
  time: {
8736
8736
  start: number;
@@ -10478,14 +10478,19 @@ declare const Definitions: readonly [Schema.Struct<{
10478
10478
  type: "image";
10479
10479
  data: string;
10480
10480
  mimeType: string;
10481
+ } | {
10482
+ type: "thinking";
10483
+ thinking: string;
10484
+ thinkingSignature?: string;
10485
+ redacted?: boolean;
10481
10486
  } | {
10482
10487
  addedToolNames?: string[];
10483
10488
  arguments: Record<string, any>;
10484
10489
  callID: string;
10485
10490
  name: string;
10486
10491
  namespace?: string;
10487
- result: {
10488
- content: ({
10492
+ partial?: {
10493
+ content?: ({
10489
10494
  type: "text";
10490
10495
  text: string;
10491
10496
  textSignature?: string;
@@ -10495,9 +10500,8 @@ declare const Definitions: readonly [Schema.Struct<{
10495
10500
  mimeType: string;
10496
10501
  })[];
10497
10502
  details?: any;
10498
- isError: false;
10499
10503
  };
10500
- status: "completed";
10504
+ status: "running";
10501
10505
  thoughtSignature?: string;
10502
10506
  time: {
10503
10507
  start: number;
@@ -10521,9 +10525,9 @@ declare const Definitions: readonly [Schema.Struct<{
10521
10525
  mimeType: string;
10522
10526
  })[];
10523
10527
  details?: any;
10524
- isError: true;
10528
+ isError: false;
10525
10529
  };
10526
- status: "error";
10530
+ status: "completed";
10527
10531
  thoughtSignature?: string;
10528
10532
  time: {
10529
10533
  start: number;
@@ -10549,7 +10553,7 @@ declare const Definitions: readonly [Schema.Struct<{
10549
10553
  details?: any;
10550
10554
  isError: true;
10551
10555
  };
10552
- status: "skipped";
10556
+ status: "error";
10553
10557
  thoughtSignature?: string;
10554
10558
  time: {
10555
10559
  start: number;
@@ -10575,26 +10579,21 @@ declare const Definitions: readonly [Schema.Struct<{
10575
10579
  details?: any;
10576
10580
  isError: true;
10577
10581
  };
10578
- status: "aborted";
10582
+ status: "skipped";
10579
10583
  thoughtSignature?: string;
10580
10584
  time: {
10581
10585
  start: number;
10582
10586
  end: number;
10583
10587
  };
10584
10588
  type: "toolCall";
10585
- } | {
10586
- type: "thinking";
10587
- thinking: string;
10588
- thinkingSignature?: string;
10589
- redacted?: boolean;
10590
10589
  } | {
10591
10590
  addedToolNames?: string[];
10592
10591
  arguments: Record<string, any>;
10593
10592
  callID: string;
10594
10593
  name: string;
10595
10594
  namespace?: string;
10596
- partial?: {
10597
- content?: ({
10595
+ result: {
10596
+ content: ({
10598
10597
  type: "text";
10599
10598
  text: string;
10600
10599
  textSignature?: string;
@@ -10604,8 +10603,9 @@ declare const Definitions: readonly [Schema.Struct<{
10604
10603
  mimeType: string;
10605
10604
  })[];
10606
10605
  details?: any;
10606
+ isError: true;
10607
10607
  };
10608
- status: "running";
10608
+ status: "aborted";
10609
10609
  thoughtSignature?: string;
10610
10610
  time: {
10611
10611
  start: number;
@@ -10780,14 +10780,19 @@ declare const Definitions: readonly [Schema.Struct<{
10780
10780
  type: "image";
10781
10781
  data: string;
10782
10782
  mimeType: string;
10783
+ } | {
10784
+ type: "thinking";
10785
+ thinking: string;
10786
+ thinkingSignature?: string;
10787
+ redacted?: boolean;
10783
10788
  } | {
10784
10789
  addedToolNames?: string[];
10785
10790
  arguments: Record<string, any>;
10786
10791
  callID: string;
10787
10792
  name: string;
10788
10793
  namespace?: string;
10789
- result: {
10790
- content: ({
10794
+ partial?: {
10795
+ content?: ({
10791
10796
  type: "text";
10792
10797
  text: string;
10793
10798
  textSignature?: string;
@@ -10797,9 +10802,8 @@ declare const Definitions: readonly [Schema.Struct<{
10797
10802
  mimeType: string;
10798
10803
  })[];
10799
10804
  details?: any;
10800
- isError: false;
10801
10805
  };
10802
- status: "completed";
10806
+ status: "running";
10803
10807
  thoughtSignature?: string;
10804
10808
  time: {
10805
10809
  start: number;
@@ -10823,9 +10827,9 @@ declare const Definitions: readonly [Schema.Struct<{
10823
10827
  mimeType: string;
10824
10828
  })[];
10825
10829
  details?: any;
10826
- isError: true;
10830
+ isError: false;
10827
10831
  };
10828
- status: "error";
10832
+ status: "completed";
10829
10833
  thoughtSignature?: string;
10830
10834
  time: {
10831
10835
  start: number;
@@ -10851,7 +10855,7 @@ declare const Definitions: readonly [Schema.Struct<{
10851
10855
  details?: any;
10852
10856
  isError: true;
10853
10857
  };
10854
- status: "skipped";
10858
+ status: "error";
10855
10859
  thoughtSignature?: string;
10856
10860
  time: {
10857
10861
  start: number;
@@ -10877,26 +10881,21 @@ declare const Definitions: readonly [Schema.Struct<{
10877
10881
  details?: any;
10878
10882
  isError: true;
10879
10883
  };
10880
- status: "aborted";
10884
+ status: "skipped";
10881
10885
  thoughtSignature?: string;
10882
10886
  time: {
10883
10887
  start: number;
10884
10888
  end: number;
10885
10889
  };
10886
10890
  type: "toolCall";
10887
- } | {
10888
- type: "thinking";
10889
- thinking: string;
10890
- thinkingSignature?: string;
10891
- redacted?: boolean;
10892
10891
  } | {
10893
10892
  addedToolNames?: string[];
10894
10893
  arguments: Record<string, any>;
10895
10894
  callID: string;
10896
10895
  name: string;
10897
10896
  namespace?: string;
10898
- partial?: {
10899
- content?: ({
10897
+ result: {
10898
+ content: ({
10900
10899
  type: "text";
10901
10900
  text: string;
10902
10901
  textSignature?: string;
@@ -10906,8 +10905,9 @@ declare const Definitions: readonly [Schema.Struct<{
10906
10905
  mimeType: string;
10907
10906
  })[];
10908
10907
  details?: any;
10908
+ isError: true;
10909
10909
  };
10910
- status: "running";
10910
+ status: "aborted";
10911
10911
  thoughtSignature?: string;
10912
10912
  time: {
10913
10913
  start: number;
@@ -11100,14 +11100,19 @@ declare const Definitions: readonly [Schema.Struct<{
11100
11100
  type: "image";
11101
11101
  data: string;
11102
11102
  mimeType: string;
11103
+ } | {
11104
+ type: "thinking";
11105
+ thinking: string;
11106
+ thinkingSignature?: string;
11107
+ redacted?: boolean;
11103
11108
  } | {
11104
11109
  addedToolNames?: string[];
11105
11110
  arguments: Record<string, any>;
11106
11111
  callID: string;
11107
11112
  name: string;
11108
11113
  namespace?: string;
11109
- result: {
11110
- content: ({
11114
+ partial?: {
11115
+ content?: ({
11111
11116
  type: "text";
11112
11117
  text: string;
11113
11118
  textSignature?: string;
@@ -11117,9 +11122,8 @@ declare const Definitions: readonly [Schema.Struct<{
11117
11122
  mimeType: string;
11118
11123
  })[];
11119
11124
  details?: any;
11120
- isError: false;
11121
11125
  };
11122
- status: "completed";
11126
+ status: "running";
11123
11127
  thoughtSignature?: string;
11124
11128
  time: {
11125
11129
  start: number;
@@ -11143,9 +11147,9 @@ declare const Definitions: readonly [Schema.Struct<{
11143
11147
  mimeType: string;
11144
11148
  })[];
11145
11149
  details?: any;
11146
- isError: true;
11150
+ isError: false;
11147
11151
  };
11148
- status: "error";
11152
+ status: "completed";
11149
11153
  thoughtSignature?: string;
11150
11154
  time: {
11151
11155
  start: number;
@@ -11171,7 +11175,7 @@ declare const Definitions: readonly [Schema.Struct<{
11171
11175
  details?: any;
11172
11176
  isError: true;
11173
11177
  };
11174
- status: "skipped";
11178
+ status: "error";
11175
11179
  thoughtSignature?: string;
11176
11180
  time: {
11177
11181
  start: number;
@@ -11197,26 +11201,21 @@ declare const Definitions: readonly [Schema.Struct<{
11197
11201
  details?: any;
11198
11202
  isError: true;
11199
11203
  };
11200
- status: "aborted";
11204
+ status: "skipped";
11201
11205
  thoughtSignature?: string;
11202
11206
  time: {
11203
11207
  start: number;
11204
11208
  end: number;
11205
11209
  };
11206
11210
  type: "toolCall";
11207
- } | {
11208
- type: "thinking";
11209
- thinking: string;
11210
- thinkingSignature?: string;
11211
- redacted?: boolean;
11212
11211
  } | {
11213
11212
  addedToolNames?: string[];
11214
11213
  arguments: Record<string, any>;
11215
11214
  callID: string;
11216
11215
  name: string;
11217
11216
  namespace?: string;
11218
- partial?: {
11219
- content?: ({
11217
+ result: {
11218
+ content: ({
11220
11219
  type: "text";
11221
11220
  text: string;
11222
11221
  textSignature?: string;
@@ -11226,8 +11225,9 @@ declare const Definitions: readonly [Schema.Struct<{
11226
11225
  mimeType: string;
11227
11226
  })[];
11228
11227
  details?: any;
11228
+ isError: true;
11229
11229
  };
11230
- status: "running";
11230
+ status: "aborted";
11231
11231
  thoughtSignature?: string;
11232
11232
  time: {
11233
11233
  start: number;
@@ -11402,14 +11402,19 @@ declare const Definitions: readonly [Schema.Struct<{
11402
11402
  type: "image";
11403
11403
  data: string;
11404
11404
  mimeType: string;
11405
+ } | {
11406
+ type: "thinking";
11407
+ thinking: string;
11408
+ thinkingSignature?: string;
11409
+ redacted?: boolean;
11405
11410
  } | {
11406
11411
  addedToolNames?: string[];
11407
11412
  arguments: Record<string, any>;
11408
11413
  callID: string;
11409
11414
  name: string;
11410
11415
  namespace?: string;
11411
- result: {
11412
- content: ({
11416
+ partial?: {
11417
+ content?: ({
11413
11418
  type: "text";
11414
11419
  text: string;
11415
11420
  textSignature?: string;
@@ -11419,9 +11424,8 @@ declare const Definitions: readonly [Schema.Struct<{
11419
11424
  mimeType: string;
11420
11425
  })[];
11421
11426
  details?: any;
11422
- isError: false;
11423
11427
  };
11424
- status: "completed";
11428
+ status: "running";
11425
11429
  thoughtSignature?: string;
11426
11430
  time: {
11427
11431
  start: number;
@@ -11445,9 +11449,9 @@ declare const Definitions: readonly [Schema.Struct<{
11445
11449
  mimeType: string;
11446
11450
  })[];
11447
11451
  details?: any;
11448
- isError: true;
11452
+ isError: false;
11449
11453
  };
11450
- status: "error";
11454
+ status: "completed";
11451
11455
  thoughtSignature?: string;
11452
11456
  time: {
11453
11457
  start: number;
@@ -11473,7 +11477,7 @@ declare const Definitions: readonly [Schema.Struct<{
11473
11477
  details?: any;
11474
11478
  isError: true;
11475
11479
  };
11476
- status: "skipped";
11480
+ status: "error";
11477
11481
  thoughtSignature?: string;
11478
11482
  time: {
11479
11483
  start: number;
@@ -11499,26 +11503,21 @@ declare const Definitions: readonly [Schema.Struct<{
11499
11503
  details?: any;
11500
11504
  isError: true;
11501
11505
  };
11502
- status: "aborted";
11506
+ status: "skipped";
11503
11507
  thoughtSignature?: string;
11504
11508
  time: {
11505
11509
  start: number;
11506
11510
  end: number;
11507
11511
  };
11508
11512
  type: "toolCall";
11509
- } | {
11510
- type: "thinking";
11511
- thinking: string;
11512
- thinkingSignature?: string;
11513
- redacted?: boolean;
11514
11513
  } | {
11515
11514
  addedToolNames?: string[];
11516
11515
  arguments: Record<string, any>;
11517
11516
  callID: string;
11518
11517
  name: string;
11519
11518
  namespace?: string;
11520
- partial?: {
11521
- content?: ({
11519
+ result: {
11520
+ content: ({
11522
11521
  type: "text";
11523
11522
  text: string;
11524
11523
  textSignature?: string;
@@ -11528,8 +11527,9 @@ declare const Definitions: readonly [Schema.Struct<{
11528
11527
  mimeType: string;
11529
11528
  })[];
11530
11529
  details?: any;
11530
+ isError: true;
11531
11531
  };
11532
- status: "running";
11532
+ status: "aborted";
11533
11533
  thoughtSignature?: string;
11534
11534
  time: {
11535
11535
  start: number;
@@ -12010,14 +12010,19 @@ declare const Definitions: readonly [Schema.Struct<{
12010
12010
  type: "image";
12011
12011
  data: string;
12012
12012
  mimeType: string;
12013
+ } | {
12014
+ type: "thinking";
12015
+ thinking: string;
12016
+ thinkingSignature?: string;
12017
+ redacted?: boolean;
12013
12018
  } | {
12014
12019
  addedToolNames?: string[];
12015
12020
  arguments: Record<string, any>;
12016
12021
  callID: string;
12017
12022
  name: string;
12018
12023
  namespace?: string;
12019
- result: {
12020
- content: ({
12024
+ partial?: {
12025
+ content?: ({
12021
12026
  type: "text";
12022
12027
  text: string;
12023
12028
  textSignature?: string;
@@ -12027,9 +12032,8 @@ declare const Definitions: readonly [Schema.Struct<{
12027
12032
  mimeType: string;
12028
12033
  })[];
12029
12034
  details?: any;
12030
- isError: false;
12031
12035
  };
12032
- status: "completed";
12036
+ status: "running";
12033
12037
  thoughtSignature?: string;
12034
12038
  time: {
12035
12039
  start: number;
@@ -12053,9 +12057,9 @@ declare const Definitions: readonly [Schema.Struct<{
12053
12057
  mimeType: string;
12054
12058
  })[];
12055
12059
  details?: any;
12056
- isError: true;
12060
+ isError: false;
12057
12061
  };
12058
- status: "error";
12062
+ status: "completed";
12059
12063
  thoughtSignature?: string;
12060
12064
  time: {
12061
12065
  start: number;
@@ -12081,7 +12085,7 @@ declare const Definitions: readonly [Schema.Struct<{
12081
12085
  details?: any;
12082
12086
  isError: true;
12083
12087
  };
12084
- status: "skipped";
12088
+ status: "error";
12085
12089
  thoughtSignature?: string;
12086
12090
  time: {
12087
12091
  start: number;
@@ -12107,26 +12111,21 @@ declare const Definitions: readonly [Schema.Struct<{
12107
12111
  details?: any;
12108
12112
  isError: true;
12109
12113
  };
12110
- status: "aborted";
12114
+ status: "skipped";
12111
12115
  thoughtSignature?: string;
12112
12116
  time: {
12113
12117
  start: number;
12114
12118
  end: number;
12115
12119
  };
12116
12120
  type: "toolCall";
12117
- } | {
12118
- type: "thinking";
12119
- thinking: string;
12120
- thinkingSignature?: string;
12121
- redacted?: boolean;
12122
12121
  } | {
12123
12122
  addedToolNames?: string[];
12124
12123
  arguments: Record<string, any>;
12125
12124
  callID: string;
12126
12125
  name: string;
12127
12126
  namespace?: string;
12128
- partial?: {
12129
- content?: ({
12127
+ result: {
12128
+ content: ({
12130
12129
  type: "text";
12131
12130
  text: string;
12132
12131
  textSignature?: string;
@@ -12136,8 +12135,9 @@ declare const Definitions: readonly [Schema.Struct<{
12136
12135
  mimeType: string;
12137
12136
  })[];
12138
12137
  details?: any;
12138
+ isError: true;
12139
12139
  };
12140
- status: "running";
12140
+ status: "aborted";
12141
12141
  thoughtSignature?: string;
12142
12142
  time: {
12143
12143
  start: number;
@@ -12312,14 +12312,19 @@ declare const Definitions: readonly [Schema.Struct<{
12312
12312
  type: "image";
12313
12313
  data: string;
12314
12314
  mimeType: string;
12315
+ } | {
12316
+ type: "thinking";
12317
+ thinking: string;
12318
+ thinkingSignature?: string;
12319
+ redacted?: boolean;
12315
12320
  } | {
12316
12321
  addedToolNames?: string[];
12317
12322
  arguments: Record<string, any>;
12318
12323
  callID: string;
12319
12324
  name: string;
12320
12325
  namespace?: string;
12321
- result: {
12322
- content: ({
12326
+ partial?: {
12327
+ content?: ({
12323
12328
  type: "text";
12324
12329
  text: string;
12325
12330
  textSignature?: string;
@@ -12329,9 +12334,8 @@ declare const Definitions: readonly [Schema.Struct<{
12329
12334
  mimeType: string;
12330
12335
  })[];
12331
12336
  details?: any;
12332
- isError: false;
12333
12337
  };
12334
- status: "completed";
12338
+ status: "running";
12335
12339
  thoughtSignature?: string;
12336
12340
  time: {
12337
12341
  start: number;
@@ -12355,9 +12359,9 @@ declare const Definitions: readonly [Schema.Struct<{
12355
12359
  mimeType: string;
12356
12360
  })[];
12357
12361
  details?: any;
12358
- isError: true;
12362
+ isError: false;
12359
12363
  };
12360
- status: "error";
12364
+ status: "completed";
12361
12365
  thoughtSignature?: string;
12362
12366
  time: {
12363
12367
  start: number;
@@ -12383,7 +12387,7 @@ declare const Definitions: readonly [Schema.Struct<{
12383
12387
  details?: any;
12384
12388
  isError: true;
12385
12389
  };
12386
- status: "skipped";
12390
+ status: "error";
12387
12391
  thoughtSignature?: string;
12388
12392
  time: {
12389
12393
  start: number;
@@ -12409,26 +12413,21 @@ declare const Definitions: readonly [Schema.Struct<{
12409
12413
  details?: any;
12410
12414
  isError: true;
12411
12415
  };
12412
- status: "aborted";
12416
+ status: "skipped";
12413
12417
  thoughtSignature?: string;
12414
12418
  time: {
12415
12419
  start: number;
12416
12420
  end: number;
12417
12421
  };
12418
12422
  type: "toolCall";
12419
- } | {
12420
- type: "thinking";
12421
- thinking: string;
12422
- thinkingSignature?: string;
12423
- redacted?: boolean;
12424
12423
  } | {
12425
12424
  addedToolNames?: string[];
12426
12425
  arguments: Record<string, any>;
12427
12426
  callID: string;
12428
12427
  name: string;
12429
12428
  namespace?: string;
12430
- partial?: {
12431
- content?: ({
12429
+ result: {
12430
+ content: ({
12432
12431
  type: "text";
12433
12432
  text: string;
12434
12433
  textSignature?: string;
@@ -12438,8 +12437,9 @@ declare const Definitions: readonly [Schema.Struct<{
12438
12437
  mimeType: string;
12439
12438
  })[];
12440
12439
  details?: any;
12440
+ isError: true;
12441
12441
  };
12442
- status: "running";
12442
+ status: "aborted";
12443
12443
  thoughtSignature?: string;
12444
12444
  time: {
12445
12445
  start: number;
@@ -12633,14 +12633,19 @@ declare const Definitions: readonly [Schema.Struct<{
12633
12633
  type: "image";
12634
12634
  data: string;
12635
12635
  mimeType: string;
12636
+ } | {
12637
+ type: "thinking";
12638
+ thinking: string;
12639
+ thinkingSignature?: string;
12640
+ redacted?: boolean;
12636
12641
  } | {
12637
12642
  addedToolNames?: string[];
12638
12643
  arguments: Record<string, any>;
12639
12644
  callID: string;
12640
12645
  name: string;
12641
12646
  namespace?: string;
12642
- result: {
12643
- content: ({
12647
+ partial?: {
12648
+ content?: ({
12644
12649
  type: "text";
12645
12650
  text: string;
12646
12651
  textSignature?: string;
@@ -12650,9 +12655,8 @@ declare const Definitions: readonly [Schema.Struct<{
12650
12655
  mimeType: string;
12651
12656
  })[];
12652
12657
  details?: any;
12653
- isError: false;
12654
12658
  };
12655
- status: "completed";
12659
+ status: "running";
12656
12660
  thoughtSignature?: string;
12657
12661
  time: {
12658
12662
  start: number;
@@ -12676,9 +12680,9 @@ declare const Definitions: readonly [Schema.Struct<{
12676
12680
  mimeType: string;
12677
12681
  })[];
12678
12682
  details?: any;
12679
- isError: true;
12683
+ isError: false;
12680
12684
  };
12681
- status: "error";
12685
+ status: "completed";
12682
12686
  thoughtSignature?: string;
12683
12687
  time: {
12684
12688
  start: number;
@@ -12704,7 +12708,7 @@ declare const Definitions: readonly [Schema.Struct<{
12704
12708
  details?: any;
12705
12709
  isError: true;
12706
12710
  };
12707
- status: "skipped";
12711
+ status: "error";
12708
12712
  thoughtSignature?: string;
12709
12713
  time: {
12710
12714
  start: number;
@@ -12730,26 +12734,21 @@ declare const Definitions: readonly [Schema.Struct<{
12730
12734
  details?: any;
12731
12735
  isError: true;
12732
12736
  };
12733
- status: "aborted";
12737
+ status: "skipped";
12734
12738
  thoughtSignature?: string;
12735
12739
  time: {
12736
12740
  start: number;
12737
12741
  end: number;
12738
12742
  };
12739
12743
  type: "toolCall";
12740
- } | {
12741
- type: "thinking";
12742
- thinking: string;
12743
- thinkingSignature?: string;
12744
- redacted?: boolean;
12745
12744
  } | {
12746
12745
  addedToolNames?: string[];
12747
12746
  arguments: Record<string, any>;
12748
12747
  callID: string;
12749
12748
  name: string;
12750
12749
  namespace?: string;
12751
- partial?: {
12752
- content?: ({
12750
+ result: {
12751
+ content: ({
12753
12752
  type: "text";
12754
12753
  text: string;
12755
12754
  textSignature?: string;
@@ -12759,8 +12758,9 @@ declare const Definitions: readonly [Schema.Struct<{
12759
12758
  mimeType: string;
12760
12759
  })[];
12761
12760
  details?: any;
12761
+ isError: true;
12762
12762
  };
12763
- status: "running";
12763
+ status: "aborted";
12764
12764
  thoughtSignature?: string;
12765
12765
  time: {
12766
12766
  start: number;
@@ -12935,14 +12935,19 @@ declare const Definitions: readonly [Schema.Struct<{
12935
12935
  type: "image";
12936
12936
  data: string;
12937
12937
  mimeType: string;
12938
+ } | {
12939
+ type: "thinking";
12940
+ thinking: string;
12941
+ thinkingSignature?: string;
12942
+ redacted?: boolean;
12938
12943
  } | {
12939
12944
  addedToolNames?: string[];
12940
12945
  arguments: Record<string, any>;
12941
12946
  callID: string;
12942
12947
  name: string;
12943
12948
  namespace?: string;
12944
- result: {
12945
- content: ({
12949
+ partial?: {
12950
+ content?: ({
12946
12951
  type: "text";
12947
12952
  text: string;
12948
12953
  textSignature?: string;
@@ -12952,9 +12957,8 @@ declare const Definitions: readonly [Schema.Struct<{
12952
12957
  mimeType: string;
12953
12958
  })[];
12954
12959
  details?: any;
12955
- isError: false;
12956
12960
  };
12957
- status: "completed";
12961
+ status: "running";
12958
12962
  thoughtSignature?: string;
12959
12963
  time: {
12960
12964
  start: number;
@@ -12978,9 +12982,9 @@ declare const Definitions: readonly [Schema.Struct<{
12978
12982
  mimeType: string;
12979
12983
  })[];
12980
12984
  details?: any;
12981
- isError: true;
12985
+ isError: false;
12982
12986
  };
12983
- status: "error";
12987
+ status: "completed";
12984
12988
  thoughtSignature?: string;
12985
12989
  time: {
12986
12990
  start: number;
@@ -13006,7 +13010,7 @@ declare const Definitions: readonly [Schema.Struct<{
13006
13010
  details?: any;
13007
13011
  isError: true;
13008
13012
  };
13009
- status: "skipped";
13013
+ status: "error";
13010
13014
  thoughtSignature?: string;
13011
13015
  time: {
13012
13016
  start: number;
@@ -13032,26 +13036,21 @@ declare const Definitions: readonly [Schema.Struct<{
13032
13036
  details?: any;
13033
13037
  isError: true;
13034
13038
  };
13035
- status: "aborted";
13039
+ status: "skipped";
13036
13040
  thoughtSignature?: string;
13037
13041
  time: {
13038
13042
  start: number;
13039
13043
  end: number;
13040
13044
  };
13041
13045
  type: "toolCall";
13042
- } | {
13043
- type: "thinking";
13044
- thinking: string;
13045
- thinkingSignature?: string;
13046
- redacted?: boolean;
13047
13046
  } | {
13048
13047
  addedToolNames?: string[];
13049
13048
  arguments: Record<string, any>;
13050
13049
  callID: string;
13051
13050
  name: string;
13052
13051
  namespace?: string;
13053
- partial?: {
13054
- content?: ({
13052
+ result: {
13053
+ content: ({
13055
13054
  type: "text";
13056
13055
  text: string;
13057
13056
  textSignature?: string;
@@ -13061,8 +13060,9 @@ declare const Definitions: readonly [Schema.Struct<{
13061
13060
  mimeType: string;
13062
13061
  })[];
13063
13062
  details?: any;
13063
+ isError: true;
13064
13064
  };
13065
- status: "running";
13065
+ status: "aborted";
13066
13066
  thoughtSignature?: string;
13067
13067
  time: {
13068
13068
  start: number;
@@ -13265,14 +13265,19 @@ declare const Definitions: readonly [Schema.Struct<{
13265
13265
  type: "image";
13266
13266
  data: string;
13267
13267
  mimeType: string;
13268
+ } | {
13269
+ type: "thinking";
13270
+ thinking: string;
13271
+ thinkingSignature?: string;
13272
+ redacted?: boolean;
13268
13273
  } | {
13269
13274
  addedToolNames?: string[];
13270
13275
  arguments: Record<string, any>;
13271
13276
  callID: string;
13272
13277
  name: string;
13273
13278
  namespace?: string;
13274
- result: {
13275
- content: ({
13279
+ partial?: {
13280
+ content?: ({
13276
13281
  type: "text";
13277
13282
  text: string;
13278
13283
  textSignature?: string;
@@ -13282,9 +13287,8 @@ declare const Definitions: readonly [Schema.Struct<{
13282
13287
  mimeType: string;
13283
13288
  })[];
13284
13289
  details?: any;
13285
- isError: false;
13286
13290
  };
13287
- status: "completed";
13291
+ status: "running";
13288
13292
  thoughtSignature?: string;
13289
13293
  time: {
13290
13294
  start: number;
@@ -13308,9 +13312,9 @@ declare const Definitions: readonly [Schema.Struct<{
13308
13312
  mimeType: string;
13309
13313
  })[];
13310
13314
  details?: any;
13311
- isError: true;
13315
+ isError: false;
13312
13316
  };
13313
- status: "error";
13317
+ status: "completed";
13314
13318
  thoughtSignature?: string;
13315
13319
  time: {
13316
13320
  start: number;
@@ -13336,7 +13340,7 @@ declare const Definitions: readonly [Schema.Struct<{
13336
13340
  details?: any;
13337
13341
  isError: true;
13338
13342
  };
13339
- status: "skipped";
13343
+ status: "error";
13340
13344
  thoughtSignature?: string;
13341
13345
  time: {
13342
13346
  start: number;
@@ -13362,26 +13366,21 @@ declare const Definitions: readonly [Schema.Struct<{
13362
13366
  details?: any;
13363
13367
  isError: true;
13364
13368
  };
13365
- status: "aborted";
13369
+ status: "skipped";
13366
13370
  thoughtSignature?: string;
13367
13371
  time: {
13368
13372
  start: number;
13369
13373
  end: number;
13370
13374
  };
13371
13375
  type: "toolCall";
13372
- } | {
13373
- type: "thinking";
13374
- thinking: string;
13375
- thinkingSignature?: string;
13376
- redacted?: boolean;
13377
13376
  } | {
13378
13377
  addedToolNames?: string[];
13379
13378
  arguments: Record<string, any>;
13380
13379
  callID: string;
13381
13380
  name: string;
13382
13381
  namespace?: string;
13383
- partial?: {
13384
- content?: ({
13382
+ result: {
13383
+ content: ({
13385
13384
  type: "text";
13386
13385
  text: string;
13387
13386
  textSignature?: string;
@@ -13391,8 +13390,9 @@ declare const Definitions: readonly [Schema.Struct<{
13391
13390
  mimeType: string;
13392
13391
  })[];
13393
13392
  details?: any;
13393
+ isError: true;
13394
13394
  };
13395
- status: "running";
13395
+ status: "aborted";
13396
13396
  thoughtSignature?: string;
13397
13397
  time: {
13398
13398
  start: number;
@@ -13567,14 +13567,19 @@ declare const Definitions: readonly [Schema.Struct<{
13567
13567
  type: "image";
13568
13568
  data: string;
13569
13569
  mimeType: string;
13570
+ } | {
13571
+ type: "thinking";
13572
+ thinking: string;
13573
+ thinkingSignature?: string;
13574
+ redacted?: boolean;
13570
13575
  } | {
13571
13576
  addedToolNames?: string[];
13572
13577
  arguments: Record<string, any>;
13573
13578
  callID: string;
13574
13579
  name: string;
13575
13580
  namespace?: string;
13576
- result: {
13577
- content: ({
13581
+ partial?: {
13582
+ content?: ({
13578
13583
  type: "text";
13579
13584
  text: string;
13580
13585
  textSignature?: string;
@@ -13584,9 +13589,8 @@ declare const Definitions: readonly [Schema.Struct<{
13584
13589
  mimeType: string;
13585
13590
  })[];
13586
13591
  details?: any;
13587
- isError: false;
13588
13592
  };
13589
- status: "completed";
13593
+ status: "running";
13590
13594
  thoughtSignature?: string;
13591
13595
  time: {
13592
13596
  start: number;
@@ -13610,9 +13614,9 @@ declare const Definitions: readonly [Schema.Struct<{
13610
13614
  mimeType: string;
13611
13615
  })[];
13612
13616
  details?: any;
13613
- isError: true;
13617
+ isError: false;
13614
13618
  };
13615
- status: "error";
13619
+ status: "completed";
13616
13620
  thoughtSignature?: string;
13617
13621
  time: {
13618
13622
  start: number;
@@ -13638,7 +13642,7 @@ declare const Definitions: readonly [Schema.Struct<{
13638
13642
  details?: any;
13639
13643
  isError: true;
13640
13644
  };
13641
- status: "skipped";
13645
+ status: "error";
13642
13646
  thoughtSignature?: string;
13643
13647
  time: {
13644
13648
  start: number;
@@ -13664,26 +13668,21 @@ declare const Definitions: readonly [Schema.Struct<{
13664
13668
  details?: any;
13665
13669
  isError: true;
13666
13670
  };
13667
- status: "aborted";
13671
+ status: "skipped";
13668
13672
  thoughtSignature?: string;
13669
13673
  time: {
13670
13674
  start: number;
13671
13675
  end: number;
13672
13676
  };
13673
13677
  type: "toolCall";
13674
- } | {
13675
- type: "thinking";
13676
- thinking: string;
13677
- thinkingSignature?: string;
13678
- redacted?: boolean;
13679
13678
  } | {
13680
13679
  addedToolNames?: string[];
13681
13680
  arguments: Record<string, any>;
13682
13681
  callID: string;
13683
13682
  name: string;
13684
13683
  namespace?: string;
13685
- partial?: {
13686
- content?: ({
13684
+ result: {
13685
+ content: ({
13687
13686
  type: "text";
13688
13687
  text: string;
13689
13688
  textSignature?: string;
@@ -13693,8 +13692,9 @@ declare const Definitions: readonly [Schema.Struct<{
13693
13692
  mimeType: string;
13694
13693
  })[];
13695
13694
  details?: any;
13695
+ isError: true;
13696
13696
  };
13697
- status: "running";
13697
+ status: "aborted";
13698
13698
  thoughtSignature?: string;
13699
13699
  time: {
13700
13700
  start: number;
@@ -13888,14 +13888,19 @@ declare const Definitions: readonly [Schema.Struct<{
13888
13888
  type: "image";
13889
13889
  data: string;
13890
13890
  mimeType: string;
13891
+ } | {
13892
+ type: "thinking";
13893
+ thinking: string;
13894
+ thinkingSignature?: string;
13895
+ redacted?: boolean;
13891
13896
  } | {
13892
13897
  addedToolNames?: string[];
13893
13898
  arguments: Record<string, any>;
13894
13899
  callID: string;
13895
13900
  name: string;
13896
13901
  namespace?: string;
13897
- result: {
13898
- content: ({
13902
+ partial?: {
13903
+ content?: ({
13899
13904
  type: "text";
13900
13905
  text: string;
13901
13906
  textSignature?: string;
@@ -13905,9 +13910,8 @@ declare const Definitions: readonly [Schema.Struct<{
13905
13910
  mimeType: string;
13906
13911
  })[];
13907
13912
  details?: any;
13908
- isError: false;
13909
13913
  };
13910
- status: "completed";
13914
+ status: "running";
13911
13915
  thoughtSignature?: string;
13912
13916
  time: {
13913
13917
  start: number;
@@ -13931,9 +13935,9 @@ declare const Definitions: readonly [Schema.Struct<{
13931
13935
  mimeType: string;
13932
13936
  })[];
13933
13937
  details?: any;
13934
- isError: true;
13938
+ isError: false;
13935
13939
  };
13936
- status: "error";
13940
+ status: "completed";
13937
13941
  thoughtSignature?: string;
13938
13942
  time: {
13939
13943
  start: number;
@@ -13959,7 +13963,7 @@ declare const Definitions: readonly [Schema.Struct<{
13959
13963
  details?: any;
13960
13964
  isError: true;
13961
13965
  };
13962
- status: "skipped";
13966
+ status: "error";
13963
13967
  thoughtSignature?: string;
13964
13968
  time: {
13965
13969
  start: number;
@@ -13985,26 +13989,21 @@ declare const Definitions: readonly [Schema.Struct<{
13985
13989
  details?: any;
13986
13990
  isError: true;
13987
13991
  };
13988
- status: "aborted";
13992
+ status: "skipped";
13989
13993
  thoughtSignature?: string;
13990
13994
  time: {
13991
13995
  start: number;
13992
13996
  end: number;
13993
13997
  };
13994
13998
  type: "toolCall";
13995
- } | {
13996
- type: "thinking";
13997
- thinking: string;
13998
- thinkingSignature?: string;
13999
- redacted?: boolean;
14000
13999
  } | {
14001
14000
  addedToolNames?: string[];
14002
14001
  arguments: Record<string, any>;
14003
14002
  callID: string;
14004
14003
  name: string;
14005
14004
  namespace?: string;
14006
- partial?: {
14007
- content?: ({
14005
+ result: {
14006
+ content: ({
14008
14007
  type: "text";
14009
14008
  text: string;
14010
14009
  textSignature?: string;
@@ -14014,8 +14013,9 @@ declare const Definitions: readonly [Schema.Struct<{
14014
14013
  mimeType: string;
14015
14014
  })[];
14016
14015
  details?: any;
14016
+ isError: true;
14017
14017
  };
14018
- status: "running";
14018
+ status: "aborted";
14019
14019
  thoughtSignature?: string;
14020
14020
  time: {
14021
14021
  start: number;
@@ -14190,14 +14190,19 @@ declare const Definitions: readonly [Schema.Struct<{
14190
14190
  type: "image";
14191
14191
  data: string;
14192
14192
  mimeType: string;
14193
+ } | {
14194
+ type: "thinking";
14195
+ thinking: string;
14196
+ thinkingSignature?: string;
14197
+ redacted?: boolean;
14193
14198
  } | {
14194
14199
  addedToolNames?: string[];
14195
14200
  arguments: Record<string, any>;
14196
14201
  callID: string;
14197
14202
  name: string;
14198
14203
  namespace?: string;
14199
- result: {
14200
- content: ({
14204
+ partial?: {
14205
+ content?: ({
14201
14206
  type: "text";
14202
14207
  text: string;
14203
14208
  textSignature?: string;
@@ -14207,9 +14212,8 @@ declare const Definitions: readonly [Schema.Struct<{
14207
14212
  mimeType: string;
14208
14213
  })[];
14209
14214
  details?: any;
14210
- isError: false;
14211
14215
  };
14212
- status: "completed";
14216
+ status: "running";
14213
14217
  thoughtSignature?: string;
14214
14218
  time: {
14215
14219
  start: number;
@@ -14233,9 +14237,9 @@ declare const Definitions: readonly [Schema.Struct<{
14233
14237
  mimeType: string;
14234
14238
  })[];
14235
14239
  details?: any;
14236
- isError: true;
14240
+ isError: false;
14237
14241
  };
14238
- status: "error";
14242
+ status: "completed";
14239
14243
  thoughtSignature?: string;
14240
14244
  time: {
14241
14245
  start: number;
@@ -14261,7 +14265,7 @@ declare const Definitions: readonly [Schema.Struct<{
14261
14265
  details?: any;
14262
14266
  isError: true;
14263
14267
  };
14264
- status: "skipped";
14268
+ status: "error";
14265
14269
  thoughtSignature?: string;
14266
14270
  time: {
14267
14271
  start: number;
@@ -14287,26 +14291,21 @@ declare const Definitions: readonly [Schema.Struct<{
14287
14291
  details?: any;
14288
14292
  isError: true;
14289
14293
  };
14290
- status: "aborted";
14294
+ status: "skipped";
14291
14295
  thoughtSignature?: string;
14292
14296
  time: {
14293
14297
  start: number;
14294
14298
  end: number;
14295
14299
  };
14296
14300
  type: "toolCall";
14297
- } | {
14298
- type: "thinking";
14299
- thinking: string;
14300
- thinkingSignature?: string;
14301
- redacted?: boolean;
14302
14301
  } | {
14303
14302
  addedToolNames?: string[];
14304
14303
  arguments: Record<string, any>;
14305
14304
  callID: string;
14306
14305
  name: string;
14307
14306
  namespace?: string;
14308
- partial?: {
14309
- content?: ({
14307
+ result: {
14308
+ content: ({
14310
14309
  type: "text";
14311
14310
  text: string;
14312
14311
  textSignature?: string;
@@ -14316,8 +14315,9 @@ declare const Definitions: readonly [Schema.Struct<{
14316
14315
  mimeType: string;
14317
14316
  })[];
14318
14317
  details?: any;
14318
+ isError: true;
14319
14319
  };
14320
- status: "running";
14320
+ status: "aborted";
14321
14321
  thoughtSignature?: string;
14322
14322
  time: {
14323
14323
  start: number;
@@ -15826,14 +15826,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15826
15826
  type: "image";
15827
15827
  data: string;
15828
15828
  mimeType: string;
15829
+ } | {
15830
+ type: "thinking";
15831
+ thinking: string;
15832
+ thinkingSignature?: string;
15833
+ redacted?: boolean;
15829
15834
  } | {
15830
15835
  addedToolNames?: string[];
15831
15836
  arguments: Record<string, any>;
15832
15837
  callID: string;
15833
15838
  name: string;
15834
15839
  namespace?: string;
15835
- result: {
15836
- content: ({
15840
+ partial?: {
15841
+ content?: ({
15837
15842
  type: "text";
15838
15843
  text: string;
15839
15844
  textSignature?: string;
@@ -15843,9 +15848,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15843
15848
  mimeType: string;
15844
15849
  })[];
15845
15850
  details?: any;
15846
- isError: false;
15847
15851
  };
15848
- status: "completed";
15852
+ status: "running";
15849
15853
  thoughtSignature?: string;
15850
15854
  time: {
15851
15855
  start: number;
@@ -15869,9 +15873,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15869
15873
  mimeType: string;
15870
15874
  })[];
15871
15875
  details?: any;
15872
- isError: true;
15876
+ isError: false;
15873
15877
  };
15874
- status: "error";
15878
+ status: "completed";
15875
15879
  thoughtSignature?: string;
15876
15880
  time: {
15877
15881
  start: number;
@@ -15897,7 +15901,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15897
15901
  details?: any;
15898
15902
  isError: true;
15899
15903
  };
15900
- status: "skipped";
15904
+ status: "error";
15901
15905
  thoughtSignature?: string;
15902
15906
  time: {
15903
15907
  start: number;
@@ -15923,26 +15927,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15923
15927
  details?: any;
15924
15928
  isError: true;
15925
15929
  };
15926
- status: "aborted";
15930
+ status: "skipped";
15927
15931
  thoughtSignature?: string;
15928
15932
  time: {
15929
15933
  start: number;
15930
15934
  end: number;
15931
15935
  };
15932
15936
  type: "toolCall";
15933
- } | {
15934
- type: "thinking";
15935
- thinking: string;
15936
- thinkingSignature?: string;
15937
- redacted?: boolean;
15938
15937
  } | {
15939
15938
  addedToolNames?: string[];
15940
15939
  arguments: Record<string, any>;
15941
15940
  callID: string;
15942
15941
  name: string;
15943
15942
  namespace?: string;
15944
- partial?: {
15945
- content?: ({
15943
+ result: {
15944
+ content: ({
15946
15945
  type: "text";
15947
15946
  text: string;
15948
15947
  textSignature?: string;
@@ -15952,8 +15951,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15952
15951
  mimeType: string;
15953
15952
  })[];
15954
15953
  details?: any;
15954
+ isError: true;
15955
15955
  };
15956
- status: "running";
15956
+ status: "aborted";
15957
15957
  thoughtSignature?: string;
15958
15958
  time: {
15959
15959
  start: number;
@@ -16128,14 +16128,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16128
16128
  type: "image";
16129
16129
  data: string;
16130
16130
  mimeType: string;
16131
+ } | {
16132
+ type: "thinking";
16133
+ thinking: string;
16134
+ thinkingSignature?: string;
16135
+ redacted?: boolean;
16131
16136
  } | {
16132
16137
  addedToolNames?: string[];
16133
16138
  arguments: Record<string, any>;
16134
16139
  callID: string;
16135
16140
  name: string;
16136
16141
  namespace?: string;
16137
- result: {
16138
- content: ({
16142
+ partial?: {
16143
+ content?: ({
16139
16144
  type: "text";
16140
16145
  text: string;
16141
16146
  textSignature?: string;
@@ -16145,9 +16150,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16145
16150
  mimeType: string;
16146
16151
  })[];
16147
16152
  details?: any;
16148
- isError: false;
16149
16153
  };
16150
- status: "completed";
16154
+ status: "running";
16151
16155
  thoughtSignature?: string;
16152
16156
  time: {
16153
16157
  start: number;
@@ -16171,9 +16175,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16171
16175
  mimeType: string;
16172
16176
  })[];
16173
16177
  details?: any;
16174
- isError: true;
16178
+ isError: false;
16175
16179
  };
16176
- status: "error";
16180
+ status: "completed";
16177
16181
  thoughtSignature?: string;
16178
16182
  time: {
16179
16183
  start: number;
@@ -16199,7 +16203,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16199
16203
  details?: any;
16200
16204
  isError: true;
16201
16205
  };
16202
- status: "skipped";
16206
+ status: "error";
16203
16207
  thoughtSignature?: string;
16204
16208
  time: {
16205
16209
  start: number;
@@ -16225,26 +16229,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16225
16229
  details?: any;
16226
16230
  isError: true;
16227
16231
  };
16228
- status: "aborted";
16232
+ status: "skipped";
16229
16233
  thoughtSignature?: string;
16230
16234
  time: {
16231
16235
  start: number;
16232
16236
  end: number;
16233
16237
  };
16234
16238
  type: "toolCall";
16235
- } | {
16236
- type: "thinking";
16237
- thinking: string;
16238
- thinkingSignature?: string;
16239
- redacted?: boolean;
16240
16239
  } | {
16241
16240
  addedToolNames?: string[];
16242
16241
  arguments: Record<string, any>;
16243
16242
  callID: string;
16244
16243
  name: string;
16245
16244
  namespace?: string;
16246
- partial?: {
16247
- content?: ({
16245
+ result: {
16246
+ content: ({
16248
16247
  type: "text";
16249
16248
  text: string;
16250
16249
  textSignature?: string;
@@ -16254,8 +16253,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16254
16253
  mimeType: string;
16255
16254
  })[];
16256
16255
  details?: any;
16256
+ isError: true;
16257
16257
  };
16258
- status: "running";
16258
+ status: "aborted";
16259
16259
  thoughtSignature?: string;
16260
16260
  time: {
16261
16261
  start: number;
@@ -16448,14 +16448,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16448
16448
  type: "image";
16449
16449
  data: string;
16450
16450
  mimeType: string;
16451
+ } | {
16452
+ type: "thinking";
16453
+ thinking: string;
16454
+ thinkingSignature?: string;
16455
+ redacted?: boolean;
16451
16456
  } | {
16452
16457
  addedToolNames?: string[];
16453
16458
  arguments: Record<string, any>;
16454
16459
  callID: string;
16455
16460
  name: string;
16456
16461
  namespace?: string;
16457
- result: {
16458
- content: ({
16462
+ partial?: {
16463
+ content?: ({
16459
16464
  type: "text";
16460
16465
  text: string;
16461
16466
  textSignature?: string;
@@ -16465,9 +16470,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16465
16470
  mimeType: string;
16466
16471
  })[];
16467
16472
  details?: any;
16468
- isError: false;
16469
16473
  };
16470
- status: "completed";
16474
+ status: "running";
16471
16475
  thoughtSignature?: string;
16472
16476
  time: {
16473
16477
  start: number;
@@ -16491,9 +16495,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16491
16495
  mimeType: string;
16492
16496
  })[];
16493
16497
  details?: any;
16494
- isError: true;
16498
+ isError: false;
16495
16499
  };
16496
- status: "error";
16500
+ status: "completed";
16497
16501
  thoughtSignature?: string;
16498
16502
  time: {
16499
16503
  start: number;
@@ -16519,7 +16523,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16519
16523
  details?: any;
16520
16524
  isError: true;
16521
16525
  };
16522
- status: "skipped";
16526
+ status: "error";
16523
16527
  thoughtSignature?: string;
16524
16528
  time: {
16525
16529
  start: number;
@@ -16545,26 +16549,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16545
16549
  details?: any;
16546
16550
  isError: true;
16547
16551
  };
16548
- status: "aborted";
16552
+ status: "skipped";
16549
16553
  thoughtSignature?: string;
16550
16554
  time: {
16551
16555
  start: number;
16552
16556
  end: number;
16553
16557
  };
16554
16558
  type: "toolCall";
16555
- } | {
16556
- type: "thinking";
16557
- thinking: string;
16558
- thinkingSignature?: string;
16559
- redacted?: boolean;
16560
16559
  } | {
16561
16560
  addedToolNames?: string[];
16562
16561
  arguments: Record<string, any>;
16563
16562
  callID: string;
16564
16563
  name: string;
16565
16564
  namespace?: string;
16566
- partial?: {
16567
- content?: ({
16565
+ result: {
16566
+ content: ({
16568
16567
  type: "text";
16569
16568
  text: string;
16570
16569
  textSignature?: string;
@@ -16574,8 +16573,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16574
16573
  mimeType: string;
16575
16574
  })[];
16576
16575
  details?: any;
16576
+ isError: true;
16577
16577
  };
16578
- status: "running";
16578
+ status: "aborted";
16579
16579
  thoughtSignature?: string;
16580
16580
  time: {
16581
16581
  start: number;
@@ -16750,14 +16750,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16750
16750
  type: "image";
16751
16751
  data: string;
16752
16752
  mimeType: string;
16753
+ } | {
16754
+ type: "thinking";
16755
+ thinking: string;
16756
+ thinkingSignature?: string;
16757
+ redacted?: boolean;
16753
16758
  } | {
16754
16759
  addedToolNames?: string[];
16755
16760
  arguments: Record<string, any>;
16756
16761
  callID: string;
16757
16762
  name: string;
16758
16763
  namespace?: string;
16759
- result: {
16760
- content: ({
16764
+ partial?: {
16765
+ content?: ({
16761
16766
  type: "text";
16762
16767
  text: string;
16763
16768
  textSignature?: string;
@@ -16767,9 +16772,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16767
16772
  mimeType: string;
16768
16773
  })[];
16769
16774
  details?: any;
16770
- isError: false;
16771
16775
  };
16772
- status: "completed";
16776
+ status: "running";
16773
16777
  thoughtSignature?: string;
16774
16778
  time: {
16775
16779
  start: number;
@@ -16793,9 +16797,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16793
16797
  mimeType: string;
16794
16798
  })[];
16795
16799
  details?: any;
16796
- isError: true;
16800
+ isError: false;
16797
16801
  };
16798
- status: "error";
16802
+ status: "completed";
16799
16803
  thoughtSignature?: string;
16800
16804
  time: {
16801
16805
  start: number;
@@ -16821,7 +16825,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16821
16825
  details?: any;
16822
16826
  isError: true;
16823
16827
  };
16824
- status: "skipped";
16828
+ status: "error";
16825
16829
  thoughtSignature?: string;
16826
16830
  time: {
16827
16831
  start: number;
@@ -16847,26 +16851,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16847
16851
  details?: any;
16848
16852
  isError: true;
16849
16853
  };
16850
- status: "aborted";
16854
+ status: "skipped";
16851
16855
  thoughtSignature?: string;
16852
16856
  time: {
16853
16857
  start: number;
16854
16858
  end: number;
16855
16859
  };
16856
16860
  type: "toolCall";
16857
- } | {
16858
- type: "thinking";
16859
- thinking: string;
16860
- thinkingSignature?: string;
16861
- redacted?: boolean;
16862
16861
  } | {
16863
16862
  addedToolNames?: string[];
16864
16863
  arguments: Record<string, any>;
16865
16864
  callID: string;
16866
16865
  name: string;
16867
16866
  namespace?: string;
16868
- partial?: {
16869
- content?: ({
16867
+ result: {
16868
+ content: ({
16870
16869
  type: "text";
16871
16870
  text: string;
16872
16871
  textSignature?: string;
@@ -16876,8 +16875,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16876
16875
  mimeType: string;
16877
16876
  })[];
16878
16877
  details?: any;
16878
+ isError: true;
16879
16879
  };
16880
- status: "running";
16880
+ status: "aborted";
16881
16881
  thoughtSignature?: string;
16882
16882
  time: {
16883
16883
  start: number;
@@ -17358,14 +17358,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17358
17358
  type: "image";
17359
17359
  data: string;
17360
17360
  mimeType: string;
17361
+ } | {
17362
+ type: "thinking";
17363
+ thinking: string;
17364
+ thinkingSignature?: string;
17365
+ redacted?: boolean;
17361
17366
  } | {
17362
17367
  addedToolNames?: string[];
17363
17368
  arguments: Record<string, any>;
17364
17369
  callID: string;
17365
17370
  name: string;
17366
17371
  namespace?: string;
17367
- result: {
17368
- content: ({
17372
+ partial?: {
17373
+ content?: ({
17369
17374
  type: "text";
17370
17375
  text: string;
17371
17376
  textSignature?: string;
@@ -17375,9 +17380,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17375
17380
  mimeType: string;
17376
17381
  })[];
17377
17382
  details?: any;
17378
- isError: false;
17379
17383
  };
17380
- status: "completed";
17384
+ status: "running";
17381
17385
  thoughtSignature?: string;
17382
17386
  time: {
17383
17387
  start: number;
@@ -17401,9 +17405,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17401
17405
  mimeType: string;
17402
17406
  })[];
17403
17407
  details?: any;
17404
- isError: true;
17408
+ isError: false;
17405
17409
  };
17406
- status: "error";
17410
+ status: "completed";
17407
17411
  thoughtSignature?: string;
17408
17412
  time: {
17409
17413
  start: number;
@@ -17429,7 +17433,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17429
17433
  details?: any;
17430
17434
  isError: true;
17431
17435
  };
17432
- status: "skipped";
17436
+ status: "error";
17433
17437
  thoughtSignature?: string;
17434
17438
  time: {
17435
17439
  start: number;
@@ -17455,26 +17459,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17455
17459
  details?: any;
17456
17460
  isError: true;
17457
17461
  };
17458
- status: "aborted";
17462
+ status: "skipped";
17459
17463
  thoughtSignature?: string;
17460
17464
  time: {
17461
17465
  start: number;
17462
17466
  end: number;
17463
17467
  };
17464
17468
  type: "toolCall";
17465
- } | {
17466
- type: "thinking";
17467
- thinking: string;
17468
- thinkingSignature?: string;
17469
- redacted?: boolean;
17470
17469
  } | {
17471
17470
  addedToolNames?: string[];
17472
17471
  arguments: Record<string, any>;
17473
17472
  callID: string;
17474
17473
  name: string;
17475
17474
  namespace?: string;
17476
- partial?: {
17477
- content?: ({
17475
+ result: {
17476
+ content: ({
17478
17477
  type: "text";
17479
17478
  text: string;
17480
17479
  textSignature?: string;
@@ -17484,8 +17483,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17484
17483
  mimeType: string;
17485
17484
  })[];
17486
17485
  details?: any;
17486
+ isError: true;
17487
17487
  };
17488
- status: "running";
17488
+ status: "aborted";
17489
17489
  thoughtSignature?: string;
17490
17490
  time: {
17491
17491
  start: number;
@@ -17660,14 +17660,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17660
17660
  type: "image";
17661
17661
  data: string;
17662
17662
  mimeType: string;
17663
+ } | {
17664
+ type: "thinking";
17665
+ thinking: string;
17666
+ thinkingSignature?: string;
17667
+ redacted?: boolean;
17663
17668
  } | {
17664
17669
  addedToolNames?: string[];
17665
17670
  arguments: Record<string, any>;
17666
17671
  callID: string;
17667
17672
  name: string;
17668
17673
  namespace?: string;
17669
- result: {
17670
- content: ({
17674
+ partial?: {
17675
+ content?: ({
17671
17676
  type: "text";
17672
17677
  text: string;
17673
17678
  textSignature?: string;
@@ -17677,9 +17682,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17677
17682
  mimeType: string;
17678
17683
  })[];
17679
17684
  details?: any;
17680
- isError: false;
17681
17685
  };
17682
- status: "completed";
17686
+ status: "running";
17683
17687
  thoughtSignature?: string;
17684
17688
  time: {
17685
17689
  start: number;
@@ -17703,9 +17707,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17703
17707
  mimeType: string;
17704
17708
  })[];
17705
17709
  details?: any;
17706
- isError: true;
17710
+ isError: false;
17707
17711
  };
17708
- status: "error";
17712
+ status: "completed";
17709
17713
  thoughtSignature?: string;
17710
17714
  time: {
17711
17715
  start: number;
@@ -17731,7 +17735,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17731
17735
  details?: any;
17732
17736
  isError: true;
17733
17737
  };
17734
- status: "skipped";
17738
+ status: "error";
17735
17739
  thoughtSignature?: string;
17736
17740
  time: {
17737
17741
  start: number;
@@ -17757,26 +17761,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17757
17761
  details?: any;
17758
17762
  isError: true;
17759
17763
  };
17760
- status: "aborted";
17764
+ status: "skipped";
17761
17765
  thoughtSignature?: string;
17762
17766
  time: {
17763
17767
  start: number;
17764
17768
  end: number;
17765
17769
  };
17766
17770
  type: "toolCall";
17767
- } | {
17768
- type: "thinking";
17769
- thinking: string;
17770
- thinkingSignature?: string;
17771
- redacted?: boolean;
17772
17771
  } | {
17773
17772
  addedToolNames?: string[];
17774
17773
  arguments: Record<string, any>;
17775
17774
  callID: string;
17776
17775
  name: string;
17777
17776
  namespace?: string;
17778
- partial?: {
17779
- content?: ({
17777
+ result: {
17778
+ content: ({
17780
17779
  type: "text";
17781
17780
  text: string;
17782
17781
  textSignature?: string;
@@ -17786,8 +17785,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17786
17785
  mimeType: string;
17787
17786
  })[];
17788
17787
  details?: any;
17788
+ isError: true;
17789
17789
  };
17790
- status: "running";
17790
+ status: "aborted";
17791
17791
  thoughtSignature?: string;
17792
17792
  time: {
17793
17793
  start: number;
@@ -17981,14 +17981,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17981
17981
  type: "image";
17982
17982
  data: string;
17983
17983
  mimeType: string;
17984
+ } | {
17985
+ type: "thinking";
17986
+ thinking: string;
17987
+ thinkingSignature?: string;
17988
+ redacted?: boolean;
17984
17989
  } | {
17985
17990
  addedToolNames?: string[];
17986
17991
  arguments: Record<string, any>;
17987
17992
  callID: string;
17988
17993
  name: string;
17989
17994
  namespace?: string;
17990
- result: {
17991
- content: ({
17995
+ partial?: {
17996
+ content?: ({
17992
17997
  type: "text";
17993
17998
  text: string;
17994
17999
  textSignature?: string;
@@ -17998,9 +18003,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17998
18003
  mimeType: string;
17999
18004
  })[];
18000
18005
  details?: any;
18001
- isError: false;
18002
18006
  };
18003
- status: "completed";
18007
+ status: "running";
18004
18008
  thoughtSignature?: string;
18005
18009
  time: {
18006
18010
  start: number;
@@ -18024,9 +18028,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18024
18028
  mimeType: string;
18025
18029
  })[];
18026
18030
  details?: any;
18027
- isError: true;
18031
+ isError: false;
18028
18032
  };
18029
- status: "error";
18033
+ status: "completed";
18030
18034
  thoughtSignature?: string;
18031
18035
  time: {
18032
18036
  start: number;
@@ -18052,7 +18056,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18052
18056
  details?: any;
18053
18057
  isError: true;
18054
18058
  };
18055
- status: "skipped";
18059
+ status: "error";
18056
18060
  thoughtSignature?: string;
18057
18061
  time: {
18058
18062
  start: number;
@@ -18078,26 +18082,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18078
18082
  details?: any;
18079
18083
  isError: true;
18080
18084
  };
18081
- status: "aborted";
18085
+ status: "skipped";
18082
18086
  thoughtSignature?: string;
18083
18087
  time: {
18084
18088
  start: number;
18085
18089
  end: number;
18086
18090
  };
18087
18091
  type: "toolCall";
18088
- } | {
18089
- type: "thinking";
18090
- thinking: string;
18091
- thinkingSignature?: string;
18092
- redacted?: boolean;
18093
18092
  } | {
18094
18093
  addedToolNames?: string[];
18095
18094
  arguments: Record<string, any>;
18096
18095
  callID: string;
18097
18096
  name: string;
18098
18097
  namespace?: string;
18099
- partial?: {
18100
- content?: ({
18098
+ result: {
18099
+ content: ({
18101
18100
  type: "text";
18102
18101
  text: string;
18103
18102
  textSignature?: string;
@@ -18107,8 +18106,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18107
18106
  mimeType: string;
18108
18107
  })[];
18109
18108
  details?: any;
18109
+ isError: true;
18110
18110
  };
18111
- status: "running";
18111
+ status: "aborted";
18112
18112
  thoughtSignature?: string;
18113
18113
  time: {
18114
18114
  start: number;
@@ -18283,14 +18283,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18283
18283
  type: "image";
18284
18284
  data: string;
18285
18285
  mimeType: string;
18286
+ } | {
18287
+ type: "thinking";
18288
+ thinking: string;
18289
+ thinkingSignature?: string;
18290
+ redacted?: boolean;
18286
18291
  } | {
18287
18292
  addedToolNames?: string[];
18288
18293
  arguments: Record<string, any>;
18289
18294
  callID: string;
18290
18295
  name: string;
18291
18296
  namespace?: string;
18292
- result: {
18293
- content: ({
18297
+ partial?: {
18298
+ content?: ({
18294
18299
  type: "text";
18295
18300
  text: string;
18296
18301
  textSignature?: string;
@@ -18300,9 +18305,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18300
18305
  mimeType: string;
18301
18306
  })[];
18302
18307
  details?: any;
18303
- isError: false;
18304
18308
  };
18305
- status: "completed";
18309
+ status: "running";
18306
18310
  thoughtSignature?: string;
18307
18311
  time: {
18308
18312
  start: number;
@@ -18326,9 +18330,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18326
18330
  mimeType: string;
18327
18331
  })[];
18328
18332
  details?: any;
18329
- isError: true;
18333
+ isError: false;
18330
18334
  };
18331
- status: "error";
18335
+ status: "completed";
18332
18336
  thoughtSignature?: string;
18333
18337
  time: {
18334
18338
  start: number;
@@ -18354,7 +18358,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18354
18358
  details?: any;
18355
18359
  isError: true;
18356
18360
  };
18357
- status: "skipped";
18361
+ status: "error";
18358
18362
  thoughtSignature?: string;
18359
18363
  time: {
18360
18364
  start: number;
@@ -18380,26 +18384,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18380
18384
  details?: any;
18381
18385
  isError: true;
18382
18386
  };
18383
- status: "aborted";
18387
+ status: "skipped";
18384
18388
  thoughtSignature?: string;
18385
18389
  time: {
18386
18390
  start: number;
18387
18391
  end: number;
18388
18392
  };
18389
18393
  type: "toolCall";
18390
- } | {
18391
- type: "thinking";
18392
- thinking: string;
18393
- thinkingSignature?: string;
18394
- redacted?: boolean;
18395
18394
  } | {
18396
18395
  addedToolNames?: string[];
18397
18396
  arguments: Record<string, any>;
18398
18397
  callID: string;
18399
18398
  name: string;
18400
18399
  namespace?: string;
18401
- partial?: {
18402
- content?: ({
18400
+ result: {
18401
+ content: ({
18403
18402
  type: "text";
18404
18403
  text: string;
18405
18404
  textSignature?: string;
@@ -18409,8 +18408,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18409
18408
  mimeType: string;
18410
18409
  })[];
18411
18410
  details?: any;
18411
+ isError: true;
18412
18412
  };
18413
- status: "running";
18413
+ status: "aborted";
18414
18414
  thoughtSignature?: string;
18415
18415
  time: {
18416
18416
  start: number;
@@ -18613,14 +18613,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18613
18613
  type: "image";
18614
18614
  data: string;
18615
18615
  mimeType: string;
18616
+ } | {
18617
+ type: "thinking";
18618
+ thinking: string;
18619
+ thinkingSignature?: string;
18620
+ redacted?: boolean;
18616
18621
  } | {
18617
18622
  addedToolNames?: string[];
18618
18623
  arguments: Record<string, any>;
18619
18624
  callID: string;
18620
18625
  name: string;
18621
18626
  namespace?: string;
18622
- result: {
18623
- content: ({
18627
+ partial?: {
18628
+ content?: ({
18624
18629
  type: "text";
18625
18630
  text: string;
18626
18631
  textSignature?: string;
@@ -18630,9 +18635,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18630
18635
  mimeType: string;
18631
18636
  })[];
18632
18637
  details?: any;
18633
- isError: false;
18634
18638
  };
18635
- status: "completed";
18639
+ status: "running";
18636
18640
  thoughtSignature?: string;
18637
18641
  time: {
18638
18642
  start: number;
@@ -18656,9 +18660,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18656
18660
  mimeType: string;
18657
18661
  })[];
18658
18662
  details?: any;
18659
- isError: true;
18663
+ isError: false;
18660
18664
  };
18661
- status: "error";
18665
+ status: "completed";
18662
18666
  thoughtSignature?: string;
18663
18667
  time: {
18664
18668
  start: number;
@@ -18684,7 +18688,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18684
18688
  details?: any;
18685
18689
  isError: true;
18686
18690
  };
18687
- status: "skipped";
18691
+ status: "error";
18688
18692
  thoughtSignature?: string;
18689
18693
  time: {
18690
18694
  start: number;
@@ -18710,26 +18714,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18710
18714
  details?: any;
18711
18715
  isError: true;
18712
18716
  };
18713
- status: "aborted";
18717
+ status: "skipped";
18714
18718
  thoughtSignature?: string;
18715
18719
  time: {
18716
18720
  start: number;
18717
18721
  end: number;
18718
18722
  };
18719
18723
  type: "toolCall";
18720
- } | {
18721
- type: "thinking";
18722
- thinking: string;
18723
- thinkingSignature?: string;
18724
- redacted?: boolean;
18725
18724
  } | {
18726
18725
  addedToolNames?: string[];
18727
18726
  arguments: Record<string, any>;
18728
18727
  callID: string;
18729
18728
  name: string;
18730
18729
  namespace?: string;
18731
- partial?: {
18732
- content?: ({
18730
+ result: {
18731
+ content: ({
18733
18732
  type: "text";
18734
18733
  text: string;
18735
18734
  textSignature?: string;
@@ -18739,8 +18738,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18739
18738
  mimeType: string;
18740
18739
  })[];
18741
18740
  details?: any;
18741
+ isError: true;
18742
18742
  };
18743
- status: "running";
18743
+ status: "aborted";
18744
18744
  thoughtSignature?: string;
18745
18745
  time: {
18746
18746
  start: number;
@@ -18915,14 +18915,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18915
18915
  type: "image";
18916
18916
  data: string;
18917
18917
  mimeType: string;
18918
+ } | {
18919
+ type: "thinking";
18920
+ thinking: string;
18921
+ thinkingSignature?: string;
18922
+ redacted?: boolean;
18918
18923
  } | {
18919
18924
  addedToolNames?: string[];
18920
18925
  arguments: Record<string, any>;
18921
18926
  callID: string;
18922
18927
  name: string;
18923
18928
  namespace?: string;
18924
- result: {
18925
- content: ({
18929
+ partial?: {
18930
+ content?: ({
18926
18931
  type: "text";
18927
18932
  text: string;
18928
18933
  textSignature?: string;
@@ -18932,9 +18937,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18932
18937
  mimeType: string;
18933
18938
  })[];
18934
18939
  details?: any;
18935
- isError: false;
18936
18940
  };
18937
- status: "completed";
18941
+ status: "running";
18938
18942
  thoughtSignature?: string;
18939
18943
  time: {
18940
18944
  start: number;
@@ -18958,9 +18962,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18958
18962
  mimeType: string;
18959
18963
  })[];
18960
18964
  details?: any;
18961
- isError: true;
18965
+ isError: false;
18962
18966
  };
18963
- status: "error";
18967
+ status: "completed";
18964
18968
  thoughtSignature?: string;
18965
18969
  time: {
18966
18970
  start: number;
@@ -18986,7 +18990,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18986
18990
  details?: any;
18987
18991
  isError: true;
18988
18992
  };
18989
- status: "skipped";
18993
+ status: "error";
18990
18994
  thoughtSignature?: string;
18991
18995
  time: {
18992
18996
  start: number;
@@ -19012,26 +19016,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19012
19016
  details?: any;
19013
19017
  isError: true;
19014
19018
  };
19015
- status: "aborted";
19019
+ status: "skipped";
19016
19020
  thoughtSignature?: string;
19017
19021
  time: {
19018
19022
  start: number;
19019
19023
  end: number;
19020
19024
  };
19021
19025
  type: "toolCall";
19022
- } | {
19023
- type: "thinking";
19024
- thinking: string;
19025
- thinkingSignature?: string;
19026
- redacted?: boolean;
19027
19026
  } | {
19028
19027
  addedToolNames?: string[];
19029
19028
  arguments: Record<string, any>;
19030
19029
  callID: string;
19031
19030
  name: string;
19032
19031
  namespace?: string;
19033
- partial?: {
19034
- content?: ({
19032
+ result: {
19033
+ content: ({
19035
19034
  type: "text";
19036
19035
  text: string;
19037
19036
  textSignature?: string;
@@ -19041,8 +19040,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19041
19040
  mimeType: string;
19042
19041
  })[];
19043
19042
  details?: any;
19043
+ isError: true;
19044
19044
  };
19045
- status: "running";
19045
+ status: "aborted";
19046
19046
  thoughtSignature?: string;
19047
19047
  time: {
19048
19048
  start: number;
@@ -19236,14 +19236,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19236
19236
  type: "image";
19237
19237
  data: string;
19238
19238
  mimeType: string;
19239
+ } | {
19240
+ type: "thinking";
19241
+ thinking: string;
19242
+ thinkingSignature?: string;
19243
+ redacted?: boolean;
19239
19244
  } | {
19240
19245
  addedToolNames?: string[];
19241
19246
  arguments: Record<string, any>;
19242
19247
  callID: string;
19243
19248
  name: string;
19244
19249
  namespace?: string;
19245
- result: {
19246
- content: ({
19250
+ partial?: {
19251
+ content?: ({
19247
19252
  type: "text";
19248
19253
  text: string;
19249
19254
  textSignature?: string;
@@ -19253,9 +19258,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19253
19258
  mimeType: string;
19254
19259
  })[];
19255
19260
  details?: any;
19256
- isError: false;
19257
19261
  };
19258
- status: "completed";
19262
+ status: "running";
19259
19263
  thoughtSignature?: string;
19260
19264
  time: {
19261
19265
  start: number;
@@ -19279,9 +19283,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19279
19283
  mimeType: string;
19280
19284
  })[];
19281
19285
  details?: any;
19282
- isError: true;
19286
+ isError: false;
19283
19287
  };
19284
- status: "error";
19288
+ status: "completed";
19285
19289
  thoughtSignature?: string;
19286
19290
  time: {
19287
19291
  start: number;
@@ -19307,7 +19311,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19307
19311
  details?: any;
19308
19312
  isError: true;
19309
19313
  };
19310
- status: "skipped";
19314
+ status: "error";
19311
19315
  thoughtSignature?: string;
19312
19316
  time: {
19313
19317
  start: number;
@@ -19333,26 +19337,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19333
19337
  details?: any;
19334
19338
  isError: true;
19335
19339
  };
19336
- status: "aborted";
19340
+ status: "skipped";
19337
19341
  thoughtSignature?: string;
19338
19342
  time: {
19339
19343
  start: number;
19340
19344
  end: number;
19341
19345
  };
19342
19346
  type: "toolCall";
19343
- } | {
19344
- type: "thinking";
19345
- thinking: string;
19346
- thinkingSignature?: string;
19347
- redacted?: boolean;
19348
19347
  } | {
19349
19348
  addedToolNames?: string[];
19350
19349
  arguments: Record<string, any>;
19351
19350
  callID: string;
19352
19351
  name: string;
19353
19352
  namespace?: string;
19354
- partial?: {
19355
- content?: ({
19353
+ result: {
19354
+ content: ({
19356
19355
  type: "text";
19357
19356
  text: string;
19358
19357
  textSignature?: string;
@@ -19362,8 +19361,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19362
19361
  mimeType: string;
19363
19362
  })[];
19364
19363
  details?: any;
19364
+ isError: true;
19365
19365
  };
19366
- status: "running";
19366
+ status: "aborted";
19367
19367
  thoughtSignature?: string;
19368
19368
  time: {
19369
19369
  start: number;
@@ -19538,14 +19538,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19538
19538
  type: "image";
19539
19539
  data: string;
19540
19540
  mimeType: string;
19541
+ } | {
19542
+ type: "thinking";
19543
+ thinking: string;
19544
+ thinkingSignature?: string;
19545
+ redacted?: boolean;
19541
19546
  } | {
19542
19547
  addedToolNames?: string[];
19543
19548
  arguments: Record<string, any>;
19544
19549
  callID: string;
19545
19550
  name: string;
19546
19551
  namespace?: string;
19547
- result: {
19548
- content: ({
19552
+ partial?: {
19553
+ content?: ({
19549
19554
  type: "text";
19550
19555
  text: string;
19551
19556
  textSignature?: string;
@@ -19555,9 +19560,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19555
19560
  mimeType: string;
19556
19561
  })[];
19557
19562
  details?: any;
19558
- isError: false;
19559
19563
  };
19560
- status: "completed";
19564
+ status: "running";
19561
19565
  thoughtSignature?: string;
19562
19566
  time: {
19563
19567
  start: number;
@@ -19581,9 +19585,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19581
19585
  mimeType: string;
19582
19586
  })[];
19583
19587
  details?: any;
19584
- isError: true;
19588
+ isError: false;
19585
19589
  };
19586
- status: "error";
19590
+ status: "completed";
19587
19591
  thoughtSignature?: string;
19588
19592
  time: {
19589
19593
  start: number;
@@ -19609,7 +19613,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19609
19613
  details?: any;
19610
19614
  isError: true;
19611
19615
  };
19612
- status: "skipped";
19616
+ status: "error";
19613
19617
  thoughtSignature?: string;
19614
19618
  time: {
19615
19619
  start: number;
@@ -19635,26 +19639,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19635
19639
  details?: any;
19636
19640
  isError: true;
19637
19641
  };
19638
- status: "aborted";
19642
+ status: "skipped";
19639
19643
  thoughtSignature?: string;
19640
19644
  time: {
19641
19645
  start: number;
19642
19646
  end: number;
19643
19647
  };
19644
19648
  type: "toolCall";
19645
- } | {
19646
- type: "thinking";
19647
- thinking: string;
19648
- thinkingSignature?: string;
19649
- redacted?: boolean;
19650
19649
  } | {
19651
19650
  addedToolNames?: string[];
19652
19651
  arguments: Record<string, any>;
19653
19652
  callID: string;
19654
19653
  name: string;
19655
19654
  namespace?: string;
19656
- partial?: {
19657
- content?: ({
19655
+ result: {
19656
+ content: ({
19658
19657
  type: "text";
19659
19658
  text: string;
19660
19659
  textSignature?: string;
@@ -19664,8 +19663,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19664
19663
  mimeType: string;
19665
19664
  })[];
19666
19665
  details?: any;
19666
+ isError: true;
19667
19667
  };
19668
- status: "running";
19668
+ status: "aborted";
19669
19669
  thoughtSignature?: string;
19670
19670
  time: {
19671
19671
  start: number;
@@ -20853,14 +20853,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20853
20853
  type: "image";
20854
20854
  data: string;
20855
20855
  mimeType: string;
20856
+ } | {
20857
+ type: "thinking";
20858
+ thinking: string;
20859
+ thinkingSignature?: string;
20860
+ redacted?: boolean;
20856
20861
  } | {
20857
20862
  addedToolNames?: string[];
20858
20863
  arguments: Record<string, any>;
20859
20864
  callID: string;
20860
20865
  name: string;
20861
20866
  namespace?: string;
20862
- result: {
20863
- content: ({
20867
+ partial?: {
20868
+ content?: ({
20864
20869
  type: "text";
20865
20870
  text: string;
20866
20871
  textSignature?: string;
@@ -20870,9 +20875,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20870
20875
  mimeType: string;
20871
20876
  })[];
20872
20877
  details?: any;
20873
- isError: false;
20874
20878
  };
20875
- status: "completed";
20879
+ status: "running";
20876
20880
  thoughtSignature?: string;
20877
20881
  time: {
20878
20882
  start: number;
@@ -20896,9 +20900,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20896
20900
  mimeType: string;
20897
20901
  })[];
20898
20902
  details?: any;
20899
- isError: true;
20903
+ isError: false;
20900
20904
  };
20901
- status: "error";
20905
+ status: "completed";
20902
20906
  thoughtSignature?: string;
20903
20907
  time: {
20904
20908
  start: number;
@@ -20924,7 +20928,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20924
20928
  details?: any;
20925
20929
  isError: true;
20926
20930
  };
20927
- status: "skipped";
20931
+ status: "error";
20928
20932
  thoughtSignature?: string;
20929
20933
  time: {
20930
20934
  start: number;
@@ -20950,26 +20954,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20950
20954
  details?: any;
20951
20955
  isError: true;
20952
20956
  };
20953
- status: "aborted";
20957
+ status: "skipped";
20954
20958
  thoughtSignature?: string;
20955
20959
  time: {
20956
20960
  start: number;
20957
20961
  end: number;
20958
20962
  };
20959
20963
  type: "toolCall";
20960
- } | {
20961
- type: "thinking";
20962
- thinking: string;
20963
- thinkingSignature?: string;
20964
- redacted?: boolean;
20965
20964
  } | {
20966
20965
  addedToolNames?: string[];
20967
20966
  arguments: Record<string, any>;
20968
20967
  callID: string;
20969
20968
  name: string;
20970
20969
  namespace?: string;
20971
- partial?: {
20972
- content?: ({
20970
+ result: {
20971
+ content: ({
20973
20972
  type: "text";
20974
20973
  text: string;
20975
20974
  textSignature?: string;
@@ -20979,8 +20978,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20979
20978
  mimeType: string;
20980
20979
  })[];
20981
20980
  details?: any;
20981
+ isError: true;
20982
20982
  };
20983
- status: "running";
20983
+ status: "aborted";
20984
20984
  thoughtSignature?: string;
20985
20985
  time: {
20986
20986
  start: number;
@@ -21155,14 +21155,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21155
21155
  type: "image";
21156
21156
  data: string;
21157
21157
  mimeType: string;
21158
+ } | {
21159
+ type: "thinking";
21160
+ thinking: string;
21161
+ thinkingSignature?: string;
21162
+ redacted?: boolean;
21158
21163
  } | {
21159
21164
  addedToolNames?: string[];
21160
21165
  arguments: Record<string, any>;
21161
21166
  callID: string;
21162
21167
  name: string;
21163
21168
  namespace?: string;
21164
- result: {
21165
- content: ({
21169
+ partial?: {
21170
+ content?: ({
21166
21171
  type: "text";
21167
21172
  text: string;
21168
21173
  textSignature?: string;
@@ -21172,9 +21177,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21172
21177
  mimeType: string;
21173
21178
  })[];
21174
21179
  details?: any;
21175
- isError: false;
21176
21180
  };
21177
- status: "completed";
21181
+ status: "running";
21178
21182
  thoughtSignature?: string;
21179
21183
  time: {
21180
21184
  start: number;
@@ -21198,9 +21202,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21198
21202
  mimeType: string;
21199
21203
  })[];
21200
21204
  details?: any;
21201
- isError: true;
21205
+ isError: false;
21202
21206
  };
21203
- status: "error";
21207
+ status: "completed";
21204
21208
  thoughtSignature?: string;
21205
21209
  time: {
21206
21210
  start: number;
@@ -21226,7 +21230,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21226
21230
  details?: any;
21227
21231
  isError: true;
21228
21232
  };
21229
- status: "skipped";
21233
+ status: "error";
21230
21234
  thoughtSignature?: string;
21231
21235
  time: {
21232
21236
  start: number;
@@ -21252,26 +21256,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21252
21256
  details?: any;
21253
21257
  isError: true;
21254
21258
  };
21255
- status: "aborted";
21259
+ status: "skipped";
21256
21260
  thoughtSignature?: string;
21257
21261
  time: {
21258
21262
  start: number;
21259
21263
  end: number;
21260
21264
  };
21261
21265
  type: "toolCall";
21262
- } | {
21263
- type: "thinking";
21264
- thinking: string;
21265
- thinkingSignature?: string;
21266
- redacted?: boolean;
21267
21266
  } | {
21268
21267
  addedToolNames?: string[];
21269
21268
  arguments: Record<string, any>;
21270
21269
  callID: string;
21271
21270
  name: string;
21272
21271
  namespace?: string;
21273
- partial?: {
21274
- content?: ({
21272
+ result: {
21273
+ content: ({
21275
21274
  type: "text";
21276
21275
  text: string;
21277
21276
  textSignature?: string;
@@ -21281,8 +21280,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21281
21280
  mimeType: string;
21282
21281
  })[];
21283
21282
  details?: any;
21283
+ isError: true;
21284
21284
  };
21285
- status: "running";
21285
+ status: "aborted";
21286
21286
  thoughtSignature?: string;
21287
21287
  time: {
21288
21288
  start: number;
@@ -21475,14 +21475,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21475
21475
  type: "image";
21476
21476
  data: string;
21477
21477
  mimeType: string;
21478
+ } | {
21479
+ type: "thinking";
21480
+ thinking: string;
21481
+ thinkingSignature?: string;
21482
+ redacted?: boolean;
21478
21483
  } | {
21479
21484
  addedToolNames?: string[];
21480
21485
  arguments: Record<string, any>;
21481
21486
  callID: string;
21482
21487
  name: string;
21483
21488
  namespace?: string;
21484
- result: {
21485
- content: ({
21489
+ partial?: {
21490
+ content?: ({
21486
21491
  type: "text";
21487
21492
  text: string;
21488
21493
  textSignature?: string;
@@ -21492,9 +21497,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21492
21497
  mimeType: string;
21493
21498
  })[];
21494
21499
  details?: any;
21495
- isError: false;
21496
21500
  };
21497
- status: "completed";
21501
+ status: "running";
21498
21502
  thoughtSignature?: string;
21499
21503
  time: {
21500
21504
  start: number;
@@ -21518,9 +21522,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21518
21522
  mimeType: string;
21519
21523
  })[];
21520
21524
  details?: any;
21521
- isError: true;
21525
+ isError: false;
21522
21526
  };
21523
- status: "error";
21527
+ status: "completed";
21524
21528
  thoughtSignature?: string;
21525
21529
  time: {
21526
21530
  start: number;
@@ -21546,7 +21550,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21546
21550
  details?: any;
21547
21551
  isError: true;
21548
21552
  };
21549
- status: "skipped";
21553
+ status: "error";
21550
21554
  thoughtSignature?: string;
21551
21555
  time: {
21552
21556
  start: number;
@@ -21572,26 +21576,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21572
21576
  details?: any;
21573
21577
  isError: true;
21574
21578
  };
21575
- status: "aborted";
21579
+ status: "skipped";
21576
21580
  thoughtSignature?: string;
21577
21581
  time: {
21578
21582
  start: number;
21579
21583
  end: number;
21580
21584
  };
21581
21585
  type: "toolCall";
21582
- } | {
21583
- type: "thinking";
21584
- thinking: string;
21585
- thinkingSignature?: string;
21586
- redacted?: boolean;
21587
21586
  } | {
21588
21587
  addedToolNames?: string[];
21589
21588
  arguments: Record<string, any>;
21590
21589
  callID: string;
21591
21590
  name: string;
21592
21591
  namespace?: string;
21593
- partial?: {
21594
- content?: ({
21592
+ result: {
21593
+ content: ({
21595
21594
  type: "text";
21596
21595
  text: string;
21597
21596
  textSignature?: string;
@@ -21601,8 +21600,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21601
21600
  mimeType: string;
21602
21601
  })[];
21603
21602
  details?: any;
21603
+ isError: true;
21604
21604
  };
21605
- status: "running";
21605
+ status: "aborted";
21606
21606
  thoughtSignature?: string;
21607
21607
  time: {
21608
21608
  start: number;
@@ -21777,14 +21777,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21777
21777
  type: "image";
21778
21778
  data: string;
21779
21779
  mimeType: string;
21780
+ } | {
21781
+ type: "thinking";
21782
+ thinking: string;
21783
+ thinkingSignature?: string;
21784
+ redacted?: boolean;
21780
21785
  } | {
21781
21786
  addedToolNames?: string[];
21782
21787
  arguments: Record<string, any>;
21783
21788
  callID: string;
21784
21789
  name: string;
21785
21790
  namespace?: string;
21786
- result: {
21787
- content: ({
21791
+ partial?: {
21792
+ content?: ({
21788
21793
  type: "text";
21789
21794
  text: string;
21790
21795
  textSignature?: string;
@@ -21794,9 +21799,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21794
21799
  mimeType: string;
21795
21800
  })[];
21796
21801
  details?: any;
21797
- isError: false;
21798
21802
  };
21799
- status: "completed";
21803
+ status: "running";
21800
21804
  thoughtSignature?: string;
21801
21805
  time: {
21802
21806
  start: number;
@@ -21820,9 +21824,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21820
21824
  mimeType: string;
21821
21825
  })[];
21822
21826
  details?: any;
21823
- isError: true;
21827
+ isError: false;
21824
21828
  };
21825
- status: "error";
21829
+ status: "completed";
21826
21830
  thoughtSignature?: string;
21827
21831
  time: {
21828
21832
  start: number;
@@ -21848,7 +21852,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21848
21852
  details?: any;
21849
21853
  isError: true;
21850
21854
  };
21851
- status: "skipped";
21855
+ status: "error";
21852
21856
  thoughtSignature?: string;
21853
21857
  time: {
21854
21858
  start: number;
@@ -21874,26 +21878,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21874
21878
  details?: any;
21875
21879
  isError: true;
21876
21880
  };
21877
- status: "aborted";
21881
+ status: "skipped";
21878
21882
  thoughtSignature?: string;
21879
21883
  time: {
21880
21884
  start: number;
21881
21885
  end: number;
21882
21886
  };
21883
21887
  type: "toolCall";
21884
- } | {
21885
- type: "thinking";
21886
- thinking: string;
21887
- thinkingSignature?: string;
21888
- redacted?: boolean;
21889
21888
  } | {
21890
21889
  addedToolNames?: string[];
21891
21890
  arguments: Record<string, any>;
21892
21891
  callID: string;
21893
21892
  name: string;
21894
21893
  namespace?: string;
21895
- partial?: {
21896
- content?: ({
21894
+ result: {
21895
+ content: ({
21897
21896
  type: "text";
21898
21897
  text: string;
21899
21898
  textSignature?: string;
@@ -21903,8 +21902,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21903
21902
  mimeType: string;
21904
21903
  })[];
21905
21904
  details?: any;
21905
+ isError: true;
21906
21906
  };
21907
- status: "running";
21907
+ status: "aborted";
21908
21908
  thoughtSignature?: string;
21909
21909
  time: {
21910
21910
  start: number;
@@ -22107,14 +22107,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22107
22107
  type: "image";
22108
22108
  data: string;
22109
22109
  mimeType: string;
22110
+ } | {
22111
+ type: "thinking";
22112
+ thinking: string;
22113
+ thinkingSignature?: string;
22114
+ redacted?: boolean;
22110
22115
  } | {
22111
22116
  addedToolNames?: string[];
22112
22117
  arguments: Record<string, any>;
22113
22118
  callID: string;
22114
22119
  name: string;
22115
22120
  namespace?: string;
22116
- result: {
22117
- content: ({
22121
+ partial?: {
22122
+ content?: ({
22118
22123
  type: "text";
22119
22124
  text: string;
22120
22125
  textSignature?: string;
@@ -22124,9 +22129,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22124
22129
  mimeType: string;
22125
22130
  })[];
22126
22131
  details?: any;
22127
- isError: false;
22128
22132
  };
22129
- status: "completed";
22133
+ status: "running";
22130
22134
  thoughtSignature?: string;
22131
22135
  time: {
22132
22136
  start: number;
@@ -22150,9 +22154,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22150
22154
  mimeType: string;
22151
22155
  })[];
22152
22156
  details?: any;
22153
- isError: true;
22157
+ isError: false;
22154
22158
  };
22155
- status: "error";
22159
+ status: "completed";
22156
22160
  thoughtSignature?: string;
22157
22161
  time: {
22158
22162
  start: number;
@@ -22178,7 +22182,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22178
22182
  details?: any;
22179
22183
  isError: true;
22180
22184
  };
22181
- status: "skipped";
22185
+ status: "error";
22182
22186
  thoughtSignature?: string;
22183
22187
  time: {
22184
22188
  start: number;
@@ -22204,26 +22208,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22204
22208
  details?: any;
22205
22209
  isError: true;
22206
22210
  };
22207
- status: "aborted";
22211
+ status: "skipped";
22208
22212
  thoughtSignature?: string;
22209
22213
  time: {
22210
22214
  start: number;
22211
22215
  end: number;
22212
22216
  };
22213
22217
  type: "toolCall";
22214
- } | {
22215
- type: "thinking";
22216
- thinking: string;
22217
- thinkingSignature?: string;
22218
- redacted?: boolean;
22219
22218
  } | {
22220
22219
  addedToolNames?: string[];
22221
22220
  arguments: Record<string, any>;
22222
22221
  callID: string;
22223
22222
  name: string;
22224
22223
  namespace?: string;
22225
- partial?: {
22226
- content?: ({
22224
+ result: {
22225
+ content: ({
22227
22226
  type: "text";
22228
22227
  text: string;
22229
22228
  textSignature?: string;
@@ -22233,8 +22232,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22233
22232
  mimeType: string;
22234
22233
  })[];
22235
22234
  details?: any;
22235
+ isError: true;
22236
22236
  };
22237
- status: "running";
22237
+ status: "aborted";
22238
22238
  thoughtSignature?: string;
22239
22239
  time: {
22240
22240
  start: number;
@@ -22409,14 +22409,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22409
22409
  type: "image";
22410
22410
  data: string;
22411
22411
  mimeType: string;
22412
+ } | {
22413
+ type: "thinking";
22414
+ thinking: string;
22415
+ thinkingSignature?: string;
22416
+ redacted?: boolean;
22412
22417
  } | {
22413
22418
  addedToolNames?: string[];
22414
22419
  arguments: Record<string, any>;
22415
22420
  callID: string;
22416
22421
  name: string;
22417
22422
  namespace?: string;
22418
- result: {
22419
- content: ({
22423
+ partial?: {
22424
+ content?: ({
22420
22425
  type: "text";
22421
22426
  text: string;
22422
22427
  textSignature?: string;
@@ -22426,9 +22431,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22426
22431
  mimeType: string;
22427
22432
  })[];
22428
22433
  details?: any;
22429
- isError: false;
22430
22434
  };
22431
- status: "completed";
22435
+ status: "running";
22432
22436
  thoughtSignature?: string;
22433
22437
  time: {
22434
22438
  start: number;
@@ -22452,9 +22456,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22452
22456
  mimeType: string;
22453
22457
  })[];
22454
22458
  details?: any;
22455
- isError: true;
22459
+ isError: false;
22456
22460
  };
22457
- status: "error";
22461
+ status: "completed";
22458
22462
  thoughtSignature?: string;
22459
22463
  time: {
22460
22464
  start: number;
@@ -22480,7 +22484,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22480
22484
  details?: any;
22481
22485
  isError: true;
22482
22486
  };
22483
- status: "skipped";
22487
+ status: "error";
22484
22488
  thoughtSignature?: string;
22485
22489
  time: {
22486
22490
  start: number;
@@ -22506,26 +22510,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22506
22510
  details?: any;
22507
22511
  isError: true;
22508
22512
  };
22509
- status: "aborted";
22513
+ status: "skipped";
22510
22514
  thoughtSignature?: string;
22511
22515
  time: {
22512
22516
  start: number;
22513
22517
  end: number;
22514
22518
  };
22515
22519
  type: "toolCall";
22516
- } | {
22517
- type: "thinking";
22518
- thinking: string;
22519
- thinkingSignature?: string;
22520
- redacted?: boolean;
22521
22520
  } | {
22522
22521
  addedToolNames?: string[];
22523
22522
  arguments: Record<string, any>;
22524
22523
  callID: string;
22525
22524
  name: string;
22526
22525
  namespace?: string;
22527
- partial?: {
22528
- content?: ({
22526
+ result: {
22527
+ content: ({
22529
22528
  type: "text";
22530
22529
  text: string;
22531
22530
  textSignature?: string;
@@ -22535,8 +22534,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22535
22534
  mimeType: string;
22536
22535
  })[];
22537
22536
  details?: any;
22537
+ isError: true;
22538
22538
  };
22539
- status: "running";
22539
+ status: "aborted";
22540
22540
  thoughtSignature?: string;
22541
22541
  time: {
22542
22542
  start: number;
@@ -22730,14 +22730,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22730
22730
  type: "image";
22731
22731
  data: string;
22732
22732
  mimeType: string;
22733
+ } | {
22734
+ type: "thinking";
22735
+ thinking: string;
22736
+ thinkingSignature?: string;
22737
+ redacted?: boolean;
22733
22738
  } | {
22734
22739
  addedToolNames?: string[];
22735
22740
  arguments: Record<string, any>;
22736
22741
  callID: string;
22737
22742
  name: string;
22738
22743
  namespace?: string;
22739
- result: {
22740
- content: ({
22744
+ partial?: {
22745
+ content?: ({
22741
22746
  type: "text";
22742
22747
  text: string;
22743
22748
  textSignature?: string;
@@ -22747,9 +22752,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22747
22752
  mimeType: string;
22748
22753
  })[];
22749
22754
  details?: any;
22750
- isError: false;
22751
22755
  };
22752
- status: "completed";
22756
+ status: "running";
22753
22757
  thoughtSignature?: string;
22754
22758
  time: {
22755
22759
  start: number;
@@ -22773,9 +22777,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22773
22777
  mimeType: string;
22774
22778
  })[];
22775
22779
  details?: any;
22776
- isError: true;
22780
+ isError: false;
22777
22781
  };
22778
- status: "error";
22782
+ status: "completed";
22779
22783
  thoughtSignature?: string;
22780
22784
  time: {
22781
22785
  start: number;
@@ -22801,7 +22805,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22801
22805
  details?: any;
22802
22806
  isError: true;
22803
22807
  };
22804
- status: "skipped";
22808
+ status: "error";
22805
22809
  thoughtSignature?: string;
22806
22810
  time: {
22807
22811
  start: number;
@@ -22827,26 +22831,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22827
22831
  details?: any;
22828
22832
  isError: true;
22829
22833
  };
22830
- status: "aborted";
22834
+ status: "skipped";
22831
22835
  thoughtSignature?: string;
22832
22836
  time: {
22833
22837
  start: number;
22834
22838
  end: number;
22835
22839
  };
22836
22840
  type: "toolCall";
22837
- } | {
22838
- type: "thinking";
22839
- thinking: string;
22840
- thinkingSignature?: string;
22841
- redacted?: boolean;
22842
22841
  } | {
22843
22842
  addedToolNames?: string[];
22844
22843
  arguments: Record<string, any>;
22845
22844
  callID: string;
22846
22845
  name: string;
22847
22846
  namespace?: string;
22848
- partial?: {
22849
- content?: ({
22847
+ result: {
22848
+ content: ({
22850
22849
  type: "text";
22851
22850
  text: string;
22852
22851
  textSignature?: string;
@@ -22856,8 +22855,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22856
22855
  mimeType: string;
22857
22856
  })[];
22858
22857
  details?: any;
22858
+ isError: true;
22859
22859
  };
22860
- status: "running";
22860
+ status: "aborted";
22861
22861
  thoughtSignature?: string;
22862
22862
  time: {
22863
22863
  start: number;
@@ -23032,14 +23032,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23032
23032
  type: "image";
23033
23033
  data: string;
23034
23034
  mimeType: string;
23035
+ } | {
23036
+ type: "thinking";
23037
+ thinking: string;
23038
+ thinkingSignature?: string;
23039
+ redacted?: boolean;
23035
23040
  } | {
23036
23041
  addedToolNames?: string[];
23037
23042
  arguments: Record<string, any>;
23038
23043
  callID: string;
23039
23044
  name: string;
23040
23045
  namespace?: string;
23041
- result: {
23042
- content: ({
23046
+ partial?: {
23047
+ content?: ({
23043
23048
  type: "text";
23044
23049
  text: string;
23045
23050
  textSignature?: string;
@@ -23049,9 +23054,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23049
23054
  mimeType: string;
23050
23055
  })[];
23051
23056
  details?: any;
23052
- isError: false;
23053
23057
  };
23054
- status: "completed";
23058
+ status: "running";
23055
23059
  thoughtSignature?: string;
23056
23060
  time: {
23057
23061
  start: number;
@@ -23075,9 +23079,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23075
23079
  mimeType: string;
23076
23080
  })[];
23077
23081
  details?: any;
23078
- isError: true;
23082
+ isError: false;
23079
23083
  };
23080
- status: "error";
23084
+ status: "completed";
23081
23085
  thoughtSignature?: string;
23082
23086
  time: {
23083
23087
  start: number;
@@ -23103,7 +23107,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23103
23107
  details?: any;
23104
23108
  isError: true;
23105
23109
  };
23106
- status: "skipped";
23110
+ status: "error";
23107
23111
  thoughtSignature?: string;
23108
23112
  time: {
23109
23113
  start: number;
@@ -23129,26 +23133,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23129
23133
  details?: any;
23130
23134
  isError: true;
23131
23135
  };
23132
- status: "aborted";
23136
+ status: "skipped";
23133
23137
  thoughtSignature?: string;
23134
23138
  time: {
23135
23139
  start: number;
23136
23140
  end: number;
23137
23141
  };
23138
23142
  type: "toolCall";
23139
- } | {
23140
- type: "thinking";
23141
- thinking: string;
23142
- thinkingSignature?: string;
23143
- redacted?: boolean;
23144
23143
  } | {
23145
23144
  addedToolNames?: string[];
23146
23145
  arguments: Record<string, any>;
23147
23146
  callID: string;
23148
23147
  name: string;
23149
23148
  namespace?: string;
23150
- partial?: {
23151
- content?: ({
23149
+ result: {
23150
+ content: ({
23152
23151
  type: "text";
23153
23152
  text: string;
23154
23153
  textSignature?: string;
@@ -23158,8 +23157,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23158
23157
  mimeType: string;
23159
23158
  })[];
23160
23159
  details?: any;
23160
+ isError: true;
23161
23161
  };
23162
- status: "running";
23162
+ status: "aborted";
23163
23163
  thoughtSignature?: string;
23164
23164
  time: {
23165
23165
  start: number;
@@ -23362,14 +23362,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23362
23362
  type: "image";
23363
23363
  data: string;
23364
23364
  mimeType: string;
23365
+ } | {
23366
+ type: "thinking";
23367
+ thinking: string;
23368
+ thinkingSignature?: string;
23369
+ redacted?: boolean;
23365
23370
  } | {
23366
23371
  addedToolNames?: string[];
23367
23372
  arguments: Record<string, any>;
23368
23373
  callID: string;
23369
23374
  name: string;
23370
23375
  namespace?: string;
23371
- result: {
23372
- content: ({
23376
+ partial?: {
23377
+ content?: ({
23373
23378
  type: "text";
23374
23379
  text: string;
23375
23380
  textSignature?: string;
@@ -23379,9 +23384,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23379
23384
  mimeType: string;
23380
23385
  })[];
23381
23386
  details?: any;
23382
- isError: false;
23383
23387
  };
23384
- status: "completed";
23388
+ status: "running";
23385
23389
  thoughtSignature?: string;
23386
23390
  time: {
23387
23391
  start: number;
@@ -23405,9 +23409,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23405
23409
  mimeType: string;
23406
23410
  })[];
23407
23411
  details?: any;
23408
- isError: true;
23412
+ isError: false;
23409
23413
  };
23410
- status: "error";
23414
+ status: "completed";
23411
23415
  thoughtSignature?: string;
23412
23416
  time: {
23413
23417
  start: number;
@@ -23433,7 +23437,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23433
23437
  details?: any;
23434
23438
  isError: true;
23435
23439
  };
23436
- status: "skipped";
23440
+ status: "error";
23437
23441
  thoughtSignature?: string;
23438
23442
  time: {
23439
23443
  start: number;
@@ -23459,26 +23463,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23459
23463
  details?: any;
23460
23464
  isError: true;
23461
23465
  };
23462
- status: "aborted";
23466
+ status: "skipped";
23463
23467
  thoughtSignature?: string;
23464
23468
  time: {
23465
23469
  start: number;
23466
23470
  end: number;
23467
23471
  };
23468
23472
  type: "toolCall";
23469
- } | {
23470
- type: "thinking";
23471
- thinking: string;
23472
- thinkingSignature?: string;
23473
- redacted?: boolean;
23474
23473
  } | {
23475
23474
  addedToolNames?: string[];
23476
23475
  arguments: Record<string, any>;
23477
23476
  callID: string;
23478
23477
  name: string;
23479
23478
  namespace?: string;
23480
- partial?: {
23481
- content?: ({
23479
+ result: {
23480
+ content: ({
23482
23481
  type: "text";
23483
23482
  text: string;
23484
23483
  textSignature?: string;
@@ -23488,8 +23487,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23488
23487
  mimeType: string;
23489
23488
  })[];
23490
23489
  details?: any;
23490
+ isError: true;
23491
23491
  };
23492
- status: "running";
23492
+ status: "aborted";
23493
23493
  thoughtSignature?: string;
23494
23494
  time: {
23495
23495
  start: number;
@@ -23664,14 +23664,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23664
23664
  type: "image";
23665
23665
  data: string;
23666
23666
  mimeType: string;
23667
+ } | {
23668
+ type: "thinking";
23669
+ thinking: string;
23670
+ thinkingSignature?: string;
23671
+ redacted?: boolean;
23667
23672
  } | {
23668
23673
  addedToolNames?: string[];
23669
23674
  arguments: Record<string, any>;
23670
23675
  callID: string;
23671
23676
  name: string;
23672
23677
  namespace?: string;
23673
- result: {
23674
- content: ({
23678
+ partial?: {
23679
+ content?: ({
23675
23680
  type: "text";
23676
23681
  text: string;
23677
23682
  textSignature?: string;
@@ -23681,9 +23686,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23681
23686
  mimeType: string;
23682
23687
  })[];
23683
23688
  details?: any;
23684
- isError: false;
23685
23689
  };
23686
- status: "completed";
23690
+ status: "running";
23687
23691
  thoughtSignature?: string;
23688
23692
  time: {
23689
23693
  start: number;
@@ -23707,9 +23711,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23707
23711
  mimeType: string;
23708
23712
  })[];
23709
23713
  details?: any;
23710
- isError: true;
23714
+ isError: false;
23711
23715
  };
23712
- status: "error";
23716
+ status: "completed";
23713
23717
  thoughtSignature?: string;
23714
23718
  time: {
23715
23719
  start: number;
@@ -23735,7 +23739,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23735
23739
  details?: any;
23736
23740
  isError: true;
23737
23741
  };
23738
- status: "skipped";
23742
+ status: "error";
23739
23743
  thoughtSignature?: string;
23740
23744
  time: {
23741
23745
  start: number;
@@ -23761,26 +23765,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23761
23765
  details?: any;
23762
23766
  isError: true;
23763
23767
  };
23764
- status: "aborted";
23768
+ status: "skipped";
23765
23769
  thoughtSignature?: string;
23766
23770
  time: {
23767
23771
  start: number;
23768
23772
  end: number;
23769
23773
  };
23770
23774
  type: "toolCall";
23771
- } | {
23772
- type: "thinking";
23773
- thinking: string;
23774
- thinkingSignature?: string;
23775
- redacted?: boolean;
23776
23775
  } | {
23777
23776
  addedToolNames?: string[];
23778
23777
  arguments: Record<string, any>;
23779
23778
  callID: string;
23780
23779
  name: string;
23781
23780
  namespace?: string;
23782
- partial?: {
23783
- content?: ({
23781
+ result: {
23782
+ content: ({
23784
23783
  type: "text";
23785
23784
  text: string;
23786
23785
  textSignature?: string;
@@ -23790,8 +23789,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23790
23789
  mimeType: string;
23791
23790
  })[];
23792
23791
  details?: any;
23792
+ isError: true;
23793
23793
  };
23794
- status: "running";
23794
+ status: "aborted";
23795
23795
  thoughtSignature?: string;
23796
23796
  time: {
23797
23797
  start: number;
@@ -23985,14 +23985,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23985
23985
  type: "image";
23986
23986
  data: string;
23987
23987
  mimeType: string;
23988
+ } | {
23989
+ type: "thinking";
23990
+ thinking: string;
23991
+ thinkingSignature?: string;
23992
+ redacted?: boolean;
23988
23993
  } | {
23989
23994
  addedToolNames?: string[];
23990
23995
  arguments: Record<string, any>;
23991
23996
  callID: string;
23992
23997
  name: string;
23993
23998
  namespace?: string;
23994
- result: {
23995
- content: ({
23999
+ partial?: {
24000
+ content?: ({
23996
24001
  type: "text";
23997
24002
  text: string;
23998
24003
  textSignature?: string;
@@ -24002,9 +24007,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24002
24007
  mimeType: string;
24003
24008
  })[];
24004
24009
  details?: any;
24005
- isError: false;
24006
24010
  };
24007
- status: "completed";
24011
+ status: "running";
24008
24012
  thoughtSignature?: string;
24009
24013
  time: {
24010
24014
  start: number;
@@ -24028,9 +24032,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24028
24032
  mimeType: string;
24029
24033
  })[];
24030
24034
  details?: any;
24031
- isError: true;
24035
+ isError: false;
24032
24036
  };
24033
- status: "error";
24037
+ status: "completed";
24034
24038
  thoughtSignature?: string;
24035
24039
  time: {
24036
24040
  start: number;
@@ -24056,7 +24060,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24056
24060
  details?: any;
24057
24061
  isError: true;
24058
24062
  };
24059
- status: "skipped";
24063
+ status: "error";
24060
24064
  thoughtSignature?: string;
24061
24065
  time: {
24062
24066
  start: number;
@@ -24082,26 +24086,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24082
24086
  details?: any;
24083
24087
  isError: true;
24084
24088
  };
24085
- status: "aborted";
24089
+ status: "skipped";
24086
24090
  thoughtSignature?: string;
24087
24091
  time: {
24088
24092
  start: number;
24089
24093
  end: number;
24090
24094
  };
24091
24095
  type: "toolCall";
24092
- } | {
24093
- type: "thinking";
24094
- thinking: string;
24095
- thinkingSignature?: string;
24096
- redacted?: boolean;
24097
24096
  } | {
24098
24097
  addedToolNames?: string[];
24099
24098
  arguments: Record<string, any>;
24100
24099
  callID: string;
24101
24100
  name: string;
24102
24101
  namespace?: string;
24103
- partial?: {
24104
- content?: ({
24102
+ result: {
24103
+ content: ({
24105
24104
  type: "text";
24106
24105
  text: string;
24107
24106
  textSignature?: string;
@@ -24111,8 +24110,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24111
24110
  mimeType: string;
24112
24111
  })[];
24113
24112
  details?: any;
24113
+ isError: true;
24114
24114
  };
24115
- status: "running";
24115
+ status: "aborted";
24116
24116
  thoughtSignature?: string;
24117
24117
  time: {
24118
24118
  start: number;
@@ -24287,14 +24287,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24287
24287
  type: "image";
24288
24288
  data: string;
24289
24289
  mimeType: string;
24290
+ } | {
24291
+ type: "thinking";
24292
+ thinking: string;
24293
+ thinkingSignature?: string;
24294
+ redacted?: boolean;
24290
24295
  } | {
24291
24296
  addedToolNames?: string[];
24292
24297
  arguments: Record<string, any>;
24293
24298
  callID: string;
24294
24299
  name: string;
24295
24300
  namespace?: string;
24296
- result: {
24297
- content: ({
24301
+ partial?: {
24302
+ content?: ({
24298
24303
  type: "text";
24299
24304
  text: string;
24300
24305
  textSignature?: string;
@@ -24304,9 +24309,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24304
24309
  mimeType: string;
24305
24310
  })[];
24306
24311
  details?: any;
24307
- isError: false;
24308
24312
  };
24309
- status: "completed";
24313
+ status: "running";
24310
24314
  thoughtSignature?: string;
24311
24315
  time: {
24312
24316
  start: number;
@@ -24330,9 +24334,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24330
24334
  mimeType: string;
24331
24335
  })[];
24332
24336
  details?: any;
24333
- isError: true;
24337
+ isError: false;
24334
24338
  };
24335
- status: "error";
24339
+ status: "completed";
24336
24340
  thoughtSignature?: string;
24337
24341
  time: {
24338
24342
  start: number;
@@ -24358,7 +24362,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24358
24362
  details?: any;
24359
24363
  isError: true;
24360
24364
  };
24361
- status: "skipped";
24365
+ status: "error";
24362
24366
  thoughtSignature?: string;
24363
24367
  time: {
24364
24368
  start: number;
@@ -24384,26 +24388,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24384
24388
  details?: any;
24385
24389
  isError: true;
24386
24390
  };
24387
- status: "aborted";
24391
+ status: "skipped";
24388
24392
  thoughtSignature?: string;
24389
24393
  time: {
24390
24394
  start: number;
24391
24395
  end: number;
24392
24396
  };
24393
24397
  type: "toolCall";
24394
- } | {
24395
- type: "thinking";
24396
- thinking: string;
24397
- thinkingSignature?: string;
24398
- redacted?: boolean;
24399
24398
  } | {
24400
24399
  addedToolNames?: string[];
24401
24400
  arguments: Record<string, any>;
24402
24401
  callID: string;
24403
24402
  name: string;
24404
24403
  namespace?: string;
24405
- partial?: {
24406
- content?: ({
24404
+ result: {
24405
+ content: ({
24407
24406
  type: "text";
24408
24407
  text: string;
24409
24408
  textSignature?: string;
@@ -24413,8 +24412,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24413
24412
  mimeType: string;
24414
24413
  })[];
24415
24414
  details?: any;
24415
+ isError: true;
24416
24416
  };
24417
- status: "running";
24417
+ status: "aborted";
24418
24418
  thoughtSignature?: string;
24419
24419
  time: {
24420
24420
  start: number;