@codeworksh/harness 0.4.0-dev.20261019193730 → 0.4.0-dev.20261020131429

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