@codeworksh/harness 0.2.0-dev.20261012155220 → 0.2.0-dev.20261013040429

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/effect.d.mts +824 -824
  2. package/package.json +3 -3
package/effect.d.mts CHANGED
@@ -2715,6 +2715,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2715
2715
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2716
2716
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2717
2717
  declare const encodeMessage: (message: {
2718
+ messageId: string;
2719
+ role: "user";
2720
+ time: {
2721
+ created: number;
2722
+ };
2723
+ parts: ({
2724
+ type: "text";
2725
+ text: string;
2726
+ textSignature?: string;
2727
+ } | {
2728
+ type: "image";
2729
+ data: string;
2730
+ mimeType: string;
2731
+ })[];
2732
+ } | {
2718
2733
  role: "assistant";
2719
2734
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2720
2735
  provider: {
@@ -2864,19 +2879,14 @@ declare const encodeMessage: (message: {
2864
2879
  type: "image";
2865
2880
  data: string;
2866
2881
  mimeType: string;
2867
- } | {
2868
- type: "thinking";
2869
- thinking: string;
2870
- thinkingSignature?: string;
2871
- redacted?: boolean;
2872
2882
  } | {
2873
2883
  addedToolNames?: string[];
2874
2884
  arguments: Record<string, any>;
2875
2885
  callID: string;
2876
2886
  name: string;
2877
2887
  namespace?: string;
2878
- partial?: {
2879
- content?: ({
2888
+ result: {
2889
+ content: ({
2880
2890
  type: "text";
2881
2891
  text: string;
2882
2892
  textSignature?: string;
@@ -2886,8 +2896,9 @@ declare const encodeMessage: (message: {
2886
2896
  mimeType: string;
2887
2897
  })[];
2888
2898
  details?: any;
2899
+ isError: false;
2889
2900
  };
2890
- status: "running";
2901
+ status: "completed";
2891
2902
  thoughtSignature?: string;
2892
2903
  time: {
2893
2904
  start: number;
@@ -2911,9 +2922,9 @@ declare const encodeMessage: (message: {
2911
2922
  mimeType: string;
2912
2923
  })[];
2913
2924
  details?: any;
2914
- isError: false;
2925
+ isError: true;
2915
2926
  };
2916
- status: "completed";
2927
+ status: "error";
2917
2928
  thoughtSignature?: string;
2918
2929
  time: {
2919
2930
  start: number;
@@ -2939,7 +2950,7 @@ declare const encodeMessage: (message: {
2939
2950
  details?: any;
2940
2951
  isError: true;
2941
2952
  };
2942
- status: "error";
2953
+ status: "skipped";
2943
2954
  thoughtSignature?: string;
2944
2955
  time: {
2945
2956
  start: number;
@@ -2965,21 +2976,26 @@ declare const encodeMessage: (message: {
2965
2976
  details?: any;
2966
2977
  isError: true;
2967
2978
  };
2968
- status: "skipped";
2979
+ status: "aborted";
2969
2980
  thoughtSignature?: string;
2970
2981
  time: {
2971
2982
  start: number;
2972
2983
  end: number;
2973
2984
  };
2974
2985
  type: "toolCall";
2986
+ } | {
2987
+ type: "thinking";
2988
+ thinking: string;
2989
+ thinkingSignature?: string;
2990
+ redacted?: boolean;
2975
2991
  } | {
2976
2992
  addedToolNames?: string[];
2977
2993
  arguments: Record<string, any>;
2978
2994
  callID: string;
2979
2995
  name: string;
2980
2996
  namespace?: string;
2981
- result: {
2982
- content: ({
2997
+ partial?: {
2998
+ content?: ({
2983
2999
  type: "text";
2984
3000
  text: string;
2985
3001
  textSignature?: string;
@@ -2989,9 +3005,8 @@ declare const encodeMessage: (message: {
2989
3005
  mimeType: string;
2990
3006
  })[];
2991
3007
  details?: any;
2992
- isError: true;
2993
3008
  };
2994
- status: "aborted";
3009
+ status: "running";
2995
3010
  thoughtSignature?: string;
2996
3011
  time: {
2997
3012
  start: number;
@@ -3016,7 +3031,8 @@ declare const encodeMessage: (message: {
3016
3031
  responseId?: string;
3017
3032
  responseModel?: string;
3018
3033
  messageId: string;
3019
- } | {
3034
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3035
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3020
3036
  messageId: string;
3021
3037
  role: "user";
3022
3038
  time: {
@@ -3031,8 +3047,8 @@ declare const encodeMessage: (message: {
3031
3047
  data: string;
3032
3048
  mimeType: string;
3033
3049
  })[];
3034
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3035
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3050
+ }, ContextDecodeError, never>;
3051
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3036
3052
  messageId: string;
3037
3053
  role: "user";
3038
3054
  time: {
@@ -3047,8 +3063,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3047
3063
  data: string;
3048
3064
  mimeType: string;
3049
3065
  })[];
3050
- }, ContextDecodeError, never>;
3051
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3066
+ } | {
3052
3067
  role: "assistant";
3053
3068
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3054
3069
  provider: {
@@ -3198,19 +3213,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3198
3213
  type: "image";
3199
3214
  data: string;
3200
3215
  mimeType: string;
3201
- } | {
3202
- type: "thinking";
3203
- thinking: string;
3204
- thinkingSignature?: string;
3205
- redacted?: boolean;
3206
3216
  } | {
3207
3217
  addedToolNames?: string[];
3208
3218
  arguments: Record<string, any>;
3209
3219
  callID: string;
3210
3220
  name: string;
3211
3221
  namespace?: string;
3212
- partial?: {
3213
- content?: ({
3222
+ result: {
3223
+ content: ({
3214
3224
  type: "text";
3215
3225
  text: string;
3216
3226
  textSignature?: string;
@@ -3220,8 +3230,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3220
3230
  mimeType: string;
3221
3231
  })[];
3222
3232
  details?: any;
3233
+ isError: false;
3223
3234
  };
3224
- status: "running";
3235
+ status: "completed";
3225
3236
  thoughtSignature?: string;
3226
3237
  time: {
3227
3238
  start: number;
@@ -3245,9 +3256,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3245
3256
  mimeType: string;
3246
3257
  })[];
3247
3258
  details?: any;
3248
- isError: false;
3259
+ isError: true;
3249
3260
  };
3250
- status: "completed";
3261
+ status: "error";
3251
3262
  thoughtSignature?: string;
3252
3263
  time: {
3253
3264
  start: number;
@@ -3273,7 +3284,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3273
3284
  details?: any;
3274
3285
  isError: true;
3275
3286
  };
3276
- status: "error";
3287
+ status: "skipped";
3277
3288
  thoughtSignature?: string;
3278
3289
  time: {
3279
3290
  start: number;
@@ -3299,21 +3310,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3299
3310
  details?: any;
3300
3311
  isError: true;
3301
3312
  };
3302
- status: "skipped";
3313
+ status: "aborted";
3303
3314
  thoughtSignature?: string;
3304
3315
  time: {
3305
3316
  start: number;
3306
3317
  end: number;
3307
3318
  };
3308
3319
  type: "toolCall";
3320
+ } | {
3321
+ type: "thinking";
3322
+ thinking: string;
3323
+ thinkingSignature?: string;
3324
+ redacted?: boolean;
3309
3325
  } | {
3310
3326
  addedToolNames?: string[];
3311
3327
  arguments: Record<string, any>;
3312
3328
  callID: string;
3313
3329
  name: string;
3314
3330
  namespace?: string;
3315
- result: {
3316
- content: ({
3331
+ partial?: {
3332
+ content?: ({
3317
3333
  type: "text";
3318
3334
  text: string;
3319
3335
  textSignature?: string;
@@ -3323,9 +3339,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3323
3339
  mimeType: string;
3324
3340
  })[];
3325
3341
  details?: any;
3326
- isError: true;
3327
3342
  };
3328
- status: "aborted";
3343
+ status: "running";
3329
3344
  thoughtSignature?: string;
3330
3345
  time: {
3331
3346
  start: number;
@@ -3350,21 +3365,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3350
3365
  responseId?: string;
3351
3366
  responseModel?: string;
3352
3367
  messageId: string;
3353
- } | {
3354
- messageId: string;
3355
- role: "user";
3356
- time: {
3357
- created: number;
3358
- };
3359
- parts: ({
3360
- type: "text";
3361
- text: string;
3362
- textSignature?: string;
3363
- } | {
3364
- type: "image";
3365
- data: string;
3366
- mimeType: string;
3367
- })[];
3368
3368
  }, ContextDecodeError, never>;
3369
3369
  declare namespace context_d_exports {
3370
3370
  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 };
@@ -4807,19 +4807,14 @@ declare const LLMStarted: Schema.Struct<{
4807
4807
  type: "image";
4808
4808
  data: string;
4809
4809
  mimeType: string;
4810
- } | {
4811
- type: "thinking";
4812
- thinking: string;
4813
- thinkingSignature?: string;
4814
- redacted?: boolean;
4815
4810
  } | {
4816
4811
  addedToolNames?: string[];
4817
4812
  arguments: Record<string, any>;
4818
4813
  callID: string;
4819
4814
  name: string;
4820
4815
  namespace?: string;
4821
- partial?: {
4822
- content?: ({
4816
+ result: {
4817
+ content: ({
4823
4818
  type: "text";
4824
4819
  text: string;
4825
4820
  textSignature?: string;
@@ -4829,8 +4824,9 @@ declare const LLMStarted: Schema.Struct<{
4829
4824
  mimeType: string;
4830
4825
  })[];
4831
4826
  details?: any;
4827
+ isError: false;
4832
4828
  };
4833
- status: "running";
4829
+ status: "completed";
4834
4830
  thoughtSignature?: string;
4835
4831
  time: {
4836
4832
  start: number;
@@ -4854,9 +4850,9 @@ declare const LLMStarted: Schema.Struct<{
4854
4850
  mimeType: string;
4855
4851
  })[];
4856
4852
  details?: any;
4857
- isError: false;
4853
+ isError: true;
4858
4854
  };
4859
- status: "completed";
4855
+ status: "error";
4860
4856
  thoughtSignature?: string;
4861
4857
  time: {
4862
4858
  start: number;
@@ -4882,7 +4878,7 @@ declare const LLMStarted: Schema.Struct<{
4882
4878
  details?: any;
4883
4879
  isError: true;
4884
4880
  };
4885
- status: "error";
4881
+ status: "skipped";
4886
4882
  thoughtSignature?: string;
4887
4883
  time: {
4888
4884
  start: number;
@@ -4908,21 +4904,26 @@ declare const LLMStarted: Schema.Struct<{
4908
4904
  details?: any;
4909
4905
  isError: true;
4910
4906
  };
4911
- status: "skipped";
4907
+ status: "aborted";
4912
4908
  thoughtSignature?: string;
4913
4909
  time: {
4914
4910
  start: number;
4915
4911
  end: number;
4916
4912
  };
4917
4913
  type: "toolCall";
4914
+ } | {
4915
+ type: "thinking";
4916
+ thinking: string;
4917
+ thinkingSignature?: string;
4918
+ redacted?: boolean;
4918
4919
  } | {
4919
4920
  addedToolNames?: string[];
4920
4921
  arguments: Record<string, any>;
4921
4922
  callID: string;
4922
4923
  name: string;
4923
4924
  namespace?: string;
4924
- result: {
4925
- content: ({
4925
+ partial?: {
4926
+ content?: ({
4926
4927
  type: "text";
4927
4928
  text: string;
4928
4929
  textSignature?: string;
@@ -4932,9 +4933,8 @@ declare const LLMStarted: Schema.Struct<{
4932
4933
  mimeType: string;
4933
4934
  })[];
4934
4935
  details?: any;
4935
- isError: true;
4936
4936
  };
4937
- status: "aborted";
4937
+ status: "running";
4938
4938
  thoughtSignature?: string;
4939
4939
  time: {
4940
4940
  start: number;
@@ -5109,19 +5109,14 @@ declare const LLMStarted: Schema.Struct<{
5109
5109
  type: "image";
5110
5110
  data: string;
5111
5111
  mimeType: string;
5112
- } | {
5113
- type: "thinking";
5114
- thinking: string;
5115
- thinkingSignature?: string;
5116
- redacted?: boolean;
5117
5112
  } | {
5118
5113
  addedToolNames?: string[];
5119
5114
  arguments: Record<string, any>;
5120
5115
  callID: string;
5121
5116
  name: string;
5122
5117
  namespace?: string;
5123
- partial?: {
5124
- content?: ({
5118
+ result: {
5119
+ content: ({
5125
5120
  type: "text";
5126
5121
  text: string;
5127
5122
  textSignature?: string;
@@ -5131,8 +5126,9 @@ declare const LLMStarted: Schema.Struct<{
5131
5126
  mimeType: string;
5132
5127
  })[];
5133
5128
  details?: any;
5129
+ isError: false;
5134
5130
  };
5135
- status: "running";
5131
+ status: "completed";
5136
5132
  thoughtSignature?: string;
5137
5133
  time: {
5138
5134
  start: number;
@@ -5156,9 +5152,9 @@ declare const LLMStarted: Schema.Struct<{
5156
5152
  mimeType: string;
5157
5153
  })[];
5158
5154
  details?: any;
5159
- isError: false;
5155
+ isError: true;
5160
5156
  };
5161
- status: "completed";
5157
+ status: "error";
5162
5158
  thoughtSignature?: string;
5163
5159
  time: {
5164
5160
  start: number;
@@ -5184,7 +5180,7 @@ declare const LLMStarted: Schema.Struct<{
5184
5180
  details?: any;
5185
5181
  isError: true;
5186
5182
  };
5187
- status: "error";
5183
+ status: "skipped";
5188
5184
  thoughtSignature?: string;
5189
5185
  time: {
5190
5186
  start: number;
@@ -5210,21 +5206,26 @@ declare const LLMStarted: Schema.Struct<{
5210
5206
  details?: any;
5211
5207
  isError: true;
5212
5208
  };
5213
- status: "skipped";
5209
+ status: "aborted";
5214
5210
  thoughtSignature?: string;
5215
5211
  time: {
5216
5212
  start: number;
5217
5213
  end: number;
5218
5214
  };
5219
5215
  type: "toolCall";
5216
+ } | {
5217
+ type: "thinking";
5218
+ thinking: string;
5219
+ thinkingSignature?: string;
5220
+ redacted?: boolean;
5220
5221
  } | {
5221
5222
  addedToolNames?: string[];
5222
5223
  arguments: Record<string, any>;
5223
5224
  callID: string;
5224
5225
  name: string;
5225
5226
  namespace?: string;
5226
- result: {
5227
- content: ({
5227
+ partial?: {
5228
+ content?: ({
5228
5229
  type: "text";
5229
5230
  text: string;
5230
5231
  textSignature?: string;
@@ -5234,9 +5235,8 @@ declare const LLMStarted: Schema.Struct<{
5234
5235
  mimeType: string;
5235
5236
  })[];
5236
5237
  details?: any;
5237
- isError: true;
5238
5238
  };
5239
- status: "aborted";
5239
+ status: "running";
5240
5240
  thoughtSignature?: string;
5241
5241
  time: {
5242
5242
  start: number;
@@ -5429,19 +5429,14 @@ declare const LLMStarted: Schema.Struct<{
5429
5429
  type: "image";
5430
5430
  data: string;
5431
5431
  mimeType: string;
5432
- } | {
5433
- type: "thinking";
5434
- thinking: string;
5435
- thinkingSignature?: string;
5436
- redacted?: boolean;
5437
5432
  } | {
5438
5433
  addedToolNames?: string[];
5439
5434
  arguments: Record<string, any>;
5440
5435
  callID: string;
5441
5436
  name: string;
5442
5437
  namespace?: string;
5443
- partial?: {
5444
- content?: ({
5438
+ result: {
5439
+ content: ({
5445
5440
  type: "text";
5446
5441
  text: string;
5447
5442
  textSignature?: string;
@@ -5451,8 +5446,9 @@ declare const LLMStarted: Schema.Struct<{
5451
5446
  mimeType: string;
5452
5447
  })[];
5453
5448
  details?: any;
5449
+ isError: false;
5454
5450
  };
5455
- status: "running";
5451
+ status: "completed";
5456
5452
  thoughtSignature?: string;
5457
5453
  time: {
5458
5454
  start: number;
@@ -5476,9 +5472,9 @@ declare const LLMStarted: Schema.Struct<{
5476
5472
  mimeType: string;
5477
5473
  })[];
5478
5474
  details?: any;
5479
- isError: false;
5475
+ isError: true;
5480
5476
  };
5481
- status: "completed";
5477
+ status: "error";
5482
5478
  thoughtSignature?: string;
5483
5479
  time: {
5484
5480
  start: number;
@@ -5504,7 +5500,7 @@ declare const LLMStarted: Schema.Struct<{
5504
5500
  details?: any;
5505
5501
  isError: true;
5506
5502
  };
5507
- status: "error";
5503
+ status: "skipped";
5508
5504
  thoughtSignature?: string;
5509
5505
  time: {
5510
5506
  start: number;
@@ -5530,21 +5526,26 @@ declare const LLMStarted: Schema.Struct<{
5530
5526
  details?: any;
5531
5527
  isError: true;
5532
5528
  };
5533
- status: "skipped";
5529
+ status: "aborted";
5534
5530
  thoughtSignature?: string;
5535
5531
  time: {
5536
5532
  start: number;
5537
5533
  end: number;
5538
5534
  };
5539
5535
  type: "toolCall";
5536
+ } | {
5537
+ type: "thinking";
5538
+ thinking: string;
5539
+ thinkingSignature?: string;
5540
+ redacted?: boolean;
5540
5541
  } | {
5541
5542
  addedToolNames?: string[];
5542
5543
  arguments: Record<string, any>;
5543
5544
  callID: string;
5544
5545
  name: string;
5545
5546
  namespace?: string;
5546
- result: {
5547
- content: ({
5547
+ partial?: {
5548
+ content?: ({
5548
5549
  type: "text";
5549
5550
  text: string;
5550
5551
  textSignature?: string;
@@ -5554,9 +5555,8 @@ declare const LLMStarted: Schema.Struct<{
5554
5555
  mimeType: string;
5555
5556
  })[];
5556
5557
  details?: any;
5557
- isError: true;
5558
5558
  };
5559
- status: "aborted";
5559
+ status: "running";
5560
5560
  thoughtSignature?: string;
5561
5561
  time: {
5562
5562
  start: number;
@@ -5731,19 +5731,14 @@ declare const LLMStarted: Schema.Struct<{
5731
5731
  type: "image";
5732
5732
  data: string;
5733
5733
  mimeType: string;
5734
- } | {
5735
- type: "thinking";
5736
- thinking: string;
5737
- thinkingSignature?: string;
5738
- redacted?: boolean;
5739
5734
  } | {
5740
5735
  addedToolNames?: string[];
5741
5736
  arguments: Record<string, any>;
5742
5737
  callID: string;
5743
5738
  name: string;
5744
5739
  namespace?: string;
5745
- partial?: {
5746
- content?: ({
5740
+ result: {
5741
+ content: ({
5747
5742
  type: "text";
5748
5743
  text: string;
5749
5744
  textSignature?: string;
@@ -5753,8 +5748,9 @@ declare const LLMStarted: Schema.Struct<{
5753
5748
  mimeType: string;
5754
5749
  })[];
5755
5750
  details?: any;
5751
+ isError: false;
5756
5752
  };
5757
- status: "running";
5753
+ status: "completed";
5758
5754
  thoughtSignature?: string;
5759
5755
  time: {
5760
5756
  start: number;
@@ -5778,9 +5774,9 @@ declare const LLMStarted: Schema.Struct<{
5778
5774
  mimeType: string;
5779
5775
  })[];
5780
5776
  details?: any;
5781
- isError: false;
5777
+ isError: true;
5782
5778
  };
5783
- status: "completed";
5779
+ status: "error";
5784
5780
  thoughtSignature?: string;
5785
5781
  time: {
5786
5782
  start: number;
@@ -5806,7 +5802,7 @@ declare const LLMStarted: Schema.Struct<{
5806
5802
  details?: any;
5807
5803
  isError: true;
5808
5804
  };
5809
- status: "error";
5805
+ status: "skipped";
5810
5806
  thoughtSignature?: string;
5811
5807
  time: {
5812
5808
  start: number;
@@ -5832,21 +5828,26 @@ declare const LLMStarted: Schema.Struct<{
5832
5828
  details?: any;
5833
5829
  isError: true;
5834
5830
  };
5835
- status: "skipped";
5831
+ status: "aborted";
5836
5832
  thoughtSignature?: string;
5837
5833
  time: {
5838
5834
  start: number;
5839
5835
  end: number;
5840
5836
  };
5841
5837
  type: "toolCall";
5838
+ } | {
5839
+ type: "thinking";
5840
+ thinking: string;
5841
+ thinkingSignature?: string;
5842
+ redacted?: boolean;
5842
5843
  } | {
5843
5844
  addedToolNames?: string[];
5844
5845
  arguments: Record<string, any>;
5845
5846
  callID: string;
5846
5847
  name: string;
5847
5848
  namespace?: string;
5848
- result: {
5849
- content: ({
5849
+ partial?: {
5850
+ content?: ({
5850
5851
  type: "text";
5851
5852
  text: string;
5852
5853
  textSignature?: string;
@@ -5856,9 +5857,8 @@ declare const LLMStarted: Schema.Struct<{
5856
5857
  mimeType: string;
5857
5858
  })[];
5858
5859
  details?: any;
5859
- isError: true;
5860
5860
  };
5861
- status: "aborted";
5861
+ status: "running";
5862
5862
  thoughtSignature?: string;
5863
5863
  time: {
5864
5864
  start: number;
@@ -6354,19 +6354,14 @@ declare const LLMEnded: Schema.Struct<{
6354
6354
  type: "image";
6355
6355
  data: string;
6356
6356
  mimeType: string;
6357
- } | {
6358
- type: "thinking";
6359
- thinking: string;
6360
- thinkingSignature?: string;
6361
- redacted?: boolean;
6362
6357
  } | {
6363
6358
  addedToolNames?: string[];
6364
6359
  arguments: Record<string, any>;
6365
6360
  callID: string;
6366
6361
  name: string;
6367
6362
  namespace?: string;
6368
- partial?: {
6369
- content?: ({
6363
+ result: {
6364
+ content: ({
6370
6365
  type: "text";
6371
6366
  text: string;
6372
6367
  textSignature?: string;
@@ -6376,8 +6371,9 @@ declare const LLMEnded: Schema.Struct<{
6376
6371
  mimeType: string;
6377
6372
  })[];
6378
6373
  details?: any;
6374
+ isError: false;
6379
6375
  };
6380
- status: "running";
6376
+ status: "completed";
6381
6377
  thoughtSignature?: string;
6382
6378
  time: {
6383
6379
  start: number;
@@ -6401,9 +6397,9 @@ declare const LLMEnded: Schema.Struct<{
6401
6397
  mimeType: string;
6402
6398
  })[];
6403
6399
  details?: any;
6404
- isError: false;
6400
+ isError: true;
6405
6401
  };
6406
- status: "completed";
6402
+ status: "error";
6407
6403
  thoughtSignature?: string;
6408
6404
  time: {
6409
6405
  start: number;
@@ -6429,7 +6425,7 @@ declare const LLMEnded: Schema.Struct<{
6429
6425
  details?: any;
6430
6426
  isError: true;
6431
6427
  };
6432
- status: "error";
6428
+ status: "skipped";
6433
6429
  thoughtSignature?: string;
6434
6430
  time: {
6435
6431
  start: number;
@@ -6455,7 +6451,7 @@ declare const LLMEnded: Schema.Struct<{
6455
6451
  details?: any;
6456
6452
  isError: true;
6457
6453
  };
6458
- status: "skipped";
6454
+ status: "aborted";
6459
6455
  thoughtSignature?: string;
6460
6456
  time: {
6461
6457
  start: number;
@@ -6463,13 +6459,18 @@ declare const LLMEnded: Schema.Struct<{
6463
6459
  };
6464
6460
  type: "toolCall";
6465
6461
  } | {
6466
- addedToolNames?: string[];
6467
- arguments: Record<string, any>;
6468
- callID: string;
6469
- name: string;
6462
+ type: "thinking";
6463
+ thinking: string;
6464
+ thinkingSignature?: string;
6465
+ redacted?: boolean;
6466
+ } | {
6467
+ addedToolNames?: string[];
6468
+ arguments: Record<string, any>;
6469
+ callID: string;
6470
+ name: string;
6470
6471
  namespace?: string;
6471
- result: {
6472
- content: ({
6472
+ partial?: {
6473
+ content?: ({
6473
6474
  type: "text";
6474
6475
  text: string;
6475
6476
  textSignature?: string;
@@ -6479,9 +6480,8 @@ declare const LLMEnded: Schema.Struct<{
6479
6480
  mimeType: string;
6480
6481
  })[];
6481
6482
  details?: any;
6482
- isError: true;
6483
6483
  };
6484
- status: "aborted";
6484
+ status: "running";
6485
6485
  thoughtSignature?: string;
6486
6486
  time: {
6487
6487
  start: number;
@@ -6656,19 +6656,14 @@ declare const LLMEnded: Schema.Struct<{
6656
6656
  type: "image";
6657
6657
  data: string;
6658
6658
  mimeType: string;
6659
- } | {
6660
- type: "thinking";
6661
- thinking: string;
6662
- thinkingSignature?: string;
6663
- redacted?: boolean;
6664
6659
  } | {
6665
6660
  addedToolNames?: string[];
6666
6661
  arguments: Record<string, any>;
6667
6662
  callID: string;
6668
6663
  name: string;
6669
6664
  namespace?: string;
6670
- partial?: {
6671
- content?: ({
6665
+ result: {
6666
+ content: ({
6672
6667
  type: "text";
6673
6668
  text: string;
6674
6669
  textSignature?: string;
@@ -6678,8 +6673,9 @@ declare const LLMEnded: Schema.Struct<{
6678
6673
  mimeType: string;
6679
6674
  })[];
6680
6675
  details?: any;
6676
+ isError: false;
6681
6677
  };
6682
- status: "running";
6678
+ status: "completed";
6683
6679
  thoughtSignature?: string;
6684
6680
  time: {
6685
6681
  start: number;
@@ -6703,9 +6699,9 @@ declare const LLMEnded: Schema.Struct<{
6703
6699
  mimeType: string;
6704
6700
  })[];
6705
6701
  details?: any;
6706
- isError: false;
6702
+ isError: true;
6707
6703
  };
6708
- status: "completed";
6704
+ status: "error";
6709
6705
  thoughtSignature?: string;
6710
6706
  time: {
6711
6707
  start: number;
@@ -6731,7 +6727,7 @@ declare const LLMEnded: Schema.Struct<{
6731
6727
  details?: any;
6732
6728
  isError: true;
6733
6729
  };
6734
- status: "error";
6730
+ status: "skipped";
6735
6731
  thoughtSignature?: string;
6736
6732
  time: {
6737
6733
  start: number;
@@ -6757,21 +6753,26 @@ declare const LLMEnded: Schema.Struct<{
6757
6753
  details?: any;
6758
6754
  isError: true;
6759
6755
  };
6760
- status: "skipped";
6756
+ status: "aborted";
6761
6757
  thoughtSignature?: string;
6762
6758
  time: {
6763
6759
  start: number;
6764
6760
  end: number;
6765
6761
  };
6766
6762
  type: "toolCall";
6763
+ } | {
6764
+ type: "thinking";
6765
+ thinking: string;
6766
+ thinkingSignature?: string;
6767
+ redacted?: boolean;
6767
6768
  } | {
6768
6769
  addedToolNames?: string[];
6769
6770
  arguments: Record<string, any>;
6770
6771
  callID: string;
6771
6772
  name: string;
6772
6773
  namespace?: string;
6773
- result: {
6774
- content: ({
6774
+ partial?: {
6775
+ content?: ({
6775
6776
  type: "text";
6776
6777
  text: string;
6777
6778
  textSignature?: string;
@@ -6781,9 +6782,8 @@ declare const LLMEnded: Schema.Struct<{
6781
6782
  mimeType: string;
6782
6783
  })[];
6783
6784
  details?: any;
6784
- isError: true;
6785
6785
  };
6786
- status: "aborted";
6786
+ status: "running";
6787
6787
  thoughtSignature?: string;
6788
6788
  time: {
6789
6789
  start: number;
@@ -6977,19 +6977,14 @@ declare const LLMEnded: Schema.Struct<{
6977
6977
  type: "image";
6978
6978
  data: string;
6979
6979
  mimeType: string;
6980
- } | {
6981
- type: "thinking";
6982
- thinking: string;
6983
- thinkingSignature?: string;
6984
- redacted?: boolean;
6985
6980
  } | {
6986
6981
  addedToolNames?: string[];
6987
6982
  arguments: Record<string, any>;
6988
6983
  callID: string;
6989
6984
  name: string;
6990
6985
  namespace?: string;
6991
- partial?: {
6992
- content?: ({
6986
+ result: {
6987
+ content: ({
6993
6988
  type: "text";
6994
6989
  text: string;
6995
6990
  textSignature?: string;
@@ -6999,8 +6994,9 @@ declare const LLMEnded: Schema.Struct<{
6999
6994
  mimeType: string;
7000
6995
  })[];
7001
6996
  details?: any;
6997
+ isError: false;
7002
6998
  };
7003
- status: "running";
6999
+ status: "completed";
7004
7000
  thoughtSignature?: string;
7005
7001
  time: {
7006
7002
  start: number;
@@ -7024,9 +7020,9 @@ declare const LLMEnded: Schema.Struct<{
7024
7020
  mimeType: string;
7025
7021
  })[];
7026
7022
  details?: any;
7027
- isError: false;
7023
+ isError: true;
7028
7024
  };
7029
- status: "completed";
7025
+ status: "error";
7030
7026
  thoughtSignature?: string;
7031
7027
  time: {
7032
7028
  start: number;
@@ -7052,7 +7048,7 @@ declare const LLMEnded: Schema.Struct<{
7052
7048
  details?: any;
7053
7049
  isError: true;
7054
7050
  };
7055
- status: "error";
7051
+ status: "skipped";
7056
7052
  thoughtSignature?: string;
7057
7053
  time: {
7058
7054
  start: number;
@@ -7078,21 +7074,26 @@ declare const LLMEnded: Schema.Struct<{
7078
7074
  details?: any;
7079
7075
  isError: true;
7080
7076
  };
7081
- status: "skipped";
7077
+ status: "aborted";
7082
7078
  thoughtSignature?: string;
7083
7079
  time: {
7084
7080
  start: number;
7085
7081
  end: number;
7086
7082
  };
7087
7083
  type: "toolCall";
7084
+ } | {
7085
+ type: "thinking";
7086
+ thinking: string;
7087
+ thinkingSignature?: string;
7088
+ redacted?: boolean;
7088
7089
  } | {
7089
7090
  addedToolNames?: string[];
7090
7091
  arguments: Record<string, any>;
7091
7092
  callID: string;
7092
7093
  name: string;
7093
7094
  namespace?: string;
7094
- result: {
7095
- content: ({
7095
+ partial?: {
7096
+ content?: ({
7096
7097
  type: "text";
7097
7098
  text: string;
7098
7099
  textSignature?: string;
@@ -7102,9 +7103,8 @@ declare const LLMEnded: Schema.Struct<{
7102
7103
  mimeType: string;
7103
7104
  })[];
7104
7105
  details?: any;
7105
- isError: true;
7106
7106
  };
7107
- status: "aborted";
7107
+ status: "running";
7108
7108
  thoughtSignature?: string;
7109
7109
  time: {
7110
7110
  start: number;
@@ -7279,19 +7279,14 @@ declare const LLMEnded: Schema.Struct<{
7279
7279
  type: "image";
7280
7280
  data: string;
7281
7281
  mimeType: string;
7282
- } | {
7283
- type: "thinking";
7284
- thinking: string;
7285
- thinkingSignature?: string;
7286
- redacted?: boolean;
7287
7282
  } | {
7288
7283
  addedToolNames?: string[];
7289
7284
  arguments: Record<string, any>;
7290
7285
  callID: string;
7291
7286
  name: string;
7292
7287
  namespace?: string;
7293
- partial?: {
7294
- content?: ({
7288
+ result: {
7289
+ content: ({
7295
7290
  type: "text";
7296
7291
  text: string;
7297
7292
  textSignature?: string;
@@ -7301,8 +7296,9 @@ declare const LLMEnded: Schema.Struct<{
7301
7296
  mimeType: string;
7302
7297
  })[];
7303
7298
  details?: any;
7299
+ isError: false;
7304
7300
  };
7305
- status: "running";
7301
+ status: "completed";
7306
7302
  thoughtSignature?: string;
7307
7303
  time: {
7308
7304
  start: number;
@@ -7326,9 +7322,9 @@ declare const LLMEnded: Schema.Struct<{
7326
7322
  mimeType: string;
7327
7323
  })[];
7328
7324
  details?: any;
7329
- isError: false;
7325
+ isError: true;
7330
7326
  };
7331
- status: "completed";
7327
+ status: "error";
7332
7328
  thoughtSignature?: string;
7333
7329
  time: {
7334
7330
  start: number;
@@ -7354,7 +7350,7 @@ declare const LLMEnded: Schema.Struct<{
7354
7350
  details?: any;
7355
7351
  isError: true;
7356
7352
  };
7357
- status: "error";
7353
+ status: "skipped";
7358
7354
  thoughtSignature?: string;
7359
7355
  time: {
7360
7356
  start: number;
@@ -7380,21 +7376,26 @@ declare const LLMEnded: Schema.Struct<{
7380
7376
  details?: any;
7381
7377
  isError: true;
7382
7378
  };
7383
- status: "skipped";
7379
+ status: "aborted";
7384
7380
  thoughtSignature?: string;
7385
7381
  time: {
7386
7382
  start: number;
7387
7383
  end: number;
7388
7384
  };
7389
7385
  type: "toolCall";
7386
+ } | {
7387
+ type: "thinking";
7388
+ thinking: string;
7389
+ thinkingSignature?: string;
7390
+ redacted?: boolean;
7390
7391
  } | {
7391
7392
  addedToolNames?: string[];
7392
7393
  arguments: Record<string, any>;
7393
7394
  callID: string;
7394
7395
  name: string;
7395
7396
  namespace?: string;
7396
- result: {
7397
- content: ({
7397
+ partial?: {
7398
+ content?: ({
7398
7399
  type: "text";
7399
7400
  text: string;
7400
7401
  textSignature?: string;
@@ -7404,9 +7405,8 @@ declare const LLMEnded: Schema.Struct<{
7404
7405
  mimeType: string;
7405
7406
  })[];
7406
7407
  details?: any;
7407
- isError: true;
7408
7408
  };
7409
- status: "aborted";
7409
+ status: "running";
7410
7410
  thoughtSignature?: string;
7411
7411
  time: {
7412
7412
  start: number;
@@ -7612,19 +7612,14 @@ declare const LLMFailed: Schema.Struct<{
7612
7612
  type: "image";
7613
7613
  data: string;
7614
7614
  mimeType: string;
7615
- } | {
7616
- type: "thinking";
7617
- thinking: string;
7618
- thinkingSignature?: string;
7619
- redacted?: boolean;
7620
7615
  } | {
7621
7616
  addedToolNames?: string[];
7622
7617
  arguments: Record<string, any>;
7623
7618
  callID: string;
7624
7619
  name: string;
7625
7620
  namespace?: string;
7626
- partial?: {
7627
- content?: ({
7621
+ result: {
7622
+ content: ({
7628
7623
  type: "text";
7629
7624
  text: string;
7630
7625
  textSignature?: string;
@@ -7634,8 +7629,9 @@ declare const LLMFailed: Schema.Struct<{
7634
7629
  mimeType: string;
7635
7630
  })[];
7636
7631
  details?: any;
7632
+ isError: false;
7637
7633
  };
7638
- status: "running";
7634
+ status: "completed";
7639
7635
  thoughtSignature?: string;
7640
7636
  time: {
7641
7637
  start: number;
@@ -7659,9 +7655,9 @@ declare const LLMFailed: Schema.Struct<{
7659
7655
  mimeType: string;
7660
7656
  })[];
7661
7657
  details?: any;
7662
- isError: false;
7658
+ isError: true;
7663
7659
  };
7664
- status: "completed";
7660
+ status: "error";
7665
7661
  thoughtSignature?: string;
7666
7662
  time: {
7667
7663
  start: number;
@@ -7687,7 +7683,7 @@ declare const LLMFailed: Schema.Struct<{
7687
7683
  details?: any;
7688
7684
  isError: true;
7689
7685
  };
7690
- status: "error";
7686
+ status: "skipped";
7691
7687
  thoughtSignature?: string;
7692
7688
  time: {
7693
7689
  start: number;
@@ -7713,21 +7709,26 @@ declare const LLMFailed: Schema.Struct<{
7713
7709
  details?: any;
7714
7710
  isError: true;
7715
7711
  };
7716
- status: "skipped";
7712
+ status: "aborted";
7717
7713
  thoughtSignature?: string;
7718
7714
  time: {
7719
7715
  start: number;
7720
7716
  end: number;
7721
7717
  };
7722
7718
  type: "toolCall";
7719
+ } | {
7720
+ type: "thinking";
7721
+ thinking: string;
7722
+ thinkingSignature?: string;
7723
+ redacted?: boolean;
7723
7724
  } | {
7724
7725
  addedToolNames?: string[];
7725
7726
  arguments: Record<string, any>;
7726
7727
  callID: string;
7727
7728
  name: string;
7728
7729
  namespace?: string;
7729
- result: {
7730
- content: ({
7730
+ partial?: {
7731
+ content?: ({
7731
7732
  type: "text";
7732
7733
  text: string;
7733
7734
  textSignature?: string;
@@ -7737,9 +7738,8 @@ declare const LLMFailed: Schema.Struct<{
7737
7738
  mimeType: string;
7738
7739
  })[];
7739
7740
  details?: any;
7740
- isError: true;
7741
7741
  };
7742
- status: "aborted";
7742
+ status: "running";
7743
7743
  thoughtSignature?: string;
7744
7744
  time: {
7745
7745
  start: number;
@@ -7914,19 +7914,14 @@ declare const LLMFailed: Schema.Struct<{
7914
7914
  type: "image";
7915
7915
  data: string;
7916
7916
  mimeType: string;
7917
- } | {
7918
- type: "thinking";
7919
- thinking: string;
7920
- thinkingSignature?: string;
7921
- redacted?: boolean;
7922
7917
  } | {
7923
7918
  addedToolNames?: string[];
7924
7919
  arguments: Record<string, any>;
7925
7920
  callID: string;
7926
7921
  name: string;
7927
7922
  namespace?: string;
7928
- partial?: {
7929
- content?: ({
7923
+ result: {
7924
+ content: ({
7930
7925
  type: "text";
7931
7926
  text: string;
7932
7927
  textSignature?: string;
@@ -7936,8 +7931,9 @@ declare const LLMFailed: Schema.Struct<{
7936
7931
  mimeType: string;
7937
7932
  })[];
7938
7933
  details?: any;
7934
+ isError: false;
7939
7935
  };
7940
- status: "running";
7936
+ status: "completed";
7941
7937
  thoughtSignature?: string;
7942
7938
  time: {
7943
7939
  start: number;
@@ -7961,9 +7957,9 @@ declare const LLMFailed: Schema.Struct<{
7961
7957
  mimeType: string;
7962
7958
  })[];
7963
7959
  details?: any;
7964
- isError: false;
7960
+ isError: true;
7965
7961
  };
7966
- status: "completed";
7962
+ status: "error";
7967
7963
  thoughtSignature?: string;
7968
7964
  time: {
7969
7965
  start: number;
@@ -7989,7 +7985,7 @@ declare const LLMFailed: Schema.Struct<{
7989
7985
  details?: any;
7990
7986
  isError: true;
7991
7987
  };
7992
- status: "error";
7988
+ status: "skipped";
7993
7989
  thoughtSignature?: string;
7994
7990
  time: {
7995
7991
  start: number;
@@ -8015,21 +8011,26 @@ declare const LLMFailed: Schema.Struct<{
8015
8011
  details?: any;
8016
8012
  isError: true;
8017
8013
  };
8018
- status: "skipped";
8014
+ status: "aborted";
8019
8015
  thoughtSignature?: string;
8020
8016
  time: {
8021
8017
  start: number;
8022
8018
  end: number;
8023
8019
  };
8024
8020
  type: "toolCall";
8021
+ } | {
8022
+ type: "thinking";
8023
+ thinking: string;
8024
+ thinkingSignature?: string;
8025
+ redacted?: boolean;
8025
8026
  } | {
8026
8027
  addedToolNames?: string[];
8027
8028
  arguments: Record<string, any>;
8028
8029
  callID: string;
8029
8030
  name: string;
8030
8031
  namespace?: string;
8031
- result: {
8032
- content: ({
8032
+ partial?: {
8033
+ content?: ({
8033
8034
  type: "text";
8034
8035
  text: string;
8035
8036
  textSignature?: string;
@@ -8039,9 +8040,8 @@ declare const LLMFailed: Schema.Struct<{
8039
8040
  mimeType: string;
8040
8041
  })[];
8041
8042
  details?: any;
8042
- isError: true;
8043
8043
  };
8044
- status: "aborted";
8044
+ status: "running";
8045
8045
  thoughtSignature?: string;
8046
8046
  time: {
8047
8047
  start: number;
@@ -8235,19 +8235,14 @@ declare const LLMFailed: Schema.Struct<{
8235
8235
  type: "image";
8236
8236
  data: string;
8237
8237
  mimeType: string;
8238
- } | {
8239
- type: "thinking";
8240
- thinking: string;
8241
- thinkingSignature?: string;
8242
- redacted?: boolean;
8243
8238
  } | {
8244
8239
  addedToolNames?: string[];
8245
8240
  arguments: Record<string, any>;
8246
8241
  callID: string;
8247
8242
  name: string;
8248
8243
  namespace?: string;
8249
- partial?: {
8250
- content?: ({
8244
+ result: {
8245
+ content: ({
8251
8246
  type: "text";
8252
8247
  text: string;
8253
8248
  textSignature?: string;
@@ -8257,8 +8252,9 @@ declare const LLMFailed: Schema.Struct<{
8257
8252
  mimeType: string;
8258
8253
  })[];
8259
8254
  details?: any;
8255
+ isError: false;
8260
8256
  };
8261
- status: "running";
8257
+ status: "completed";
8262
8258
  thoughtSignature?: string;
8263
8259
  time: {
8264
8260
  start: number;
@@ -8282,9 +8278,9 @@ declare const LLMFailed: Schema.Struct<{
8282
8278
  mimeType: string;
8283
8279
  })[];
8284
8280
  details?: any;
8285
- isError: false;
8281
+ isError: true;
8286
8282
  };
8287
- status: "completed";
8283
+ status: "error";
8288
8284
  thoughtSignature?: string;
8289
8285
  time: {
8290
8286
  start: number;
@@ -8310,7 +8306,7 @@ declare const LLMFailed: Schema.Struct<{
8310
8306
  details?: any;
8311
8307
  isError: true;
8312
8308
  };
8313
- status: "error";
8309
+ status: "skipped";
8314
8310
  thoughtSignature?: string;
8315
8311
  time: {
8316
8312
  start: number;
@@ -8336,21 +8332,26 @@ declare const LLMFailed: Schema.Struct<{
8336
8332
  details?: any;
8337
8333
  isError: true;
8338
8334
  };
8339
- status: "skipped";
8335
+ status: "aborted";
8340
8336
  thoughtSignature?: string;
8341
8337
  time: {
8342
8338
  start: number;
8343
8339
  end: number;
8344
8340
  };
8345
8341
  type: "toolCall";
8342
+ } | {
8343
+ type: "thinking";
8344
+ thinking: string;
8345
+ thinkingSignature?: string;
8346
+ redacted?: boolean;
8346
8347
  } | {
8347
8348
  addedToolNames?: string[];
8348
8349
  arguments: Record<string, any>;
8349
8350
  callID: string;
8350
8351
  name: string;
8351
8352
  namespace?: string;
8352
- result: {
8353
- content: ({
8353
+ partial?: {
8354
+ content?: ({
8354
8355
  type: "text";
8355
8356
  text: string;
8356
8357
  textSignature?: string;
@@ -8360,9 +8361,8 @@ declare const LLMFailed: Schema.Struct<{
8360
8361
  mimeType: string;
8361
8362
  })[];
8362
8363
  details?: any;
8363
- isError: true;
8364
8364
  };
8365
- status: "aborted";
8365
+ status: "running";
8366
8366
  thoughtSignature?: string;
8367
8367
  time: {
8368
8368
  start: number;
@@ -8537,19 +8537,14 @@ declare const LLMFailed: Schema.Struct<{
8537
8537
  type: "image";
8538
8538
  data: string;
8539
8539
  mimeType: string;
8540
- } | {
8541
- type: "thinking";
8542
- thinking: string;
8543
- thinkingSignature?: string;
8544
- redacted?: boolean;
8545
8540
  } | {
8546
8541
  addedToolNames?: string[];
8547
8542
  arguments: Record<string, any>;
8548
8543
  callID: string;
8549
8544
  name: string;
8550
8545
  namespace?: string;
8551
- partial?: {
8552
- content?: ({
8546
+ result: {
8547
+ content: ({
8553
8548
  type: "text";
8554
8549
  text: string;
8555
8550
  textSignature?: string;
@@ -8559,8 +8554,9 @@ declare const LLMFailed: Schema.Struct<{
8559
8554
  mimeType: string;
8560
8555
  })[];
8561
8556
  details?: any;
8557
+ isError: false;
8562
8558
  };
8563
- status: "running";
8559
+ status: "completed";
8564
8560
  thoughtSignature?: string;
8565
8561
  time: {
8566
8562
  start: number;
@@ -8584,9 +8580,9 @@ declare const LLMFailed: Schema.Struct<{
8584
8580
  mimeType: string;
8585
8581
  })[];
8586
8582
  details?: any;
8587
- isError: false;
8583
+ isError: true;
8588
8584
  };
8589
- status: "completed";
8585
+ status: "error";
8590
8586
  thoughtSignature?: string;
8591
8587
  time: {
8592
8588
  start: number;
@@ -8612,7 +8608,7 @@ declare const LLMFailed: Schema.Struct<{
8612
8608
  details?: any;
8613
8609
  isError: true;
8614
8610
  };
8615
- status: "error";
8611
+ status: "skipped";
8616
8612
  thoughtSignature?: string;
8617
8613
  time: {
8618
8614
  start: number;
@@ -8638,21 +8634,26 @@ declare const LLMFailed: Schema.Struct<{
8638
8634
  details?: any;
8639
8635
  isError: true;
8640
8636
  };
8641
- status: "skipped";
8637
+ status: "aborted";
8642
8638
  thoughtSignature?: string;
8643
8639
  time: {
8644
8640
  start: number;
8645
8641
  end: number;
8646
8642
  };
8647
8643
  type: "toolCall";
8644
+ } | {
8645
+ type: "thinking";
8646
+ thinking: string;
8647
+ thinkingSignature?: string;
8648
+ redacted?: boolean;
8648
8649
  } | {
8649
8650
  addedToolNames?: string[];
8650
8651
  arguments: Record<string, any>;
8651
8652
  callID: string;
8652
8653
  name: string;
8653
8654
  namespace?: string;
8654
- result: {
8655
- content: ({
8655
+ partial?: {
8656
+ content?: ({
8656
8657
  type: "text";
8657
8658
  text: string;
8658
8659
  textSignature?: string;
@@ -8662,9 +8663,8 @@ declare const LLMFailed: Schema.Struct<{
8662
8663
  mimeType: string;
8663
8664
  })[];
8664
8665
  details?: any;
8665
- isError: true;
8666
8666
  };
8667
- status: "aborted";
8667
+ status: "running";
8668
8668
  thoughtSignature?: string;
8669
8669
  time: {
8670
8670
  start: number;
@@ -10412,19 +10412,14 @@ declare const Definitions: readonly [Schema.Struct<{
10412
10412
  type: "image";
10413
10413
  data: string;
10414
10414
  mimeType: string;
10415
- } | {
10416
- type: "thinking";
10417
- thinking: string;
10418
- thinkingSignature?: string;
10419
- redacted?: boolean;
10420
10415
  } | {
10421
10416
  addedToolNames?: string[];
10422
10417
  arguments: Record<string, any>;
10423
10418
  callID: string;
10424
10419
  name: string;
10425
10420
  namespace?: string;
10426
- partial?: {
10427
- content?: ({
10421
+ result: {
10422
+ content: ({
10428
10423
  type: "text";
10429
10424
  text: string;
10430
10425
  textSignature?: string;
@@ -10434,8 +10429,9 @@ declare const Definitions: readonly [Schema.Struct<{
10434
10429
  mimeType: string;
10435
10430
  })[];
10436
10431
  details?: any;
10432
+ isError: false;
10437
10433
  };
10438
- status: "running";
10434
+ status: "completed";
10439
10435
  thoughtSignature?: string;
10440
10436
  time: {
10441
10437
  start: number;
@@ -10459,9 +10455,9 @@ declare const Definitions: readonly [Schema.Struct<{
10459
10455
  mimeType: string;
10460
10456
  })[];
10461
10457
  details?: any;
10462
- isError: false;
10458
+ isError: true;
10463
10459
  };
10464
- status: "completed";
10460
+ status: "error";
10465
10461
  thoughtSignature?: string;
10466
10462
  time: {
10467
10463
  start: number;
@@ -10487,7 +10483,7 @@ declare const Definitions: readonly [Schema.Struct<{
10487
10483
  details?: any;
10488
10484
  isError: true;
10489
10485
  };
10490
- status: "error";
10486
+ status: "skipped";
10491
10487
  thoughtSignature?: string;
10492
10488
  time: {
10493
10489
  start: number;
@@ -10513,21 +10509,26 @@ declare const Definitions: readonly [Schema.Struct<{
10513
10509
  details?: any;
10514
10510
  isError: true;
10515
10511
  };
10516
- status: "skipped";
10512
+ status: "aborted";
10517
10513
  thoughtSignature?: string;
10518
10514
  time: {
10519
10515
  start: number;
10520
10516
  end: number;
10521
10517
  };
10522
10518
  type: "toolCall";
10519
+ } | {
10520
+ type: "thinking";
10521
+ thinking: string;
10522
+ thinkingSignature?: string;
10523
+ redacted?: boolean;
10523
10524
  } | {
10524
10525
  addedToolNames?: string[];
10525
10526
  arguments: Record<string, any>;
10526
10527
  callID: string;
10527
10528
  name: string;
10528
10529
  namespace?: string;
10529
- result: {
10530
- content: ({
10530
+ partial?: {
10531
+ content?: ({
10531
10532
  type: "text";
10532
10533
  text: string;
10533
10534
  textSignature?: string;
@@ -10537,9 +10538,8 @@ declare const Definitions: readonly [Schema.Struct<{
10537
10538
  mimeType: string;
10538
10539
  })[];
10539
10540
  details?: any;
10540
- isError: true;
10541
10541
  };
10542
- status: "aborted";
10542
+ status: "running";
10543
10543
  thoughtSignature?: string;
10544
10544
  time: {
10545
10545
  start: number;
@@ -10714,19 +10714,14 @@ declare const Definitions: readonly [Schema.Struct<{
10714
10714
  type: "image";
10715
10715
  data: string;
10716
10716
  mimeType: string;
10717
- } | {
10718
- type: "thinking";
10719
- thinking: string;
10720
- thinkingSignature?: string;
10721
- redacted?: boolean;
10722
10717
  } | {
10723
10718
  addedToolNames?: string[];
10724
10719
  arguments: Record<string, any>;
10725
10720
  callID: string;
10726
10721
  name: string;
10727
10722
  namespace?: string;
10728
- partial?: {
10729
- content?: ({
10723
+ result: {
10724
+ content: ({
10730
10725
  type: "text";
10731
10726
  text: string;
10732
10727
  textSignature?: string;
@@ -10736,8 +10731,9 @@ declare const Definitions: readonly [Schema.Struct<{
10736
10731
  mimeType: string;
10737
10732
  })[];
10738
10733
  details?: any;
10734
+ isError: false;
10739
10735
  };
10740
- status: "running";
10736
+ status: "completed";
10741
10737
  thoughtSignature?: string;
10742
10738
  time: {
10743
10739
  start: number;
@@ -10761,9 +10757,9 @@ declare const Definitions: readonly [Schema.Struct<{
10761
10757
  mimeType: string;
10762
10758
  })[];
10763
10759
  details?: any;
10764
- isError: false;
10760
+ isError: true;
10765
10761
  };
10766
- status: "completed";
10762
+ status: "error";
10767
10763
  thoughtSignature?: string;
10768
10764
  time: {
10769
10765
  start: number;
@@ -10789,7 +10785,7 @@ declare const Definitions: readonly [Schema.Struct<{
10789
10785
  details?: any;
10790
10786
  isError: true;
10791
10787
  };
10792
- status: "error";
10788
+ status: "skipped";
10793
10789
  thoughtSignature?: string;
10794
10790
  time: {
10795
10791
  start: number;
@@ -10815,21 +10811,26 @@ declare const Definitions: readonly [Schema.Struct<{
10815
10811
  details?: any;
10816
10812
  isError: true;
10817
10813
  };
10818
- status: "skipped";
10814
+ status: "aborted";
10819
10815
  thoughtSignature?: string;
10820
10816
  time: {
10821
10817
  start: number;
10822
10818
  end: number;
10823
10819
  };
10824
10820
  type: "toolCall";
10821
+ } | {
10822
+ type: "thinking";
10823
+ thinking: string;
10824
+ thinkingSignature?: string;
10825
+ redacted?: boolean;
10825
10826
  } | {
10826
10827
  addedToolNames?: string[];
10827
10828
  arguments: Record<string, any>;
10828
10829
  callID: string;
10829
10830
  name: string;
10830
10831
  namespace?: string;
10831
- result: {
10832
- content: ({
10832
+ partial?: {
10833
+ content?: ({
10833
10834
  type: "text";
10834
10835
  text: string;
10835
10836
  textSignature?: string;
@@ -10839,9 +10840,8 @@ declare const Definitions: readonly [Schema.Struct<{
10839
10840
  mimeType: string;
10840
10841
  })[];
10841
10842
  details?: any;
10842
- isError: true;
10843
10843
  };
10844
- status: "aborted";
10844
+ status: "running";
10845
10845
  thoughtSignature?: string;
10846
10846
  time: {
10847
10847
  start: number;
@@ -11034,19 +11034,14 @@ declare const Definitions: readonly [Schema.Struct<{
11034
11034
  type: "image";
11035
11035
  data: string;
11036
11036
  mimeType: string;
11037
- } | {
11038
- type: "thinking";
11039
- thinking: string;
11040
- thinkingSignature?: string;
11041
- redacted?: boolean;
11042
11037
  } | {
11043
11038
  addedToolNames?: string[];
11044
11039
  arguments: Record<string, any>;
11045
11040
  callID: string;
11046
11041
  name: string;
11047
11042
  namespace?: string;
11048
- partial?: {
11049
- content?: ({
11043
+ result: {
11044
+ content: ({
11050
11045
  type: "text";
11051
11046
  text: string;
11052
11047
  textSignature?: string;
@@ -11056,8 +11051,9 @@ declare const Definitions: readonly [Schema.Struct<{
11056
11051
  mimeType: string;
11057
11052
  })[];
11058
11053
  details?: any;
11054
+ isError: false;
11059
11055
  };
11060
- status: "running";
11056
+ status: "completed";
11061
11057
  thoughtSignature?: string;
11062
11058
  time: {
11063
11059
  start: number;
@@ -11081,9 +11077,9 @@ declare const Definitions: readonly [Schema.Struct<{
11081
11077
  mimeType: string;
11082
11078
  })[];
11083
11079
  details?: any;
11084
- isError: false;
11080
+ isError: true;
11085
11081
  };
11086
- status: "completed";
11082
+ status: "error";
11087
11083
  thoughtSignature?: string;
11088
11084
  time: {
11089
11085
  start: number;
@@ -11109,7 +11105,7 @@ declare const Definitions: readonly [Schema.Struct<{
11109
11105
  details?: any;
11110
11106
  isError: true;
11111
11107
  };
11112
- status: "error";
11108
+ status: "skipped";
11113
11109
  thoughtSignature?: string;
11114
11110
  time: {
11115
11111
  start: number;
@@ -11135,21 +11131,26 @@ declare const Definitions: readonly [Schema.Struct<{
11135
11131
  details?: any;
11136
11132
  isError: true;
11137
11133
  };
11138
- status: "skipped";
11134
+ status: "aborted";
11139
11135
  thoughtSignature?: string;
11140
11136
  time: {
11141
11137
  start: number;
11142
11138
  end: number;
11143
11139
  };
11144
11140
  type: "toolCall";
11141
+ } | {
11142
+ type: "thinking";
11143
+ thinking: string;
11144
+ thinkingSignature?: string;
11145
+ redacted?: boolean;
11145
11146
  } | {
11146
11147
  addedToolNames?: string[];
11147
11148
  arguments: Record<string, any>;
11148
11149
  callID: string;
11149
11150
  name: string;
11150
11151
  namespace?: string;
11151
- result: {
11152
- content: ({
11152
+ partial?: {
11153
+ content?: ({
11153
11154
  type: "text";
11154
11155
  text: string;
11155
11156
  textSignature?: string;
@@ -11159,9 +11160,8 @@ declare const Definitions: readonly [Schema.Struct<{
11159
11160
  mimeType: string;
11160
11161
  })[];
11161
11162
  details?: any;
11162
- isError: true;
11163
11163
  };
11164
- status: "aborted";
11164
+ status: "running";
11165
11165
  thoughtSignature?: string;
11166
11166
  time: {
11167
11167
  start: number;
@@ -11336,19 +11336,14 @@ declare const Definitions: readonly [Schema.Struct<{
11336
11336
  type: "image";
11337
11337
  data: string;
11338
11338
  mimeType: string;
11339
- } | {
11340
- type: "thinking";
11341
- thinking: string;
11342
- thinkingSignature?: string;
11343
- redacted?: boolean;
11344
11339
  } | {
11345
11340
  addedToolNames?: string[];
11346
11341
  arguments: Record<string, any>;
11347
11342
  callID: string;
11348
11343
  name: string;
11349
11344
  namespace?: string;
11350
- partial?: {
11351
- content?: ({
11345
+ result: {
11346
+ content: ({
11352
11347
  type: "text";
11353
11348
  text: string;
11354
11349
  textSignature?: string;
@@ -11358,8 +11353,9 @@ declare const Definitions: readonly [Schema.Struct<{
11358
11353
  mimeType: string;
11359
11354
  })[];
11360
11355
  details?: any;
11356
+ isError: false;
11361
11357
  };
11362
- status: "running";
11358
+ status: "completed";
11363
11359
  thoughtSignature?: string;
11364
11360
  time: {
11365
11361
  start: number;
@@ -11383,9 +11379,9 @@ declare const Definitions: readonly [Schema.Struct<{
11383
11379
  mimeType: string;
11384
11380
  })[];
11385
11381
  details?: any;
11386
- isError: false;
11382
+ isError: true;
11387
11383
  };
11388
- status: "completed";
11384
+ status: "error";
11389
11385
  thoughtSignature?: string;
11390
11386
  time: {
11391
11387
  start: number;
@@ -11411,7 +11407,7 @@ declare const Definitions: readonly [Schema.Struct<{
11411
11407
  details?: any;
11412
11408
  isError: true;
11413
11409
  };
11414
- status: "error";
11410
+ status: "skipped";
11415
11411
  thoughtSignature?: string;
11416
11412
  time: {
11417
11413
  start: number;
@@ -11437,21 +11433,26 @@ declare const Definitions: readonly [Schema.Struct<{
11437
11433
  details?: any;
11438
11434
  isError: true;
11439
11435
  };
11440
- status: "skipped";
11436
+ status: "aborted";
11441
11437
  thoughtSignature?: string;
11442
11438
  time: {
11443
11439
  start: number;
11444
11440
  end: number;
11445
11441
  };
11446
11442
  type: "toolCall";
11443
+ } | {
11444
+ type: "thinking";
11445
+ thinking: string;
11446
+ thinkingSignature?: string;
11447
+ redacted?: boolean;
11447
11448
  } | {
11448
11449
  addedToolNames?: string[];
11449
11450
  arguments: Record<string, any>;
11450
11451
  callID: string;
11451
11452
  name: string;
11452
11453
  namespace?: string;
11453
- result: {
11454
- content: ({
11454
+ partial?: {
11455
+ content?: ({
11455
11456
  type: "text";
11456
11457
  text: string;
11457
11458
  textSignature?: string;
@@ -11461,9 +11462,8 @@ declare const Definitions: readonly [Schema.Struct<{
11461
11462
  mimeType: string;
11462
11463
  })[];
11463
11464
  details?: any;
11464
- isError: true;
11465
11465
  };
11466
- status: "aborted";
11466
+ status: "running";
11467
11467
  thoughtSignature?: string;
11468
11468
  time: {
11469
11469
  start: number;
@@ -11944,19 +11944,14 @@ declare const Definitions: readonly [Schema.Struct<{
11944
11944
  type: "image";
11945
11945
  data: string;
11946
11946
  mimeType: string;
11947
- } | {
11948
- type: "thinking";
11949
- thinking: string;
11950
- thinkingSignature?: string;
11951
- redacted?: boolean;
11952
11947
  } | {
11953
11948
  addedToolNames?: string[];
11954
11949
  arguments: Record<string, any>;
11955
11950
  callID: string;
11956
11951
  name: string;
11957
11952
  namespace?: string;
11958
- partial?: {
11959
- content?: ({
11953
+ result: {
11954
+ content: ({
11960
11955
  type: "text";
11961
11956
  text: string;
11962
11957
  textSignature?: string;
@@ -11966,8 +11961,9 @@ declare const Definitions: readonly [Schema.Struct<{
11966
11961
  mimeType: string;
11967
11962
  })[];
11968
11963
  details?: any;
11964
+ isError: false;
11969
11965
  };
11970
- status: "running";
11966
+ status: "completed";
11971
11967
  thoughtSignature?: string;
11972
11968
  time: {
11973
11969
  start: number;
@@ -11991,9 +11987,9 @@ declare const Definitions: readonly [Schema.Struct<{
11991
11987
  mimeType: string;
11992
11988
  })[];
11993
11989
  details?: any;
11994
- isError: false;
11990
+ isError: true;
11995
11991
  };
11996
- status: "completed";
11992
+ status: "error";
11997
11993
  thoughtSignature?: string;
11998
11994
  time: {
11999
11995
  start: number;
@@ -12019,7 +12015,7 @@ declare const Definitions: readonly [Schema.Struct<{
12019
12015
  details?: any;
12020
12016
  isError: true;
12021
12017
  };
12022
- status: "error";
12018
+ status: "skipped";
12023
12019
  thoughtSignature?: string;
12024
12020
  time: {
12025
12021
  start: number;
@@ -12045,21 +12041,26 @@ declare const Definitions: readonly [Schema.Struct<{
12045
12041
  details?: any;
12046
12042
  isError: true;
12047
12043
  };
12048
- status: "skipped";
12044
+ status: "aborted";
12049
12045
  thoughtSignature?: string;
12050
12046
  time: {
12051
12047
  start: number;
12052
12048
  end: number;
12053
12049
  };
12054
12050
  type: "toolCall";
12051
+ } | {
12052
+ type: "thinking";
12053
+ thinking: string;
12054
+ thinkingSignature?: string;
12055
+ redacted?: boolean;
12055
12056
  } | {
12056
12057
  addedToolNames?: string[];
12057
12058
  arguments: Record<string, any>;
12058
12059
  callID: string;
12059
12060
  name: string;
12060
12061
  namespace?: string;
12061
- result: {
12062
- content: ({
12062
+ partial?: {
12063
+ content?: ({
12063
12064
  type: "text";
12064
12065
  text: string;
12065
12066
  textSignature?: string;
@@ -12069,9 +12070,8 @@ declare const Definitions: readonly [Schema.Struct<{
12069
12070
  mimeType: string;
12070
12071
  })[];
12071
12072
  details?: any;
12072
- isError: true;
12073
12073
  };
12074
- status: "aborted";
12074
+ status: "running";
12075
12075
  thoughtSignature?: string;
12076
12076
  time: {
12077
12077
  start: number;
@@ -12246,19 +12246,14 @@ declare const Definitions: readonly [Schema.Struct<{
12246
12246
  type: "image";
12247
12247
  data: string;
12248
12248
  mimeType: string;
12249
- } | {
12250
- type: "thinking";
12251
- thinking: string;
12252
- thinkingSignature?: string;
12253
- redacted?: boolean;
12254
12249
  } | {
12255
12250
  addedToolNames?: string[];
12256
12251
  arguments: Record<string, any>;
12257
12252
  callID: string;
12258
12253
  name: string;
12259
12254
  namespace?: string;
12260
- partial?: {
12261
- content?: ({
12255
+ result: {
12256
+ content: ({
12262
12257
  type: "text";
12263
12258
  text: string;
12264
12259
  textSignature?: string;
@@ -12268,8 +12263,9 @@ declare const Definitions: readonly [Schema.Struct<{
12268
12263
  mimeType: string;
12269
12264
  })[];
12270
12265
  details?: any;
12266
+ isError: false;
12271
12267
  };
12272
- status: "running";
12268
+ status: "completed";
12273
12269
  thoughtSignature?: string;
12274
12270
  time: {
12275
12271
  start: number;
@@ -12293,9 +12289,9 @@ declare const Definitions: readonly [Schema.Struct<{
12293
12289
  mimeType: string;
12294
12290
  })[];
12295
12291
  details?: any;
12296
- isError: false;
12292
+ isError: true;
12297
12293
  };
12298
- status: "completed";
12294
+ status: "error";
12299
12295
  thoughtSignature?: string;
12300
12296
  time: {
12301
12297
  start: number;
@@ -12321,7 +12317,7 @@ declare const Definitions: readonly [Schema.Struct<{
12321
12317
  details?: any;
12322
12318
  isError: true;
12323
12319
  };
12324
- status: "error";
12320
+ status: "skipped";
12325
12321
  thoughtSignature?: string;
12326
12322
  time: {
12327
12323
  start: number;
@@ -12347,21 +12343,26 @@ declare const Definitions: readonly [Schema.Struct<{
12347
12343
  details?: any;
12348
12344
  isError: true;
12349
12345
  };
12350
- status: "skipped";
12346
+ status: "aborted";
12351
12347
  thoughtSignature?: string;
12352
12348
  time: {
12353
12349
  start: number;
12354
12350
  end: number;
12355
12351
  };
12356
12352
  type: "toolCall";
12353
+ } | {
12354
+ type: "thinking";
12355
+ thinking: string;
12356
+ thinkingSignature?: string;
12357
+ redacted?: boolean;
12357
12358
  } | {
12358
12359
  addedToolNames?: string[];
12359
12360
  arguments: Record<string, any>;
12360
12361
  callID: string;
12361
12362
  name: string;
12362
12363
  namespace?: string;
12363
- result: {
12364
- content: ({
12364
+ partial?: {
12365
+ content?: ({
12365
12366
  type: "text";
12366
12367
  text: string;
12367
12368
  textSignature?: string;
@@ -12371,9 +12372,8 @@ declare const Definitions: readonly [Schema.Struct<{
12371
12372
  mimeType: string;
12372
12373
  })[];
12373
12374
  details?: any;
12374
- isError: true;
12375
12375
  };
12376
- status: "aborted";
12376
+ status: "running";
12377
12377
  thoughtSignature?: string;
12378
12378
  time: {
12379
12379
  start: number;
@@ -12567,19 +12567,14 @@ declare const Definitions: readonly [Schema.Struct<{
12567
12567
  type: "image";
12568
12568
  data: string;
12569
12569
  mimeType: string;
12570
- } | {
12571
- type: "thinking";
12572
- thinking: string;
12573
- thinkingSignature?: string;
12574
- redacted?: boolean;
12575
12570
  } | {
12576
12571
  addedToolNames?: string[];
12577
12572
  arguments: Record<string, any>;
12578
12573
  callID: string;
12579
12574
  name: string;
12580
12575
  namespace?: string;
12581
- partial?: {
12582
- content?: ({
12576
+ result: {
12577
+ content: ({
12583
12578
  type: "text";
12584
12579
  text: string;
12585
12580
  textSignature?: string;
@@ -12589,8 +12584,9 @@ declare const Definitions: readonly [Schema.Struct<{
12589
12584
  mimeType: string;
12590
12585
  })[];
12591
12586
  details?: any;
12587
+ isError: false;
12592
12588
  };
12593
- status: "running";
12589
+ status: "completed";
12594
12590
  thoughtSignature?: string;
12595
12591
  time: {
12596
12592
  start: number;
@@ -12614,9 +12610,9 @@ declare const Definitions: readonly [Schema.Struct<{
12614
12610
  mimeType: string;
12615
12611
  })[];
12616
12612
  details?: any;
12617
- isError: false;
12613
+ isError: true;
12618
12614
  };
12619
- status: "completed";
12615
+ status: "error";
12620
12616
  thoughtSignature?: string;
12621
12617
  time: {
12622
12618
  start: number;
@@ -12642,7 +12638,7 @@ declare const Definitions: readonly [Schema.Struct<{
12642
12638
  details?: any;
12643
12639
  isError: true;
12644
12640
  };
12645
- status: "error";
12641
+ status: "skipped";
12646
12642
  thoughtSignature?: string;
12647
12643
  time: {
12648
12644
  start: number;
@@ -12668,21 +12664,26 @@ declare const Definitions: readonly [Schema.Struct<{
12668
12664
  details?: any;
12669
12665
  isError: true;
12670
12666
  };
12671
- status: "skipped";
12667
+ status: "aborted";
12672
12668
  thoughtSignature?: string;
12673
12669
  time: {
12674
12670
  start: number;
12675
12671
  end: number;
12676
12672
  };
12677
12673
  type: "toolCall";
12674
+ } | {
12675
+ type: "thinking";
12676
+ thinking: string;
12677
+ thinkingSignature?: string;
12678
+ redacted?: boolean;
12678
12679
  } | {
12679
12680
  addedToolNames?: string[];
12680
12681
  arguments: Record<string, any>;
12681
12682
  callID: string;
12682
12683
  name: string;
12683
12684
  namespace?: string;
12684
- result: {
12685
- content: ({
12685
+ partial?: {
12686
+ content?: ({
12686
12687
  type: "text";
12687
12688
  text: string;
12688
12689
  textSignature?: string;
@@ -12692,9 +12693,8 @@ declare const Definitions: readonly [Schema.Struct<{
12692
12693
  mimeType: string;
12693
12694
  })[];
12694
12695
  details?: any;
12695
- isError: true;
12696
12696
  };
12697
- status: "aborted";
12697
+ status: "running";
12698
12698
  thoughtSignature?: string;
12699
12699
  time: {
12700
12700
  start: number;
@@ -12869,19 +12869,14 @@ declare const Definitions: readonly [Schema.Struct<{
12869
12869
  type: "image";
12870
12870
  data: string;
12871
12871
  mimeType: string;
12872
- } | {
12873
- type: "thinking";
12874
- thinking: string;
12875
- thinkingSignature?: string;
12876
- redacted?: boolean;
12877
12872
  } | {
12878
12873
  addedToolNames?: string[];
12879
12874
  arguments: Record<string, any>;
12880
12875
  callID: string;
12881
12876
  name: string;
12882
12877
  namespace?: string;
12883
- partial?: {
12884
- content?: ({
12878
+ result: {
12879
+ content: ({
12885
12880
  type: "text";
12886
12881
  text: string;
12887
12882
  textSignature?: string;
@@ -12891,8 +12886,9 @@ declare const Definitions: readonly [Schema.Struct<{
12891
12886
  mimeType: string;
12892
12887
  })[];
12893
12888
  details?: any;
12889
+ isError: false;
12894
12890
  };
12895
- status: "running";
12891
+ status: "completed";
12896
12892
  thoughtSignature?: string;
12897
12893
  time: {
12898
12894
  start: number;
@@ -12916,9 +12912,9 @@ declare const Definitions: readonly [Schema.Struct<{
12916
12912
  mimeType: string;
12917
12913
  })[];
12918
12914
  details?: any;
12919
- isError: false;
12915
+ isError: true;
12920
12916
  };
12921
- status: "completed";
12917
+ status: "error";
12922
12918
  thoughtSignature?: string;
12923
12919
  time: {
12924
12920
  start: number;
@@ -12944,7 +12940,7 @@ declare const Definitions: readonly [Schema.Struct<{
12944
12940
  details?: any;
12945
12941
  isError: true;
12946
12942
  };
12947
- status: "error";
12943
+ status: "skipped";
12948
12944
  thoughtSignature?: string;
12949
12945
  time: {
12950
12946
  start: number;
@@ -12970,21 +12966,26 @@ declare const Definitions: readonly [Schema.Struct<{
12970
12966
  details?: any;
12971
12967
  isError: true;
12972
12968
  };
12973
- status: "skipped";
12969
+ status: "aborted";
12974
12970
  thoughtSignature?: string;
12975
12971
  time: {
12976
12972
  start: number;
12977
12973
  end: number;
12978
12974
  };
12979
12975
  type: "toolCall";
12976
+ } | {
12977
+ type: "thinking";
12978
+ thinking: string;
12979
+ thinkingSignature?: string;
12980
+ redacted?: boolean;
12980
12981
  } | {
12981
12982
  addedToolNames?: string[];
12982
12983
  arguments: Record<string, any>;
12983
12984
  callID: string;
12984
12985
  name: string;
12985
12986
  namespace?: string;
12986
- result: {
12987
- content: ({
12987
+ partial?: {
12988
+ content?: ({
12988
12989
  type: "text";
12989
12990
  text: string;
12990
12991
  textSignature?: string;
@@ -12994,9 +12995,8 @@ declare const Definitions: readonly [Schema.Struct<{
12994
12995
  mimeType: string;
12995
12996
  })[];
12996
12997
  details?: any;
12997
- isError: true;
12998
12998
  };
12999
- status: "aborted";
12999
+ status: "running";
13000
13000
  thoughtSignature?: string;
13001
13001
  time: {
13002
13002
  start: number;
@@ -13199,19 +13199,14 @@ declare const Definitions: readonly [Schema.Struct<{
13199
13199
  type: "image";
13200
13200
  data: string;
13201
13201
  mimeType: string;
13202
- } | {
13203
- type: "thinking";
13204
- thinking: string;
13205
- thinkingSignature?: string;
13206
- redacted?: boolean;
13207
13202
  } | {
13208
13203
  addedToolNames?: string[];
13209
13204
  arguments: Record<string, any>;
13210
13205
  callID: string;
13211
13206
  name: string;
13212
13207
  namespace?: string;
13213
- partial?: {
13214
- content?: ({
13208
+ result: {
13209
+ content: ({
13215
13210
  type: "text";
13216
13211
  text: string;
13217
13212
  textSignature?: string;
@@ -13221,8 +13216,9 @@ declare const Definitions: readonly [Schema.Struct<{
13221
13216
  mimeType: string;
13222
13217
  })[];
13223
13218
  details?: any;
13219
+ isError: false;
13224
13220
  };
13225
- status: "running";
13221
+ status: "completed";
13226
13222
  thoughtSignature?: string;
13227
13223
  time: {
13228
13224
  start: number;
@@ -13246,9 +13242,9 @@ declare const Definitions: readonly [Schema.Struct<{
13246
13242
  mimeType: string;
13247
13243
  })[];
13248
13244
  details?: any;
13249
- isError: false;
13245
+ isError: true;
13250
13246
  };
13251
- status: "completed";
13247
+ status: "error";
13252
13248
  thoughtSignature?: string;
13253
13249
  time: {
13254
13250
  start: number;
@@ -13274,7 +13270,7 @@ declare const Definitions: readonly [Schema.Struct<{
13274
13270
  details?: any;
13275
13271
  isError: true;
13276
13272
  };
13277
- status: "error";
13273
+ status: "skipped";
13278
13274
  thoughtSignature?: string;
13279
13275
  time: {
13280
13276
  start: number;
@@ -13300,21 +13296,26 @@ declare const Definitions: readonly [Schema.Struct<{
13300
13296
  details?: any;
13301
13297
  isError: true;
13302
13298
  };
13303
- status: "skipped";
13299
+ status: "aborted";
13304
13300
  thoughtSignature?: string;
13305
13301
  time: {
13306
13302
  start: number;
13307
13303
  end: number;
13308
13304
  };
13309
13305
  type: "toolCall";
13306
+ } | {
13307
+ type: "thinking";
13308
+ thinking: string;
13309
+ thinkingSignature?: string;
13310
+ redacted?: boolean;
13310
13311
  } | {
13311
13312
  addedToolNames?: string[];
13312
13313
  arguments: Record<string, any>;
13313
13314
  callID: string;
13314
13315
  name: string;
13315
13316
  namespace?: string;
13316
- result: {
13317
- content: ({
13317
+ partial?: {
13318
+ content?: ({
13318
13319
  type: "text";
13319
13320
  text: string;
13320
13321
  textSignature?: string;
@@ -13324,9 +13325,8 @@ declare const Definitions: readonly [Schema.Struct<{
13324
13325
  mimeType: string;
13325
13326
  })[];
13326
13327
  details?: any;
13327
- isError: true;
13328
13328
  };
13329
- status: "aborted";
13329
+ status: "running";
13330
13330
  thoughtSignature?: string;
13331
13331
  time: {
13332
13332
  start: number;
@@ -13501,19 +13501,14 @@ declare const Definitions: readonly [Schema.Struct<{
13501
13501
  type: "image";
13502
13502
  data: string;
13503
13503
  mimeType: string;
13504
- } | {
13505
- type: "thinking";
13506
- thinking: string;
13507
- thinkingSignature?: string;
13508
- redacted?: boolean;
13509
13504
  } | {
13510
13505
  addedToolNames?: string[];
13511
13506
  arguments: Record<string, any>;
13512
13507
  callID: string;
13513
13508
  name: string;
13514
13509
  namespace?: string;
13515
- partial?: {
13516
- content?: ({
13510
+ result: {
13511
+ content: ({
13517
13512
  type: "text";
13518
13513
  text: string;
13519
13514
  textSignature?: string;
@@ -13523,8 +13518,9 @@ declare const Definitions: readonly [Schema.Struct<{
13523
13518
  mimeType: string;
13524
13519
  })[];
13525
13520
  details?: any;
13521
+ isError: false;
13526
13522
  };
13527
- status: "running";
13523
+ status: "completed";
13528
13524
  thoughtSignature?: string;
13529
13525
  time: {
13530
13526
  start: number;
@@ -13548,9 +13544,9 @@ declare const Definitions: readonly [Schema.Struct<{
13548
13544
  mimeType: string;
13549
13545
  })[];
13550
13546
  details?: any;
13551
- isError: false;
13547
+ isError: true;
13552
13548
  };
13553
- status: "completed";
13549
+ status: "error";
13554
13550
  thoughtSignature?: string;
13555
13551
  time: {
13556
13552
  start: number;
@@ -13576,7 +13572,7 @@ declare const Definitions: readonly [Schema.Struct<{
13576
13572
  details?: any;
13577
13573
  isError: true;
13578
13574
  };
13579
- status: "error";
13575
+ status: "skipped";
13580
13576
  thoughtSignature?: string;
13581
13577
  time: {
13582
13578
  start: number;
@@ -13602,21 +13598,26 @@ declare const Definitions: readonly [Schema.Struct<{
13602
13598
  details?: any;
13603
13599
  isError: true;
13604
13600
  };
13605
- status: "skipped";
13601
+ status: "aborted";
13606
13602
  thoughtSignature?: string;
13607
13603
  time: {
13608
13604
  start: number;
13609
13605
  end: number;
13610
13606
  };
13611
13607
  type: "toolCall";
13608
+ } | {
13609
+ type: "thinking";
13610
+ thinking: string;
13611
+ thinkingSignature?: string;
13612
+ redacted?: boolean;
13612
13613
  } | {
13613
13614
  addedToolNames?: string[];
13614
13615
  arguments: Record<string, any>;
13615
13616
  callID: string;
13616
13617
  name: string;
13617
13618
  namespace?: string;
13618
- result: {
13619
- content: ({
13619
+ partial?: {
13620
+ content?: ({
13620
13621
  type: "text";
13621
13622
  text: string;
13622
13623
  textSignature?: string;
@@ -13626,9 +13627,8 @@ declare const Definitions: readonly [Schema.Struct<{
13626
13627
  mimeType: string;
13627
13628
  })[];
13628
13629
  details?: any;
13629
- isError: true;
13630
13630
  };
13631
- status: "aborted";
13631
+ status: "running";
13632
13632
  thoughtSignature?: string;
13633
13633
  time: {
13634
13634
  start: number;
@@ -13822,19 +13822,14 @@ declare const Definitions: readonly [Schema.Struct<{
13822
13822
  type: "image";
13823
13823
  data: string;
13824
13824
  mimeType: string;
13825
- } | {
13826
- type: "thinking";
13827
- thinking: string;
13828
- thinkingSignature?: string;
13829
- redacted?: boolean;
13830
13825
  } | {
13831
13826
  addedToolNames?: string[];
13832
13827
  arguments: Record<string, any>;
13833
13828
  callID: string;
13834
13829
  name: string;
13835
13830
  namespace?: string;
13836
- partial?: {
13837
- content?: ({
13831
+ result: {
13832
+ content: ({
13838
13833
  type: "text";
13839
13834
  text: string;
13840
13835
  textSignature?: string;
@@ -13844,8 +13839,9 @@ declare const Definitions: readonly [Schema.Struct<{
13844
13839
  mimeType: string;
13845
13840
  })[];
13846
13841
  details?: any;
13842
+ isError: false;
13847
13843
  };
13848
- status: "running";
13844
+ status: "completed";
13849
13845
  thoughtSignature?: string;
13850
13846
  time: {
13851
13847
  start: number;
@@ -13869,9 +13865,9 @@ declare const Definitions: readonly [Schema.Struct<{
13869
13865
  mimeType: string;
13870
13866
  })[];
13871
13867
  details?: any;
13872
- isError: false;
13868
+ isError: true;
13873
13869
  };
13874
- status: "completed";
13870
+ status: "error";
13875
13871
  thoughtSignature?: string;
13876
13872
  time: {
13877
13873
  start: number;
@@ -13897,7 +13893,7 @@ declare const Definitions: readonly [Schema.Struct<{
13897
13893
  details?: any;
13898
13894
  isError: true;
13899
13895
  };
13900
- status: "error";
13896
+ status: "skipped";
13901
13897
  thoughtSignature?: string;
13902
13898
  time: {
13903
13899
  start: number;
@@ -13923,21 +13919,26 @@ declare const Definitions: readonly [Schema.Struct<{
13923
13919
  details?: any;
13924
13920
  isError: true;
13925
13921
  };
13926
- status: "skipped";
13922
+ status: "aborted";
13927
13923
  thoughtSignature?: string;
13928
13924
  time: {
13929
13925
  start: number;
13930
13926
  end: number;
13931
13927
  };
13932
13928
  type: "toolCall";
13929
+ } | {
13930
+ type: "thinking";
13931
+ thinking: string;
13932
+ thinkingSignature?: string;
13933
+ redacted?: boolean;
13933
13934
  } | {
13934
13935
  addedToolNames?: string[];
13935
13936
  arguments: Record<string, any>;
13936
13937
  callID: string;
13937
13938
  name: string;
13938
13939
  namespace?: string;
13939
- result: {
13940
- content: ({
13940
+ partial?: {
13941
+ content?: ({
13941
13942
  type: "text";
13942
13943
  text: string;
13943
13944
  textSignature?: string;
@@ -13947,9 +13948,8 @@ declare const Definitions: readonly [Schema.Struct<{
13947
13948
  mimeType: string;
13948
13949
  })[];
13949
13950
  details?: any;
13950
- isError: true;
13951
13951
  };
13952
- status: "aborted";
13952
+ status: "running";
13953
13953
  thoughtSignature?: string;
13954
13954
  time: {
13955
13955
  start: number;
@@ -14124,19 +14124,14 @@ declare const Definitions: readonly [Schema.Struct<{
14124
14124
  type: "image";
14125
14125
  data: string;
14126
14126
  mimeType: string;
14127
- } | {
14128
- type: "thinking";
14129
- thinking: string;
14130
- thinkingSignature?: string;
14131
- redacted?: boolean;
14132
14127
  } | {
14133
14128
  addedToolNames?: string[];
14134
14129
  arguments: Record<string, any>;
14135
14130
  callID: string;
14136
14131
  name: string;
14137
14132
  namespace?: string;
14138
- partial?: {
14139
- content?: ({
14133
+ result: {
14134
+ content: ({
14140
14135
  type: "text";
14141
14136
  text: string;
14142
14137
  textSignature?: string;
@@ -14146,8 +14141,9 @@ declare const Definitions: readonly [Schema.Struct<{
14146
14141
  mimeType: string;
14147
14142
  })[];
14148
14143
  details?: any;
14144
+ isError: false;
14149
14145
  };
14150
- status: "running";
14146
+ status: "completed";
14151
14147
  thoughtSignature?: string;
14152
14148
  time: {
14153
14149
  start: number;
@@ -14171,9 +14167,9 @@ declare const Definitions: readonly [Schema.Struct<{
14171
14167
  mimeType: string;
14172
14168
  })[];
14173
14169
  details?: any;
14174
- isError: false;
14170
+ isError: true;
14175
14171
  };
14176
- status: "completed";
14172
+ status: "error";
14177
14173
  thoughtSignature?: string;
14178
14174
  time: {
14179
14175
  start: number;
@@ -14199,7 +14195,7 @@ declare const Definitions: readonly [Schema.Struct<{
14199
14195
  details?: any;
14200
14196
  isError: true;
14201
14197
  };
14202
- status: "error";
14198
+ status: "skipped";
14203
14199
  thoughtSignature?: string;
14204
14200
  time: {
14205
14201
  start: number;
@@ -14225,21 +14221,26 @@ declare const Definitions: readonly [Schema.Struct<{
14225
14221
  details?: any;
14226
14222
  isError: true;
14227
14223
  };
14228
- status: "skipped";
14224
+ status: "aborted";
14229
14225
  thoughtSignature?: string;
14230
14226
  time: {
14231
14227
  start: number;
14232
14228
  end: number;
14233
14229
  };
14234
14230
  type: "toolCall";
14231
+ } | {
14232
+ type: "thinking";
14233
+ thinking: string;
14234
+ thinkingSignature?: string;
14235
+ redacted?: boolean;
14235
14236
  } | {
14236
14237
  addedToolNames?: string[];
14237
14238
  arguments: Record<string, any>;
14238
14239
  callID: string;
14239
14240
  name: string;
14240
14241
  namespace?: string;
14241
- result: {
14242
- content: ({
14242
+ partial?: {
14243
+ content?: ({
14243
14244
  type: "text";
14244
14245
  text: string;
14245
14246
  textSignature?: string;
@@ -14249,9 +14250,8 @@ declare const Definitions: readonly [Schema.Struct<{
14249
14250
  mimeType: string;
14250
14251
  })[];
14251
14252
  details?: any;
14252
- isError: true;
14253
14253
  };
14254
- status: "aborted";
14254
+ status: "running";
14255
14255
  thoughtSignature?: string;
14256
14256
  time: {
14257
14257
  start: number;
@@ -15760,19 +15760,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15760
15760
  type: "image";
15761
15761
  data: string;
15762
15762
  mimeType: string;
15763
- } | {
15764
- type: "thinking";
15765
- thinking: string;
15766
- thinkingSignature?: string;
15767
- redacted?: boolean;
15768
15763
  } | {
15769
15764
  addedToolNames?: string[];
15770
15765
  arguments: Record<string, any>;
15771
15766
  callID: string;
15772
15767
  name: string;
15773
15768
  namespace?: string;
15774
- partial?: {
15775
- content?: ({
15769
+ result: {
15770
+ content: ({
15776
15771
  type: "text";
15777
15772
  text: string;
15778
15773
  textSignature?: string;
@@ -15782,8 +15777,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15782
15777
  mimeType: string;
15783
15778
  })[];
15784
15779
  details?: any;
15780
+ isError: false;
15785
15781
  };
15786
- status: "running";
15782
+ status: "completed";
15787
15783
  thoughtSignature?: string;
15788
15784
  time: {
15789
15785
  start: number;
@@ -15807,9 +15803,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15807
15803
  mimeType: string;
15808
15804
  })[];
15809
15805
  details?: any;
15810
- isError: false;
15806
+ isError: true;
15811
15807
  };
15812
- status: "completed";
15808
+ status: "error";
15813
15809
  thoughtSignature?: string;
15814
15810
  time: {
15815
15811
  start: number;
@@ -15835,7 +15831,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15835
15831
  details?: any;
15836
15832
  isError: true;
15837
15833
  };
15838
- status: "error";
15834
+ status: "skipped";
15839
15835
  thoughtSignature?: string;
15840
15836
  time: {
15841
15837
  start: number;
@@ -15861,21 +15857,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15861
15857
  details?: any;
15862
15858
  isError: true;
15863
15859
  };
15864
- status: "skipped";
15860
+ status: "aborted";
15865
15861
  thoughtSignature?: string;
15866
15862
  time: {
15867
15863
  start: number;
15868
15864
  end: number;
15869
15865
  };
15870
15866
  type: "toolCall";
15867
+ } | {
15868
+ type: "thinking";
15869
+ thinking: string;
15870
+ thinkingSignature?: string;
15871
+ redacted?: boolean;
15871
15872
  } | {
15872
15873
  addedToolNames?: string[];
15873
15874
  arguments: Record<string, any>;
15874
15875
  callID: string;
15875
15876
  name: string;
15876
15877
  namespace?: string;
15877
- result: {
15878
- content: ({
15878
+ partial?: {
15879
+ content?: ({
15879
15880
  type: "text";
15880
15881
  text: string;
15881
15882
  textSignature?: string;
@@ -15885,9 +15886,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15885
15886
  mimeType: string;
15886
15887
  })[];
15887
15888
  details?: any;
15888
- isError: true;
15889
15889
  };
15890
- status: "aborted";
15890
+ status: "running";
15891
15891
  thoughtSignature?: string;
15892
15892
  time: {
15893
15893
  start: number;
@@ -16062,19 +16062,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16062
16062
  type: "image";
16063
16063
  data: string;
16064
16064
  mimeType: string;
16065
- } | {
16066
- type: "thinking";
16067
- thinking: string;
16068
- thinkingSignature?: string;
16069
- redacted?: boolean;
16070
16065
  } | {
16071
16066
  addedToolNames?: string[];
16072
16067
  arguments: Record<string, any>;
16073
16068
  callID: string;
16074
16069
  name: string;
16075
16070
  namespace?: string;
16076
- partial?: {
16077
- content?: ({
16071
+ result: {
16072
+ content: ({
16078
16073
  type: "text";
16079
16074
  text: string;
16080
16075
  textSignature?: string;
@@ -16084,8 +16079,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16084
16079
  mimeType: string;
16085
16080
  })[];
16086
16081
  details?: any;
16082
+ isError: false;
16087
16083
  };
16088
- status: "running";
16084
+ status: "completed";
16089
16085
  thoughtSignature?: string;
16090
16086
  time: {
16091
16087
  start: number;
@@ -16109,9 +16105,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16109
16105
  mimeType: string;
16110
16106
  })[];
16111
16107
  details?: any;
16112
- isError: false;
16108
+ isError: true;
16113
16109
  };
16114
- status: "completed";
16110
+ status: "error";
16115
16111
  thoughtSignature?: string;
16116
16112
  time: {
16117
16113
  start: number;
@@ -16137,7 +16133,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16137
16133
  details?: any;
16138
16134
  isError: true;
16139
16135
  };
16140
- status: "error";
16136
+ status: "skipped";
16141
16137
  thoughtSignature?: string;
16142
16138
  time: {
16143
16139
  start: number;
@@ -16163,21 +16159,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16163
16159
  details?: any;
16164
16160
  isError: true;
16165
16161
  };
16166
- status: "skipped";
16162
+ status: "aborted";
16167
16163
  thoughtSignature?: string;
16168
16164
  time: {
16169
16165
  start: number;
16170
16166
  end: number;
16171
16167
  };
16172
16168
  type: "toolCall";
16169
+ } | {
16170
+ type: "thinking";
16171
+ thinking: string;
16172
+ thinkingSignature?: string;
16173
+ redacted?: boolean;
16173
16174
  } | {
16174
16175
  addedToolNames?: string[];
16175
16176
  arguments: Record<string, any>;
16176
16177
  callID: string;
16177
16178
  name: string;
16178
16179
  namespace?: string;
16179
- result: {
16180
- content: ({
16180
+ partial?: {
16181
+ content?: ({
16181
16182
  type: "text";
16182
16183
  text: string;
16183
16184
  textSignature?: string;
@@ -16187,9 +16188,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16187
16188
  mimeType: string;
16188
16189
  })[];
16189
16190
  details?: any;
16190
- isError: true;
16191
16191
  };
16192
- status: "aborted";
16192
+ status: "running";
16193
16193
  thoughtSignature?: string;
16194
16194
  time: {
16195
16195
  start: number;
@@ -16382,19 +16382,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16382
16382
  type: "image";
16383
16383
  data: string;
16384
16384
  mimeType: string;
16385
- } | {
16386
- type: "thinking";
16387
- thinking: string;
16388
- thinkingSignature?: string;
16389
- redacted?: boolean;
16390
16385
  } | {
16391
16386
  addedToolNames?: string[];
16392
16387
  arguments: Record<string, any>;
16393
16388
  callID: string;
16394
16389
  name: string;
16395
16390
  namespace?: string;
16396
- partial?: {
16397
- content?: ({
16391
+ result: {
16392
+ content: ({
16398
16393
  type: "text";
16399
16394
  text: string;
16400
16395
  textSignature?: string;
@@ -16404,8 +16399,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16404
16399
  mimeType: string;
16405
16400
  })[];
16406
16401
  details?: any;
16402
+ isError: false;
16407
16403
  };
16408
- status: "running";
16404
+ status: "completed";
16409
16405
  thoughtSignature?: string;
16410
16406
  time: {
16411
16407
  start: number;
@@ -16429,9 +16425,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16429
16425
  mimeType: string;
16430
16426
  })[];
16431
16427
  details?: any;
16432
- isError: false;
16428
+ isError: true;
16433
16429
  };
16434
- status: "completed";
16430
+ status: "error";
16435
16431
  thoughtSignature?: string;
16436
16432
  time: {
16437
16433
  start: number;
@@ -16457,7 +16453,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16457
16453
  details?: any;
16458
16454
  isError: true;
16459
16455
  };
16460
- status: "error";
16456
+ status: "skipped";
16461
16457
  thoughtSignature?: string;
16462
16458
  time: {
16463
16459
  start: number;
@@ -16483,21 +16479,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16483
16479
  details?: any;
16484
16480
  isError: true;
16485
16481
  };
16486
- status: "skipped";
16482
+ status: "aborted";
16487
16483
  thoughtSignature?: string;
16488
16484
  time: {
16489
16485
  start: number;
16490
16486
  end: number;
16491
16487
  };
16492
16488
  type: "toolCall";
16489
+ } | {
16490
+ type: "thinking";
16491
+ thinking: string;
16492
+ thinkingSignature?: string;
16493
+ redacted?: boolean;
16493
16494
  } | {
16494
16495
  addedToolNames?: string[];
16495
16496
  arguments: Record<string, any>;
16496
16497
  callID: string;
16497
16498
  name: string;
16498
16499
  namespace?: string;
16499
- result: {
16500
- content: ({
16500
+ partial?: {
16501
+ content?: ({
16501
16502
  type: "text";
16502
16503
  text: string;
16503
16504
  textSignature?: string;
@@ -16507,9 +16508,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16507
16508
  mimeType: string;
16508
16509
  })[];
16509
16510
  details?: any;
16510
- isError: true;
16511
16511
  };
16512
- status: "aborted";
16512
+ status: "running";
16513
16513
  thoughtSignature?: string;
16514
16514
  time: {
16515
16515
  start: number;
@@ -16684,19 +16684,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16684
16684
  type: "image";
16685
16685
  data: string;
16686
16686
  mimeType: string;
16687
- } | {
16688
- type: "thinking";
16689
- thinking: string;
16690
- thinkingSignature?: string;
16691
- redacted?: boolean;
16692
16687
  } | {
16693
16688
  addedToolNames?: string[];
16694
16689
  arguments: Record<string, any>;
16695
16690
  callID: string;
16696
16691
  name: string;
16697
16692
  namespace?: string;
16698
- partial?: {
16699
- content?: ({
16693
+ result: {
16694
+ content: ({
16700
16695
  type: "text";
16701
16696
  text: string;
16702
16697
  textSignature?: string;
@@ -16706,8 +16701,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16706
16701
  mimeType: string;
16707
16702
  })[];
16708
16703
  details?: any;
16704
+ isError: false;
16709
16705
  };
16710
- status: "running";
16706
+ status: "completed";
16711
16707
  thoughtSignature?: string;
16712
16708
  time: {
16713
16709
  start: number;
@@ -16731,9 +16727,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16731
16727
  mimeType: string;
16732
16728
  })[];
16733
16729
  details?: any;
16734
- isError: false;
16730
+ isError: true;
16735
16731
  };
16736
- status: "completed";
16732
+ status: "error";
16737
16733
  thoughtSignature?: string;
16738
16734
  time: {
16739
16735
  start: number;
@@ -16759,7 +16755,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16759
16755
  details?: any;
16760
16756
  isError: true;
16761
16757
  };
16762
- status: "error";
16758
+ status: "skipped";
16763
16759
  thoughtSignature?: string;
16764
16760
  time: {
16765
16761
  start: number;
@@ -16785,21 +16781,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16785
16781
  details?: any;
16786
16782
  isError: true;
16787
16783
  };
16788
- status: "skipped";
16784
+ status: "aborted";
16789
16785
  thoughtSignature?: string;
16790
16786
  time: {
16791
16787
  start: number;
16792
16788
  end: number;
16793
16789
  };
16794
16790
  type: "toolCall";
16791
+ } | {
16792
+ type: "thinking";
16793
+ thinking: string;
16794
+ thinkingSignature?: string;
16795
+ redacted?: boolean;
16795
16796
  } | {
16796
16797
  addedToolNames?: string[];
16797
16798
  arguments: Record<string, any>;
16798
16799
  callID: string;
16799
16800
  name: string;
16800
16801
  namespace?: string;
16801
- result: {
16802
- content: ({
16802
+ partial?: {
16803
+ content?: ({
16803
16804
  type: "text";
16804
16805
  text: string;
16805
16806
  textSignature?: string;
@@ -16809,9 +16810,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16809
16810
  mimeType: string;
16810
16811
  })[];
16811
16812
  details?: any;
16812
- isError: true;
16813
16813
  };
16814
- status: "aborted";
16814
+ status: "running";
16815
16815
  thoughtSignature?: string;
16816
16816
  time: {
16817
16817
  start: number;
@@ -17292,19 +17292,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17292
17292
  type: "image";
17293
17293
  data: string;
17294
17294
  mimeType: string;
17295
- } | {
17296
- type: "thinking";
17297
- thinking: string;
17298
- thinkingSignature?: string;
17299
- redacted?: boolean;
17300
17295
  } | {
17301
17296
  addedToolNames?: string[];
17302
17297
  arguments: Record<string, any>;
17303
17298
  callID: string;
17304
17299
  name: string;
17305
17300
  namespace?: string;
17306
- partial?: {
17307
- content?: ({
17301
+ result: {
17302
+ content: ({
17308
17303
  type: "text";
17309
17304
  text: string;
17310
17305
  textSignature?: string;
@@ -17314,8 +17309,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17314
17309
  mimeType: string;
17315
17310
  })[];
17316
17311
  details?: any;
17312
+ isError: false;
17317
17313
  };
17318
- status: "running";
17314
+ status: "completed";
17319
17315
  thoughtSignature?: string;
17320
17316
  time: {
17321
17317
  start: number;
@@ -17339,9 +17335,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17339
17335
  mimeType: string;
17340
17336
  })[];
17341
17337
  details?: any;
17342
- isError: false;
17338
+ isError: true;
17343
17339
  };
17344
- status: "completed";
17340
+ status: "error";
17345
17341
  thoughtSignature?: string;
17346
17342
  time: {
17347
17343
  start: number;
@@ -17367,7 +17363,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17367
17363
  details?: any;
17368
17364
  isError: true;
17369
17365
  };
17370
- status: "error";
17366
+ status: "skipped";
17371
17367
  thoughtSignature?: string;
17372
17368
  time: {
17373
17369
  start: number;
@@ -17393,21 +17389,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17393
17389
  details?: any;
17394
17390
  isError: true;
17395
17391
  };
17396
- status: "skipped";
17392
+ status: "aborted";
17397
17393
  thoughtSignature?: string;
17398
17394
  time: {
17399
17395
  start: number;
17400
17396
  end: number;
17401
17397
  };
17402
17398
  type: "toolCall";
17399
+ } | {
17400
+ type: "thinking";
17401
+ thinking: string;
17402
+ thinkingSignature?: string;
17403
+ redacted?: boolean;
17403
17404
  } | {
17404
17405
  addedToolNames?: string[];
17405
17406
  arguments: Record<string, any>;
17406
17407
  callID: string;
17407
17408
  name: string;
17408
17409
  namespace?: string;
17409
- result: {
17410
- content: ({
17410
+ partial?: {
17411
+ content?: ({
17411
17412
  type: "text";
17412
17413
  text: string;
17413
17414
  textSignature?: string;
@@ -17417,9 +17418,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17417
17418
  mimeType: string;
17418
17419
  })[];
17419
17420
  details?: any;
17420
- isError: true;
17421
17421
  };
17422
- status: "aborted";
17422
+ status: "running";
17423
17423
  thoughtSignature?: string;
17424
17424
  time: {
17425
17425
  start: number;
@@ -17594,19 +17594,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17594
17594
  type: "image";
17595
17595
  data: string;
17596
17596
  mimeType: string;
17597
- } | {
17598
- type: "thinking";
17599
- thinking: string;
17600
- thinkingSignature?: string;
17601
- redacted?: boolean;
17602
17597
  } | {
17603
17598
  addedToolNames?: string[];
17604
17599
  arguments: Record<string, any>;
17605
17600
  callID: string;
17606
17601
  name: string;
17607
17602
  namespace?: string;
17608
- partial?: {
17609
- content?: ({
17603
+ result: {
17604
+ content: ({
17610
17605
  type: "text";
17611
17606
  text: string;
17612
17607
  textSignature?: string;
@@ -17616,8 +17611,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17616
17611
  mimeType: string;
17617
17612
  })[];
17618
17613
  details?: any;
17614
+ isError: false;
17619
17615
  };
17620
- status: "running";
17616
+ status: "completed";
17621
17617
  thoughtSignature?: string;
17622
17618
  time: {
17623
17619
  start: number;
@@ -17641,9 +17637,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17641
17637
  mimeType: string;
17642
17638
  })[];
17643
17639
  details?: any;
17644
- isError: false;
17640
+ isError: true;
17645
17641
  };
17646
- status: "completed";
17642
+ status: "error";
17647
17643
  thoughtSignature?: string;
17648
17644
  time: {
17649
17645
  start: number;
@@ -17669,7 +17665,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17669
17665
  details?: any;
17670
17666
  isError: true;
17671
17667
  };
17672
- status: "error";
17668
+ status: "skipped";
17673
17669
  thoughtSignature?: string;
17674
17670
  time: {
17675
17671
  start: number;
@@ -17695,21 +17691,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17695
17691
  details?: any;
17696
17692
  isError: true;
17697
17693
  };
17698
- status: "skipped";
17694
+ status: "aborted";
17699
17695
  thoughtSignature?: string;
17700
17696
  time: {
17701
17697
  start: number;
17702
17698
  end: number;
17703
17699
  };
17704
17700
  type: "toolCall";
17701
+ } | {
17702
+ type: "thinking";
17703
+ thinking: string;
17704
+ thinkingSignature?: string;
17705
+ redacted?: boolean;
17705
17706
  } | {
17706
17707
  addedToolNames?: string[];
17707
17708
  arguments: Record<string, any>;
17708
17709
  callID: string;
17709
17710
  name: string;
17710
17711
  namespace?: string;
17711
- result: {
17712
- content: ({
17712
+ partial?: {
17713
+ content?: ({
17713
17714
  type: "text";
17714
17715
  text: string;
17715
17716
  textSignature?: string;
@@ -17719,9 +17720,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17719
17720
  mimeType: string;
17720
17721
  })[];
17721
17722
  details?: any;
17722
- isError: true;
17723
17723
  };
17724
- status: "aborted";
17724
+ status: "running";
17725
17725
  thoughtSignature?: string;
17726
17726
  time: {
17727
17727
  start: number;
@@ -17915,19 +17915,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17915
17915
  type: "image";
17916
17916
  data: string;
17917
17917
  mimeType: string;
17918
- } | {
17919
- type: "thinking";
17920
- thinking: string;
17921
- thinkingSignature?: string;
17922
- redacted?: boolean;
17923
17918
  } | {
17924
17919
  addedToolNames?: string[];
17925
17920
  arguments: Record<string, any>;
17926
17921
  callID: string;
17927
17922
  name: string;
17928
17923
  namespace?: string;
17929
- partial?: {
17930
- content?: ({
17924
+ result: {
17925
+ content: ({
17931
17926
  type: "text";
17932
17927
  text: string;
17933
17928
  textSignature?: string;
@@ -17937,8 +17932,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17937
17932
  mimeType: string;
17938
17933
  })[];
17939
17934
  details?: any;
17935
+ isError: false;
17940
17936
  };
17941
- status: "running";
17937
+ status: "completed";
17942
17938
  thoughtSignature?: string;
17943
17939
  time: {
17944
17940
  start: number;
@@ -17962,9 +17958,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17962
17958
  mimeType: string;
17963
17959
  })[];
17964
17960
  details?: any;
17965
- isError: false;
17961
+ isError: true;
17966
17962
  };
17967
- status: "completed";
17963
+ status: "error";
17968
17964
  thoughtSignature?: string;
17969
17965
  time: {
17970
17966
  start: number;
@@ -17990,7 +17986,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17990
17986
  details?: any;
17991
17987
  isError: true;
17992
17988
  };
17993
- status: "error";
17989
+ status: "skipped";
17994
17990
  thoughtSignature?: string;
17995
17991
  time: {
17996
17992
  start: number;
@@ -18016,21 +18012,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18016
18012
  details?: any;
18017
18013
  isError: true;
18018
18014
  };
18019
- status: "skipped";
18015
+ status: "aborted";
18020
18016
  thoughtSignature?: string;
18021
18017
  time: {
18022
18018
  start: number;
18023
18019
  end: number;
18024
18020
  };
18025
18021
  type: "toolCall";
18022
+ } | {
18023
+ type: "thinking";
18024
+ thinking: string;
18025
+ thinkingSignature?: string;
18026
+ redacted?: boolean;
18026
18027
  } | {
18027
18028
  addedToolNames?: string[];
18028
18029
  arguments: Record<string, any>;
18029
18030
  callID: string;
18030
18031
  name: string;
18031
18032
  namespace?: string;
18032
- result: {
18033
- content: ({
18033
+ partial?: {
18034
+ content?: ({
18034
18035
  type: "text";
18035
18036
  text: string;
18036
18037
  textSignature?: string;
@@ -18040,9 +18041,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18040
18041
  mimeType: string;
18041
18042
  })[];
18042
18043
  details?: any;
18043
- isError: true;
18044
18044
  };
18045
- status: "aborted";
18045
+ status: "running";
18046
18046
  thoughtSignature?: string;
18047
18047
  time: {
18048
18048
  start: number;
@@ -18217,19 +18217,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18217
18217
  type: "image";
18218
18218
  data: string;
18219
18219
  mimeType: string;
18220
- } | {
18221
- type: "thinking";
18222
- thinking: string;
18223
- thinkingSignature?: string;
18224
- redacted?: boolean;
18225
18220
  } | {
18226
18221
  addedToolNames?: string[];
18227
18222
  arguments: Record<string, any>;
18228
18223
  callID: string;
18229
18224
  name: string;
18230
18225
  namespace?: string;
18231
- partial?: {
18232
- content?: ({
18226
+ result: {
18227
+ content: ({
18233
18228
  type: "text";
18234
18229
  text: string;
18235
18230
  textSignature?: string;
@@ -18239,8 +18234,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18239
18234
  mimeType: string;
18240
18235
  })[];
18241
18236
  details?: any;
18237
+ isError: false;
18242
18238
  };
18243
- status: "running";
18239
+ status: "completed";
18244
18240
  thoughtSignature?: string;
18245
18241
  time: {
18246
18242
  start: number;
@@ -18264,9 +18260,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18264
18260
  mimeType: string;
18265
18261
  })[];
18266
18262
  details?: any;
18267
- isError: false;
18263
+ isError: true;
18268
18264
  };
18269
- status: "completed";
18265
+ status: "error";
18270
18266
  thoughtSignature?: string;
18271
18267
  time: {
18272
18268
  start: number;
@@ -18292,7 +18288,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18292
18288
  details?: any;
18293
18289
  isError: true;
18294
18290
  };
18295
- status: "error";
18291
+ status: "skipped";
18296
18292
  thoughtSignature?: string;
18297
18293
  time: {
18298
18294
  start: number;
@@ -18318,21 +18314,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18318
18314
  details?: any;
18319
18315
  isError: true;
18320
18316
  };
18321
- status: "skipped";
18317
+ status: "aborted";
18322
18318
  thoughtSignature?: string;
18323
18319
  time: {
18324
18320
  start: number;
18325
18321
  end: number;
18326
18322
  };
18327
18323
  type: "toolCall";
18324
+ } | {
18325
+ type: "thinking";
18326
+ thinking: string;
18327
+ thinkingSignature?: string;
18328
+ redacted?: boolean;
18328
18329
  } | {
18329
18330
  addedToolNames?: string[];
18330
18331
  arguments: Record<string, any>;
18331
18332
  callID: string;
18332
18333
  name: string;
18333
18334
  namespace?: string;
18334
- result: {
18335
- content: ({
18335
+ partial?: {
18336
+ content?: ({
18336
18337
  type: "text";
18337
18338
  text: string;
18338
18339
  textSignature?: string;
@@ -18342,9 +18343,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18342
18343
  mimeType: string;
18343
18344
  })[];
18344
18345
  details?: any;
18345
- isError: true;
18346
18346
  };
18347
- status: "aborted";
18347
+ status: "running";
18348
18348
  thoughtSignature?: string;
18349
18349
  time: {
18350
18350
  start: number;
@@ -18547,19 +18547,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18547
18547
  type: "image";
18548
18548
  data: string;
18549
18549
  mimeType: string;
18550
- } | {
18551
- type: "thinking";
18552
- thinking: string;
18553
- thinkingSignature?: string;
18554
- redacted?: boolean;
18555
18550
  } | {
18556
18551
  addedToolNames?: string[];
18557
18552
  arguments: Record<string, any>;
18558
18553
  callID: string;
18559
18554
  name: string;
18560
18555
  namespace?: string;
18561
- partial?: {
18562
- content?: ({
18556
+ result: {
18557
+ content: ({
18563
18558
  type: "text";
18564
18559
  text: string;
18565
18560
  textSignature?: string;
@@ -18569,8 +18564,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18569
18564
  mimeType: string;
18570
18565
  })[];
18571
18566
  details?: any;
18567
+ isError: false;
18572
18568
  };
18573
- status: "running";
18569
+ status: "completed";
18574
18570
  thoughtSignature?: string;
18575
18571
  time: {
18576
18572
  start: number;
@@ -18594,9 +18590,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18594
18590
  mimeType: string;
18595
18591
  })[];
18596
18592
  details?: any;
18597
- isError: false;
18593
+ isError: true;
18598
18594
  };
18599
- status: "completed";
18595
+ status: "error";
18600
18596
  thoughtSignature?: string;
18601
18597
  time: {
18602
18598
  start: number;
@@ -18622,7 +18618,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18622
18618
  details?: any;
18623
18619
  isError: true;
18624
18620
  };
18625
- status: "error";
18621
+ status: "skipped";
18626
18622
  thoughtSignature?: string;
18627
18623
  time: {
18628
18624
  start: number;
@@ -18648,21 +18644,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18648
18644
  details?: any;
18649
18645
  isError: true;
18650
18646
  };
18651
- status: "skipped";
18647
+ status: "aborted";
18652
18648
  thoughtSignature?: string;
18653
18649
  time: {
18654
18650
  start: number;
18655
18651
  end: number;
18656
18652
  };
18657
18653
  type: "toolCall";
18654
+ } | {
18655
+ type: "thinking";
18656
+ thinking: string;
18657
+ thinkingSignature?: string;
18658
+ redacted?: boolean;
18658
18659
  } | {
18659
18660
  addedToolNames?: string[];
18660
18661
  arguments: Record<string, any>;
18661
18662
  callID: string;
18662
18663
  name: string;
18663
18664
  namespace?: string;
18664
- result: {
18665
- content: ({
18665
+ partial?: {
18666
+ content?: ({
18666
18667
  type: "text";
18667
18668
  text: string;
18668
18669
  textSignature?: string;
@@ -18672,9 +18673,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18672
18673
  mimeType: string;
18673
18674
  })[];
18674
18675
  details?: any;
18675
- isError: true;
18676
18676
  };
18677
- status: "aborted";
18677
+ status: "running";
18678
18678
  thoughtSignature?: string;
18679
18679
  time: {
18680
18680
  start: number;
@@ -18849,19 +18849,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18849
18849
  type: "image";
18850
18850
  data: string;
18851
18851
  mimeType: string;
18852
- } | {
18853
- type: "thinking";
18854
- thinking: string;
18855
- thinkingSignature?: string;
18856
- redacted?: boolean;
18857
18852
  } | {
18858
18853
  addedToolNames?: string[];
18859
18854
  arguments: Record<string, any>;
18860
18855
  callID: string;
18861
18856
  name: string;
18862
18857
  namespace?: string;
18863
- partial?: {
18864
- content?: ({
18858
+ result: {
18859
+ content: ({
18865
18860
  type: "text";
18866
18861
  text: string;
18867
18862
  textSignature?: string;
@@ -18871,8 +18866,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18871
18866
  mimeType: string;
18872
18867
  })[];
18873
18868
  details?: any;
18869
+ isError: false;
18874
18870
  };
18875
- status: "running";
18871
+ status: "completed";
18876
18872
  thoughtSignature?: string;
18877
18873
  time: {
18878
18874
  start: number;
@@ -18896,9 +18892,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18896
18892
  mimeType: string;
18897
18893
  })[];
18898
18894
  details?: any;
18899
- isError: false;
18895
+ isError: true;
18900
18896
  };
18901
- status: "completed";
18897
+ status: "error";
18902
18898
  thoughtSignature?: string;
18903
18899
  time: {
18904
18900
  start: number;
@@ -18924,7 +18920,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18924
18920
  details?: any;
18925
18921
  isError: true;
18926
18922
  };
18927
- status: "error";
18923
+ status: "skipped";
18928
18924
  thoughtSignature?: string;
18929
18925
  time: {
18930
18926
  start: number;
@@ -18950,21 +18946,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18950
18946
  details?: any;
18951
18947
  isError: true;
18952
18948
  };
18953
- status: "skipped";
18949
+ status: "aborted";
18954
18950
  thoughtSignature?: string;
18955
18951
  time: {
18956
18952
  start: number;
18957
18953
  end: number;
18958
18954
  };
18959
18955
  type: "toolCall";
18956
+ } | {
18957
+ type: "thinking";
18958
+ thinking: string;
18959
+ thinkingSignature?: string;
18960
+ redacted?: boolean;
18960
18961
  } | {
18961
18962
  addedToolNames?: string[];
18962
18963
  arguments: Record<string, any>;
18963
18964
  callID: string;
18964
18965
  name: string;
18965
18966
  namespace?: string;
18966
- result: {
18967
- content: ({
18967
+ partial?: {
18968
+ content?: ({
18968
18969
  type: "text";
18969
18970
  text: string;
18970
18971
  textSignature?: string;
@@ -18974,9 +18975,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18974
18975
  mimeType: string;
18975
18976
  })[];
18976
18977
  details?: any;
18977
- isError: true;
18978
18978
  };
18979
- status: "aborted";
18979
+ status: "running";
18980
18980
  thoughtSignature?: string;
18981
18981
  time: {
18982
18982
  start: number;
@@ -19170,19 +19170,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19170
19170
  type: "image";
19171
19171
  data: string;
19172
19172
  mimeType: string;
19173
- } | {
19174
- type: "thinking";
19175
- thinking: string;
19176
- thinkingSignature?: string;
19177
- redacted?: boolean;
19178
19173
  } | {
19179
19174
  addedToolNames?: string[];
19180
19175
  arguments: Record<string, any>;
19181
19176
  callID: string;
19182
19177
  name: string;
19183
19178
  namespace?: string;
19184
- partial?: {
19185
- content?: ({
19179
+ result: {
19180
+ content: ({
19186
19181
  type: "text";
19187
19182
  text: string;
19188
19183
  textSignature?: string;
@@ -19192,8 +19187,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19192
19187
  mimeType: string;
19193
19188
  })[];
19194
19189
  details?: any;
19190
+ isError: false;
19195
19191
  };
19196
- status: "running";
19192
+ status: "completed";
19197
19193
  thoughtSignature?: string;
19198
19194
  time: {
19199
19195
  start: number;
@@ -19217,9 +19213,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19217
19213
  mimeType: string;
19218
19214
  })[];
19219
19215
  details?: any;
19220
- isError: false;
19216
+ isError: true;
19221
19217
  };
19222
- status: "completed";
19218
+ status: "error";
19223
19219
  thoughtSignature?: string;
19224
19220
  time: {
19225
19221
  start: number;
@@ -19245,7 +19241,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19245
19241
  details?: any;
19246
19242
  isError: true;
19247
19243
  };
19248
- status: "error";
19244
+ status: "skipped";
19249
19245
  thoughtSignature?: string;
19250
19246
  time: {
19251
19247
  start: number;
@@ -19271,21 +19267,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19271
19267
  details?: any;
19272
19268
  isError: true;
19273
19269
  };
19274
- status: "skipped";
19270
+ status: "aborted";
19275
19271
  thoughtSignature?: string;
19276
19272
  time: {
19277
19273
  start: number;
19278
19274
  end: number;
19279
19275
  };
19280
19276
  type: "toolCall";
19277
+ } | {
19278
+ type: "thinking";
19279
+ thinking: string;
19280
+ thinkingSignature?: string;
19281
+ redacted?: boolean;
19281
19282
  } | {
19282
19283
  addedToolNames?: string[];
19283
19284
  arguments: Record<string, any>;
19284
19285
  callID: string;
19285
19286
  name: string;
19286
19287
  namespace?: string;
19287
- result: {
19288
- content: ({
19288
+ partial?: {
19289
+ content?: ({
19289
19290
  type: "text";
19290
19291
  text: string;
19291
19292
  textSignature?: string;
@@ -19295,9 +19296,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19295
19296
  mimeType: string;
19296
19297
  })[];
19297
19298
  details?: any;
19298
- isError: true;
19299
19299
  };
19300
- status: "aborted";
19300
+ status: "running";
19301
19301
  thoughtSignature?: string;
19302
19302
  time: {
19303
19303
  start: number;
@@ -19472,19 +19472,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19472
19472
  type: "image";
19473
19473
  data: string;
19474
19474
  mimeType: string;
19475
- } | {
19476
- type: "thinking";
19477
- thinking: string;
19478
- thinkingSignature?: string;
19479
- redacted?: boolean;
19480
19475
  } | {
19481
19476
  addedToolNames?: string[];
19482
19477
  arguments: Record<string, any>;
19483
19478
  callID: string;
19484
19479
  name: string;
19485
19480
  namespace?: string;
19486
- partial?: {
19487
- content?: ({
19481
+ result: {
19482
+ content: ({
19488
19483
  type: "text";
19489
19484
  text: string;
19490
19485
  textSignature?: string;
@@ -19494,8 +19489,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19494
19489
  mimeType: string;
19495
19490
  })[];
19496
19491
  details?: any;
19492
+ isError: false;
19497
19493
  };
19498
- status: "running";
19494
+ status: "completed";
19499
19495
  thoughtSignature?: string;
19500
19496
  time: {
19501
19497
  start: number;
@@ -19519,9 +19515,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19519
19515
  mimeType: string;
19520
19516
  })[];
19521
19517
  details?: any;
19522
- isError: false;
19518
+ isError: true;
19523
19519
  };
19524
- status: "completed";
19520
+ status: "error";
19525
19521
  thoughtSignature?: string;
19526
19522
  time: {
19527
19523
  start: number;
@@ -19547,7 +19543,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19547
19543
  details?: any;
19548
19544
  isError: true;
19549
19545
  };
19550
- status: "error";
19546
+ status: "skipped";
19551
19547
  thoughtSignature?: string;
19552
19548
  time: {
19553
19549
  start: number;
@@ -19573,21 +19569,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19573
19569
  details?: any;
19574
19570
  isError: true;
19575
19571
  };
19576
- status: "skipped";
19572
+ status: "aborted";
19577
19573
  thoughtSignature?: string;
19578
19574
  time: {
19579
19575
  start: number;
19580
19576
  end: number;
19581
19577
  };
19582
19578
  type: "toolCall";
19579
+ } | {
19580
+ type: "thinking";
19581
+ thinking: string;
19582
+ thinkingSignature?: string;
19583
+ redacted?: boolean;
19583
19584
  } | {
19584
19585
  addedToolNames?: string[];
19585
19586
  arguments: Record<string, any>;
19586
19587
  callID: string;
19587
19588
  name: string;
19588
19589
  namespace?: string;
19589
- result: {
19590
- content: ({
19590
+ partial?: {
19591
+ content?: ({
19591
19592
  type: "text";
19592
19593
  text: string;
19593
19594
  textSignature?: string;
@@ -19597,9 +19598,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19597
19598
  mimeType: string;
19598
19599
  })[];
19599
19600
  details?: any;
19600
- isError: true;
19601
19601
  };
19602
- status: "aborted";
19602
+ status: "running";
19603
19603
  thoughtSignature?: string;
19604
19604
  time: {
19605
19605
  start: number;
@@ -20787,19 +20787,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20787
20787
  type: "image";
20788
20788
  data: string;
20789
20789
  mimeType: string;
20790
- } | {
20791
- type: "thinking";
20792
- thinking: string;
20793
- thinkingSignature?: string;
20794
- redacted?: boolean;
20795
20790
  } | {
20796
20791
  addedToolNames?: string[];
20797
20792
  arguments: Record<string, any>;
20798
20793
  callID: string;
20799
20794
  name: string;
20800
20795
  namespace?: string;
20801
- partial?: {
20802
- content?: ({
20796
+ result: {
20797
+ content: ({
20803
20798
  type: "text";
20804
20799
  text: string;
20805
20800
  textSignature?: string;
@@ -20809,8 +20804,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20809
20804
  mimeType: string;
20810
20805
  })[];
20811
20806
  details?: any;
20807
+ isError: false;
20812
20808
  };
20813
- status: "running";
20809
+ status: "completed";
20814
20810
  thoughtSignature?: string;
20815
20811
  time: {
20816
20812
  start: number;
@@ -20834,9 +20830,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20834
20830
  mimeType: string;
20835
20831
  })[];
20836
20832
  details?: any;
20837
- isError: false;
20833
+ isError: true;
20838
20834
  };
20839
- status: "completed";
20835
+ status: "error";
20840
20836
  thoughtSignature?: string;
20841
20837
  time: {
20842
20838
  start: number;
@@ -20862,7 +20858,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20862
20858
  details?: any;
20863
20859
  isError: true;
20864
20860
  };
20865
- status: "error";
20861
+ status: "skipped";
20866
20862
  thoughtSignature?: string;
20867
20863
  time: {
20868
20864
  start: number;
@@ -20888,21 +20884,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20888
20884
  details?: any;
20889
20885
  isError: true;
20890
20886
  };
20891
- status: "skipped";
20887
+ status: "aborted";
20892
20888
  thoughtSignature?: string;
20893
20889
  time: {
20894
20890
  start: number;
20895
20891
  end: number;
20896
20892
  };
20897
20893
  type: "toolCall";
20894
+ } | {
20895
+ type: "thinking";
20896
+ thinking: string;
20897
+ thinkingSignature?: string;
20898
+ redacted?: boolean;
20898
20899
  } | {
20899
20900
  addedToolNames?: string[];
20900
20901
  arguments: Record<string, any>;
20901
20902
  callID: string;
20902
20903
  name: string;
20903
20904
  namespace?: string;
20904
- result: {
20905
- content: ({
20905
+ partial?: {
20906
+ content?: ({
20906
20907
  type: "text";
20907
20908
  text: string;
20908
20909
  textSignature?: string;
@@ -20912,9 +20913,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20912
20913
  mimeType: string;
20913
20914
  })[];
20914
20915
  details?: any;
20915
- isError: true;
20916
20916
  };
20917
- status: "aborted";
20917
+ status: "running";
20918
20918
  thoughtSignature?: string;
20919
20919
  time: {
20920
20920
  start: number;
@@ -21089,19 +21089,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21089
21089
  type: "image";
21090
21090
  data: string;
21091
21091
  mimeType: string;
21092
- } | {
21093
- type: "thinking";
21094
- thinking: string;
21095
- thinkingSignature?: string;
21096
- redacted?: boolean;
21097
21092
  } | {
21098
21093
  addedToolNames?: string[];
21099
21094
  arguments: Record<string, any>;
21100
21095
  callID: string;
21101
21096
  name: string;
21102
21097
  namespace?: string;
21103
- partial?: {
21104
- content?: ({
21098
+ result: {
21099
+ content: ({
21105
21100
  type: "text";
21106
21101
  text: string;
21107
21102
  textSignature?: string;
@@ -21111,8 +21106,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21111
21106
  mimeType: string;
21112
21107
  })[];
21113
21108
  details?: any;
21109
+ isError: false;
21114
21110
  };
21115
- status: "running";
21111
+ status: "completed";
21116
21112
  thoughtSignature?: string;
21117
21113
  time: {
21118
21114
  start: number;
@@ -21136,9 +21132,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21136
21132
  mimeType: string;
21137
21133
  })[];
21138
21134
  details?: any;
21139
- isError: false;
21135
+ isError: true;
21140
21136
  };
21141
- status: "completed";
21137
+ status: "error";
21142
21138
  thoughtSignature?: string;
21143
21139
  time: {
21144
21140
  start: number;
@@ -21164,7 +21160,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21164
21160
  details?: any;
21165
21161
  isError: true;
21166
21162
  };
21167
- status: "error";
21163
+ status: "skipped";
21168
21164
  thoughtSignature?: string;
21169
21165
  time: {
21170
21166
  start: number;
@@ -21190,21 +21186,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21190
21186
  details?: any;
21191
21187
  isError: true;
21192
21188
  };
21193
- status: "skipped";
21189
+ status: "aborted";
21194
21190
  thoughtSignature?: string;
21195
21191
  time: {
21196
21192
  start: number;
21197
21193
  end: number;
21198
21194
  };
21199
21195
  type: "toolCall";
21196
+ } | {
21197
+ type: "thinking";
21198
+ thinking: string;
21199
+ thinkingSignature?: string;
21200
+ redacted?: boolean;
21200
21201
  } | {
21201
21202
  addedToolNames?: string[];
21202
21203
  arguments: Record<string, any>;
21203
21204
  callID: string;
21204
21205
  name: string;
21205
21206
  namespace?: string;
21206
- result: {
21207
- content: ({
21207
+ partial?: {
21208
+ content?: ({
21208
21209
  type: "text";
21209
21210
  text: string;
21210
21211
  textSignature?: string;
@@ -21214,9 +21215,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21214
21215
  mimeType: string;
21215
21216
  })[];
21216
21217
  details?: any;
21217
- isError: true;
21218
21218
  };
21219
- status: "aborted";
21219
+ status: "running";
21220
21220
  thoughtSignature?: string;
21221
21221
  time: {
21222
21222
  start: number;
@@ -21409,19 +21409,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21409
21409
  type: "image";
21410
21410
  data: string;
21411
21411
  mimeType: string;
21412
- } | {
21413
- type: "thinking";
21414
- thinking: string;
21415
- thinkingSignature?: string;
21416
- redacted?: boolean;
21417
21412
  } | {
21418
21413
  addedToolNames?: string[];
21419
21414
  arguments: Record<string, any>;
21420
21415
  callID: string;
21421
21416
  name: string;
21422
21417
  namespace?: string;
21423
- partial?: {
21424
- content?: ({
21418
+ result: {
21419
+ content: ({
21425
21420
  type: "text";
21426
21421
  text: string;
21427
21422
  textSignature?: string;
@@ -21431,8 +21426,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21431
21426
  mimeType: string;
21432
21427
  })[];
21433
21428
  details?: any;
21429
+ isError: false;
21434
21430
  };
21435
- status: "running";
21431
+ status: "completed";
21436
21432
  thoughtSignature?: string;
21437
21433
  time: {
21438
21434
  start: number;
@@ -21456,9 +21452,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21456
21452
  mimeType: string;
21457
21453
  })[];
21458
21454
  details?: any;
21459
- isError: false;
21455
+ isError: true;
21460
21456
  };
21461
- status: "completed";
21457
+ status: "error";
21462
21458
  thoughtSignature?: string;
21463
21459
  time: {
21464
21460
  start: number;
@@ -21484,7 +21480,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21484
21480
  details?: any;
21485
21481
  isError: true;
21486
21482
  };
21487
- status: "error";
21483
+ status: "skipped";
21488
21484
  thoughtSignature?: string;
21489
21485
  time: {
21490
21486
  start: number;
@@ -21510,21 +21506,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21510
21506
  details?: any;
21511
21507
  isError: true;
21512
21508
  };
21513
- status: "skipped";
21509
+ status: "aborted";
21514
21510
  thoughtSignature?: string;
21515
21511
  time: {
21516
21512
  start: number;
21517
21513
  end: number;
21518
21514
  };
21519
21515
  type: "toolCall";
21516
+ } | {
21517
+ type: "thinking";
21518
+ thinking: string;
21519
+ thinkingSignature?: string;
21520
+ redacted?: boolean;
21520
21521
  } | {
21521
21522
  addedToolNames?: string[];
21522
21523
  arguments: Record<string, any>;
21523
21524
  callID: string;
21524
21525
  name: string;
21525
21526
  namespace?: string;
21526
- result: {
21527
- content: ({
21527
+ partial?: {
21528
+ content?: ({
21528
21529
  type: "text";
21529
21530
  text: string;
21530
21531
  textSignature?: string;
@@ -21534,9 +21535,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21534
21535
  mimeType: string;
21535
21536
  })[];
21536
21537
  details?: any;
21537
- isError: true;
21538
21538
  };
21539
- status: "aborted";
21539
+ status: "running";
21540
21540
  thoughtSignature?: string;
21541
21541
  time: {
21542
21542
  start: number;
@@ -21711,19 +21711,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21711
21711
  type: "image";
21712
21712
  data: string;
21713
21713
  mimeType: string;
21714
- } | {
21715
- type: "thinking";
21716
- thinking: string;
21717
- thinkingSignature?: string;
21718
- redacted?: boolean;
21719
21714
  } | {
21720
21715
  addedToolNames?: string[];
21721
21716
  arguments: Record<string, any>;
21722
21717
  callID: string;
21723
21718
  name: string;
21724
21719
  namespace?: string;
21725
- partial?: {
21726
- content?: ({
21720
+ result: {
21721
+ content: ({
21727
21722
  type: "text";
21728
21723
  text: string;
21729
21724
  textSignature?: string;
@@ -21733,8 +21728,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21733
21728
  mimeType: string;
21734
21729
  })[];
21735
21730
  details?: any;
21731
+ isError: false;
21736
21732
  };
21737
- status: "running";
21733
+ status: "completed";
21738
21734
  thoughtSignature?: string;
21739
21735
  time: {
21740
21736
  start: number;
@@ -21758,9 +21754,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21758
21754
  mimeType: string;
21759
21755
  })[];
21760
21756
  details?: any;
21761
- isError: false;
21757
+ isError: true;
21762
21758
  };
21763
- status: "completed";
21759
+ status: "error";
21764
21760
  thoughtSignature?: string;
21765
21761
  time: {
21766
21762
  start: number;
@@ -21786,7 +21782,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21786
21782
  details?: any;
21787
21783
  isError: true;
21788
21784
  };
21789
- status: "error";
21785
+ status: "skipped";
21790
21786
  thoughtSignature?: string;
21791
21787
  time: {
21792
21788
  start: number;
@@ -21812,21 +21808,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21812
21808
  details?: any;
21813
21809
  isError: true;
21814
21810
  };
21815
- status: "skipped";
21811
+ status: "aborted";
21816
21812
  thoughtSignature?: string;
21817
21813
  time: {
21818
21814
  start: number;
21819
21815
  end: number;
21820
21816
  };
21821
21817
  type: "toolCall";
21818
+ } | {
21819
+ type: "thinking";
21820
+ thinking: string;
21821
+ thinkingSignature?: string;
21822
+ redacted?: boolean;
21822
21823
  } | {
21823
21824
  addedToolNames?: string[];
21824
21825
  arguments: Record<string, any>;
21825
21826
  callID: string;
21826
21827
  name: string;
21827
21828
  namespace?: string;
21828
- result: {
21829
- content: ({
21829
+ partial?: {
21830
+ content?: ({
21830
21831
  type: "text";
21831
21832
  text: string;
21832
21833
  textSignature?: string;
@@ -21836,9 +21837,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21836
21837
  mimeType: string;
21837
21838
  })[];
21838
21839
  details?: any;
21839
- isError: true;
21840
21840
  };
21841
- status: "aborted";
21841
+ status: "running";
21842
21842
  thoughtSignature?: string;
21843
21843
  time: {
21844
21844
  start: number;
@@ -22041,19 +22041,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22041
22041
  type: "image";
22042
22042
  data: string;
22043
22043
  mimeType: string;
22044
- } | {
22045
- type: "thinking";
22046
- thinking: string;
22047
- thinkingSignature?: string;
22048
- redacted?: boolean;
22049
22044
  } | {
22050
22045
  addedToolNames?: string[];
22051
22046
  arguments: Record<string, any>;
22052
22047
  callID: string;
22053
22048
  name: string;
22054
22049
  namespace?: string;
22055
- partial?: {
22056
- content?: ({
22050
+ result: {
22051
+ content: ({
22057
22052
  type: "text";
22058
22053
  text: string;
22059
22054
  textSignature?: string;
@@ -22063,8 +22058,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22063
22058
  mimeType: string;
22064
22059
  })[];
22065
22060
  details?: any;
22061
+ isError: false;
22066
22062
  };
22067
- status: "running";
22063
+ status: "completed";
22068
22064
  thoughtSignature?: string;
22069
22065
  time: {
22070
22066
  start: number;
@@ -22088,9 +22084,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22088
22084
  mimeType: string;
22089
22085
  })[];
22090
22086
  details?: any;
22091
- isError: false;
22087
+ isError: true;
22092
22088
  };
22093
- status: "completed";
22089
+ status: "error";
22094
22090
  thoughtSignature?: string;
22095
22091
  time: {
22096
22092
  start: number;
@@ -22116,7 +22112,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22116
22112
  details?: any;
22117
22113
  isError: true;
22118
22114
  };
22119
- status: "error";
22115
+ status: "skipped";
22120
22116
  thoughtSignature?: string;
22121
22117
  time: {
22122
22118
  start: number;
@@ -22142,21 +22138,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22142
22138
  details?: any;
22143
22139
  isError: true;
22144
22140
  };
22145
- status: "skipped";
22141
+ status: "aborted";
22146
22142
  thoughtSignature?: string;
22147
22143
  time: {
22148
22144
  start: number;
22149
22145
  end: number;
22150
22146
  };
22151
22147
  type: "toolCall";
22148
+ } | {
22149
+ type: "thinking";
22150
+ thinking: string;
22151
+ thinkingSignature?: string;
22152
+ redacted?: boolean;
22152
22153
  } | {
22153
22154
  addedToolNames?: string[];
22154
22155
  arguments: Record<string, any>;
22155
22156
  callID: string;
22156
22157
  name: string;
22157
22158
  namespace?: string;
22158
- result: {
22159
- content: ({
22159
+ partial?: {
22160
+ content?: ({
22160
22161
  type: "text";
22161
22162
  text: string;
22162
22163
  textSignature?: string;
@@ -22166,9 +22167,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22166
22167
  mimeType: string;
22167
22168
  })[];
22168
22169
  details?: any;
22169
- isError: true;
22170
22170
  };
22171
- status: "aborted";
22171
+ status: "running";
22172
22172
  thoughtSignature?: string;
22173
22173
  time: {
22174
22174
  start: number;
@@ -22343,19 +22343,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22343
22343
  type: "image";
22344
22344
  data: string;
22345
22345
  mimeType: string;
22346
- } | {
22347
- type: "thinking";
22348
- thinking: string;
22349
- thinkingSignature?: string;
22350
- redacted?: boolean;
22351
22346
  } | {
22352
22347
  addedToolNames?: string[];
22353
22348
  arguments: Record<string, any>;
22354
22349
  callID: string;
22355
22350
  name: string;
22356
22351
  namespace?: string;
22357
- partial?: {
22358
- content?: ({
22352
+ result: {
22353
+ content: ({
22359
22354
  type: "text";
22360
22355
  text: string;
22361
22356
  textSignature?: string;
@@ -22365,8 +22360,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22365
22360
  mimeType: string;
22366
22361
  })[];
22367
22362
  details?: any;
22363
+ isError: false;
22368
22364
  };
22369
- status: "running";
22365
+ status: "completed";
22370
22366
  thoughtSignature?: string;
22371
22367
  time: {
22372
22368
  start: number;
@@ -22390,9 +22386,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22390
22386
  mimeType: string;
22391
22387
  })[];
22392
22388
  details?: any;
22393
- isError: false;
22389
+ isError: true;
22394
22390
  };
22395
- status: "completed";
22391
+ status: "error";
22396
22392
  thoughtSignature?: string;
22397
22393
  time: {
22398
22394
  start: number;
@@ -22418,7 +22414,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22418
22414
  details?: any;
22419
22415
  isError: true;
22420
22416
  };
22421
- status: "error";
22417
+ status: "skipped";
22422
22418
  thoughtSignature?: string;
22423
22419
  time: {
22424
22420
  start: number;
@@ -22444,21 +22440,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22444
22440
  details?: any;
22445
22441
  isError: true;
22446
22442
  };
22447
- status: "skipped";
22443
+ status: "aborted";
22448
22444
  thoughtSignature?: string;
22449
22445
  time: {
22450
22446
  start: number;
22451
22447
  end: number;
22452
22448
  };
22453
22449
  type: "toolCall";
22450
+ } | {
22451
+ type: "thinking";
22452
+ thinking: string;
22453
+ thinkingSignature?: string;
22454
+ redacted?: boolean;
22454
22455
  } | {
22455
22456
  addedToolNames?: string[];
22456
22457
  arguments: Record<string, any>;
22457
22458
  callID: string;
22458
22459
  name: string;
22459
22460
  namespace?: string;
22460
- result: {
22461
- content: ({
22461
+ partial?: {
22462
+ content?: ({
22462
22463
  type: "text";
22463
22464
  text: string;
22464
22465
  textSignature?: string;
@@ -22468,9 +22469,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22468
22469
  mimeType: string;
22469
22470
  })[];
22470
22471
  details?: any;
22471
- isError: true;
22472
22472
  };
22473
- status: "aborted";
22473
+ status: "running";
22474
22474
  thoughtSignature?: string;
22475
22475
  time: {
22476
22476
  start: number;
@@ -22664,19 +22664,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22664
22664
  type: "image";
22665
22665
  data: string;
22666
22666
  mimeType: string;
22667
- } | {
22668
- type: "thinking";
22669
- thinking: string;
22670
- thinkingSignature?: string;
22671
- redacted?: boolean;
22672
22667
  } | {
22673
22668
  addedToolNames?: string[];
22674
22669
  arguments: Record<string, any>;
22675
22670
  callID: string;
22676
22671
  name: string;
22677
22672
  namespace?: string;
22678
- partial?: {
22679
- content?: ({
22673
+ result: {
22674
+ content: ({
22680
22675
  type: "text";
22681
22676
  text: string;
22682
22677
  textSignature?: string;
@@ -22686,8 +22681,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22686
22681
  mimeType: string;
22687
22682
  })[];
22688
22683
  details?: any;
22684
+ isError: false;
22689
22685
  };
22690
- status: "running";
22686
+ status: "completed";
22691
22687
  thoughtSignature?: string;
22692
22688
  time: {
22693
22689
  start: number;
@@ -22711,9 +22707,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22711
22707
  mimeType: string;
22712
22708
  })[];
22713
22709
  details?: any;
22714
- isError: false;
22710
+ isError: true;
22715
22711
  };
22716
- status: "completed";
22712
+ status: "error";
22717
22713
  thoughtSignature?: string;
22718
22714
  time: {
22719
22715
  start: number;
@@ -22739,7 +22735,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22739
22735
  details?: any;
22740
22736
  isError: true;
22741
22737
  };
22742
- status: "error";
22738
+ status: "skipped";
22743
22739
  thoughtSignature?: string;
22744
22740
  time: {
22745
22741
  start: number;
@@ -22765,21 +22761,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22765
22761
  details?: any;
22766
22762
  isError: true;
22767
22763
  };
22768
- status: "skipped";
22764
+ status: "aborted";
22769
22765
  thoughtSignature?: string;
22770
22766
  time: {
22771
22767
  start: number;
22772
22768
  end: number;
22773
22769
  };
22774
22770
  type: "toolCall";
22771
+ } | {
22772
+ type: "thinking";
22773
+ thinking: string;
22774
+ thinkingSignature?: string;
22775
+ redacted?: boolean;
22775
22776
  } | {
22776
22777
  addedToolNames?: string[];
22777
22778
  arguments: Record<string, any>;
22778
22779
  callID: string;
22779
22780
  name: string;
22780
22781
  namespace?: string;
22781
- result: {
22782
- content: ({
22782
+ partial?: {
22783
+ content?: ({
22783
22784
  type: "text";
22784
22785
  text: string;
22785
22786
  textSignature?: string;
@@ -22789,9 +22790,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22789
22790
  mimeType: string;
22790
22791
  })[];
22791
22792
  details?: any;
22792
- isError: true;
22793
22793
  };
22794
- status: "aborted";
22794
+ status: "running";
22795
22795
  thoughtSignature?: string;
22796
22796
  time: {
22797
22797
  start: number;
@@ -22966,19 +22966,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22966
22966
  type: "image";
22967
22967
  data: string;
22968
22968
  mimeType: string;
22969
- } | {
22970
- type: "thinking";
22971
- thinking: string;
22972
- thinkingSignature?: string;
22973
- redacted?: boolean;
22974
22969
  } | {
22975
22970
  addedToolNames?: string[];
22976
22971
  arguments: Record<string, any>;
22977
22972
  callID: string;
22978
22973
  name: string;
22979
22974
  namespace?: string;
22980
- partial?: {
22981
- content?: ({
22975
+ result: {
22976
+ content: ({
22982
22977
  type: "text";
22983
22978
  text: string;
22984
22979
  textSignature?: string;
@@ -22988,8 +22983,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22988
22983
  mimeType: string;
22989
22984
  })[];
22990
22985
  details?: any;
22986
+ isError: false;
22991
22987
  };
22992
- status: "running";
22988
+ status: "completed";
22993
22989
  thoughtSignature?: string;
22994
22990
  time: {
22995
22991
  start: number;
@@ -23013,9 +23009,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23013
23009
  mimeType: string;
23014
23010
  })[];
23015
23011
  details?: any;
23016
- isError: false;
23012
+ isError: true;
23017
23013
  };
23018
- status: "completed";
23014
+ status: "error";
23019
23015
  thoughtSignature?: string;
23020
23016
  time: {
23021
23017
  start: number;
@@ -23041,7 +23037,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23041
23037
  details?: any;
23042
23038
  isError: true;
23043
23039
  };
23044
- status: "error";
23040
+ status: "skipped";
23045
23041
  thoughtSignature?: string;
23046
23042
  time: {
23047
23043
  start: number;
@@ -23067,21 +23063,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23067
23063
  details?: any;
23068
23064
  isError: true;
23069
23065
  };
23070
- status: "skipped";
23066
+ status: "aborted";
23071
23067
  thoughtSignature?: string;
23072
23068
  time: {
23073
23069
  start: number;
23074
23070
  end: number;
23075
23071
  };
23076
23072
  type: "toolCall";
23073
+ } | {
23074
+ type: "thinking";
23075
+ thinking: string;
23076
+ thinkingSignature?: string;
23077
+ redacted?: boolean;
23077
23078
  } | {
23078
23079
  addedToolNames?: string[];
23079
23080
  arguments: Record<string, any>;
23080
23081
  callID: string;
23081
23082
  name: string;
23082
23083
  namespace?: string;
23083
- result: {
23084
- content: ({
23084
+ partial?: {
23085
+ content?: ({
23085
23086
  type: "text";
23086
23087
  text: string;
23087
23088
  textSignature?: string;
@@ -23091,9 +23092,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23091
23092
  mimeType: string;
23092
23093
  })[];
23093
23094
  details?: any;
23094
- isError: true;
23095
23095
  };
23096
- status: "aborted";
23096
+ status: "running";
23097
23097
  thoughtSignature?: string;
23098
23098
  time: {
23099
23099
  start: number;
@@ -23296,19 +23296,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23296
23296
  type: "image";
23297
23297
  data: string;
23298
23298
  mimeType: string;
23299
- } | {
23300
- type: "thinking";
23301
- thinking: string;
23302
- thinkingSignature?: string;
23303
- redacted?: boolean;
23304
23299
  } | {
23305
23300
  addedToolNames?: string[];
23306
23301
  arguments: Record<string, any>;
23307
23302
  callID: string;
23308
23303
  name: string;
23309
23304
  namespace?: string;
23310
- partial?: {
23311
- content?: ({
23305
+ result: {
23306
+ content: ({
23312
23307
  type: "text";
23313
23308
  text: string;
23314
23309
  textSignature?: string;
@@ -23318,8 +23313,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23318
23313
  mimeType: string;
23319
23314
  })[];
23320
23315
  details?: any;
23316
+ isError: false;
23321
23317
  };
23322
- status: "running";
23318
+ status: "completed";
23323
23319
  thoughtSignature?: string;
23324
23320
  time: {
23325
23321
  start: number;
@@ -23343,9 +23339,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23343
23339
  mimeType: string;
23344
23340
  })[];
23345
23341
  details?: any;
23346
- isError: false;
23342
+ isError: true;
23347
23343
  };
23348
- status: "completed";
23344
+ status: "error";
23349
23345
  thoughtSignature?: string;
23350
23346
  time: {
23351
23347
  start: number;
@@ -23371,7 +23367,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23371
23367
  details?: any;
23372
23368
  isError: true;
23373
23369
  };
23374
- status: "error";
23370
+ status: "skipped";
23375
23371
  thoughtSignature?: string;
23376
23372
  time: {
23377
23373
  start: number;
@@ -23397,21 +23393,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23397
23393
  details?: any;
23398
23394
  isError: true;
23399
23395
  };
23400
- status: "skipped";
23396
+ status: "aborted";
23401
23397
  thoughtSignature?: string;
23402
23398
  time: {
23403
23399
  start: number;
23404
23400
  end: number;
23405
23401
  };
23406
23402
  type: "toolCall";
23403
+ } | {
23404
+ type: "thinking";
23405
+ thinking: string;
23406
+ thinkingSignature?: string;
23407
+ redacted?: boolean;
23407
23408
  } | {
23408
23409
  addedToolNames?: string[];
23409
23410
  arguments: Record<string, any>;
23410
23411
  callID: string;
23411
23412
  name: string;
23412
23413
  namespace?: string;
23413
- result: {
23414
- content: ({
23414
+ partial?: {
23415
+ content?: ({
23415
23416
  type: "text";
23416
23417
  text: string;
23417
23418
  textSignature?: string;
@@ -23421,9 +23422,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23421
23422
  mimeType: string;
23422
23423
  })[];
23423
23424
  details?: any;
23424
- isError: true;
23425
23425
  };
23426
- status: "aborted";
23426
+ status: "running";
23427
23427
  thoughtSignature?: string;
23428
23428
  time: {
23429
23429
  start: number;
@@ -23598,19 +23598,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23598
23598
  type: "image";
23599
23599
  data: string;
23600
23600
  mimeType: string;
23601
- } | {
23602
- type: "thinking";
23603
- thinking: string;
23604
- thinkingSignature?: string;
23605
- redacted?: boolean;
23606
23601
  } | {
23607
23602
  addedToolNames?: string[];
23608
23603
  arguments: Record<string, any>;
23609
23604
  callID: string;
23610
23605
  name: string;
23611
23606
  namespace?: string;
23612
- partial?: {
23613
- content?: ({
23607
+ result: {
23608
+ content: ({
23614
23609
  type: "text";
23615
23610
  text: string;
23616
23611
  textSignature?: string;
@@ -23620,8 +23615,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23620
23615
  mimeType: string;
23621
23616
  })[];
23622
23617
  details?: any;
23618
+ isError: false;
23623
23619
  };
23624
- status: "running";
23620
+ status: "completed";
23625
23621
  thoughtSignature?: string;
23626
23622
  time: {
23627
23623
  start: number;
@@ -23645,9 +23641,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23645
23641
  mimeType: string;
23646
23642
  })[];
23647
23643
  details?: any;
23648
- isError: false;
23644
+ isError: true;
23649
23645
  };
23650
- status: "completed";
23646
+ status: "error";
23651
23647
  thoughtSignature?: string;
23652
23648
  time: {
23653
23649
  start: number;
@@ -23673,7 +23669,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23673
23669
  details?: any;
23674
23670
  isError: true;
23675
23671
  };
23676
- status: "error";
23672
+ status: "skipped";
23677
23673
  thoughtSignature?: string;
23678
23674
  time: {
23679
23675
  start: number;
@@ -23699,21 +23695,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23699
23695
  details?: any;
23700
23696
  isError: true;
23701
23697
  };
23702
- status: "skipped";
23698
+ status: "aborted";
23703
23699
  thoughtSignature?: string;
23704
23700
  time: {
23705
23701
  start: number;
23706
23702
  end: number;
23707
23703
  };
23708
23704
  type: "toolCall";
23705
+ } | {
23706
+ type: "thinking";
23707
+ thinking: string;
23708
+ thinkingSignature?: string;
23709
+ redacted?: boolean;
23709
23710
  } | {
23710
23711
  addedToolNames?: string[];
23711
23712
  arguments: Record<string, any>;
23712
23713
  callID: string;
23713
23714
  name: string;
23714
23715
  namespace?: string;
23715
- result: {
23716
- content: ({
23716
+ partial?: {
23717
+ content?: ({
23717
23718
  type: "text";
23718
23719
  text: string;
23719
23720
  textSignature?: string;
@@ -23723,9 +23724,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23723
23724
  mimeType: string;
23724
23725
  })[];
23725
23726
  details?: any;
23726
- isError: true;
23727
23727
  };
23728
- status: "aborted";
23728
+ status: "running";
23729
23729
  thoughtSignature?: string;
23730
23730
  time: {
23731
23731
  start: number;
@@ -23919,19 +23919,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23919
23919
  type: "image";
23920
23920
  data: string;
23921
23921
  mimeType: string;
23922
- } | {
23923
- type: "thinking";
23924
- thinking: string;
23925
- thinkingSignature?: string;
23926
- redacted?: boolean;
23927
23922
  } | {
23928
23923
  addedToolNames?: string[];
23929
23924
  arguments: Record<string, any>;
23930
23925
  callID: string;
23931
23926
  name: string;
23932
23927
  namespace?: string;
23933
- partial?: {
23934
- content?: ({
23928
+ result: {
23929
+ content: ({
23935
23930
  type: "text";
23936
23931
  text: string;
23937
23932
  textSignature?: string;
@@ -23941,8 +23936,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23941
23936
  mimeType: string;
23942
23937
  })[];
23943
23938
  details?: any;
23939
+ isError: false;
23944
23940
  };
23945
- status: "running";
23941
+ status: "completed";
23946
23942
  thoughtSignature?: string;
23947
23943
  time: {
23948
23944
  start: number;
@@ -23966,9 +23962,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23966
23962
  mimeType: string;
23967
23963
  })[];
23968
23964
  details?: any;
23969
- isError: false;
23965
+ isError: true;
23970
23966
  };
23971
- status: "completed";
23967
+ status: "error";
23972
23968
  thoughtSignature?: string;
23973
23969
  time: {
23974
23970
  start: number;
@@ -23994,7 +23990,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23994
23990
  details?: any;
23995
23991
  isError: true;
23996
23992
  };
23997
- status: "error";
23993
+ status: "skipped";
23998
23994
  thoughtSignature?: string;
23999
23995
  time: {
24000
23996
  start: number;
@@ -24020,21 +24016,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24020
24016
  details?: any;
24021
24017
  isError: true;
24022
24018
  };
24023
- status: "skipped";
24019
+ status: "aborted";
24024
24020
  thoughtSignature?: string;
24025
24021
  time: {
24026
24022
  start: number;
24027
24023
  end: number;
24028
24024
  };
24029
24025
  type: "toolCall";
24026
+ } | {
24027
+ type: "thinking";
24028
+ thinking: string;
24029
+ thinkingSignature?: string;
24030
+ redacted?: boolean;
24030
24031
  } | {
24031
24032
  addedToolNames?: string[];
24032
24033
  arguments: Record<string, any>;
24033
24034
  callID: string;
24034
24035
  name: string;
24035
24036
  namespace?: string;
24036
- result: {
24037
- content: ({
24037
+ partial?: {
24038
+ content?: ({
24038
24039
  type: "text";
24039
24040
  text: string;
24040
24041
  textSignature?: string;
@@ -24044,9 +24045,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24044
24045
  mimeType: string;
24045
24046
  })[];
24046
24047
  details?: any;
24047
- isError: true;
24048
24048
  };
24049
- status: "aborted";
24049
+ status: "running";
24050
24050
  thoughtSignature?: string;
24051
24051
  time: {
24052
24052
  start: number;
@@ -24221,19 +24221,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24221
24221
  type: "image";
24222
24222
  data: string;
24223
24223
  mimeType: string;
24224
- } | {
24225
- type: "thinking";
24226
- thinking: string;
24227
- thinkingSignature?: string;
24228
- redacted?: boolean;
24229
24224
  } | {
24230
24225
  addedToolNames?: string[];
24231
24226
  arguments: Record<string, any>;
24232
24227
  callID: string;
24233
24228
  name: string;
24234
24229
  namespace?: string;
24235
- partial?: {
24236
- content?: ({
24230
+ result: {
24231
+ content: ({
24237
24232
  type: "text";
24238
24233
  text: string;
24239
24234
  textSignature?: string;
@@ -24243,8 +24238,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24243
24238
  mimeType: string;
24244
24239
  })[];
24245
24240
  details?: any;
24241
+ isError: false;
24246
24242
  };
24247
- status: "running";
24243
+ status: "completed";
24248
24244
  thoughtSignature?: string;
24249
24245
  time: {
24250
24246
  start: number;
@@ -24268,9 +24264,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24268
24264
  mimeType: string;
24269
24265
  })[];
24270
24266
  details?: any;
24271
- isError: false;
24267
+ isError: true;
24272
24268
  };
24273
- status: "completed";
24269
+ status: "error";
24274
24270
  thoughtSignature?: string;
24275
24271
  time: {
24276
24272
  start: number;
@@ -24296,7 +24292,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24296
24292
  details?: any;
24297
24293
  isError: true;
24298
24294
  };
24299
- status: "error";
24295
+ status: "skipped";
24300
24296
  thoughtSignature?: string;
24301
24297
  time: {
24302
24298
  start: number;
@@ -24322,21 +24318,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24322
24318
  details?: any;
24323
24319
  isError: true;
24324
24320
  };
24325
- status: "skipped";
24321
+ status: "aborted";
24326
24322
  thoughtSignature?: string;
24327
24323
  time: {
24328
24324
  start: number;
24329
24325
  end: number;
24330
24326
  };
24331
24327
  type: "toolCall";
24328
+ } | {
24329
+ type: "thinking";
24330
+ thinking: string;
24331
+ thinkingSignature?: string;
24332
+ redacted?: boolean;
24332
24333
  } | {
24333
24334
  addedToolNames?: string[];
24334
24335
  arguments: Record<string, any>;
24335
24336
  callID: string;
24336
24337
  name: string;
24337
24338
  namespace?: string;
24338
- result: {
24339
- content: ({
24339
+ partial?: {
24340
+ content?: ({
24340
24341
  type: "text";
24341
24342
  text: string;
24342
24343
  textSignature?: string;
@@ -24346,9 +24347,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24346
24347
  mimeType: string;
24347
24348
  })[];
24348
24349
  details?: any;
24349
- isError: true;
24350
24350
  };
24351
- status: "aborted";
24351
+ status: "running";
24352
24352
  thoughtSignature?: string;
24353
24353
  time: {
24354
24354
  start: number;