@codeworksh/harness 0.3.0-canary.35.1.gd8b65e21 → 0.3.0-canary.37.1.g89a70d77

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 (4) hide show
  1. package/effect.d.mts +828 -823
  2. package/effect.mjs +5 -2
  3. package/effect.mjs.map +1 -1
  4. package/package.json +3 -3
package/effect.d.mts CHANGED
@@ -2733,6 +2733,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2733
2733
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2734
2734
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2735
2735
  declare const encodeMessage: (message: {
2736
+ messageId: string;
2737
+ role: "user";
2738
+ time: {
2739
+ created: number;
2740
+ };
2741
+ parts: ({
2742
+ type: "text";
2743
+ text: string;
2744
+ textSignature?: string;
2745
+ } | {
2746
+ type: "image";
2747
+ data: string;
2748
+ mimeType: string;
2749
+ })[];
2750
+ } | {
2736
2751
  role: "assistant";
2737
2752
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2738
2753
  provider: {
@@ -2882,19 +2897,14 @@ declare const encodeMessage: (message: {
2882
2897
  type: "image";
2883
2898
  data: string;
2884
2899
  mimeType: string;
2885
- } | {
2886
- type: "thinking";
2887
- thinking: string;
2888
- thinkingSignature?: string;
2889
- redacted?: boolean;
2890
2900
  } | {
2891
2901
  addedToolNames?: string[];
2892
2902
  arguments: Record<string, any>;
2893
2903
  callID: string;
2894
2904
  name: string;
2895
2905
  namespace?: string;
2896
- partial?: {
2897
- content?: ({
2906
+ result: {
2907
+ content: ({
2898
2908
  type: "text";
2899
2909
  text: string;
2900
2910
  textSignature?: string;
@@ -2904,8 +2914,9 @@ declare const encodeMessage: (message: {
2904
2914
  mimeType: string;
2905
2915
  })[];
2906
2916
  details?: any;
2917
+ isError: false;
2907
2918
  };
2908
- status: "running";
2919
+ status: "completed";
2909
2920
  thoughtSignature?: string;
2910
2921
  time: {
2911
2922
  start: number;
@@ -2929,9 +2940,9 @@ declare const encodeMessage: (message: {
2929
2940
  mimeType: string;
2930
2941
  })[];
2931
2942
  details?: any;
2932
- isError: false;
2943
+ isError: true;
2933
2944
  };
2934
- status: "completed";
2945
+ status: "error";
2935
2946
  thoughtSignature?: string;
2936
2947
  time: {
2937
2948
  start: number;
@@ -2957,7 +2968,7 @@ declare const encodeMessage: (message: {
2957
2968
  details?: any;
2958
2969
  isError: true;
2959
2970
  };
2960
- status: "error";
2971
+ status: "skipped";
2961
2972
  thoughtSignature?: string;
2962
2973
  time: {
2963
2974
  start: number;
@@ -2983,21 +2994,26 @@ declare const encodeMessage: (message: {
2983
2994
  details?: any;
2984
2995
  isError: true;
2985
2996
  };
2986
- status: "skipped";
2997
+ status: "aborted";
2987
2998
  thoughtSignature?: string;
2988
2999
  time: {
2989
3000
  start: number;
2990
3001
  end: number;
2991
3002
  };
2992
3003
  type: "toolCall";
3004
+ } | {
3005
+ type: "thinking";
3006
+ thinking: string;
3007
+ thinkingSignature?: string;
3008
+ redacted?: boolean;
2993
3009
  } | {
2994
3010
  addedToolNames?: string[];
2995
3011
  arguments: Record<string, any>;
2996
3012
  callID: string;
2997
3013
  name: string;
2998
3014
  namespace?: string;
2999
- result: {
3000
- content: ({
3015
+ partial?: {
3016
+ content?: ({
3001
3017
  type: "text";
3002
3018
  text: string;
3003
3019
  textSignature?: string;
@@ -3007,9 +3023,8 @@ declare const encodeMessage: (message: {
3007
3023
  mimeType: string;
3008
3024
  })[];
3009
3025
  details?: any;
3010
- isError: true;
3011
3026
  };
3012
- status: "aborted";
3027
+ status: "running";
3013
3028
  thoughtSignature?: string;
3014
3029
  time: {
3015
3030
  start: number;
@@ -3034,7 +3049,8 @@ declare const encodeMessage: (message: {
3034
3049
  responseId?: string;
3035
3050
  responseModel?: string;
3036
3051
  messageId: string;
3037
- } | {
3052
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3053
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3038
3054
  messageId: string;
3039
3055
  role: "user";
3040
3056
  time: {
@@ -3049,8 +3065,8 @@ declare const encodeMessage: (message: {
3049
3065
  data: string;
3050
3066
  mimeType: string;
3051
3067
  })[];
3052
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3053
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3068
+ }, ContextDecodeError, never>;
3069
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3054
3070
  messageId: string;
3055
3071
  role: "user";
3056
3072
  time: {
@@ -3065,8 +3081,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3065
3081
  data: string;
3066
3082
  mimeType: string;
3067
3083
  })[];
3068
- }, ContextDecodeError, never>;
3069
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3084
+ } | {
3070
3085
  role: "assistant";
3071
3086
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3072
3087
  provider: {
@@ -3216,19 +3231,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3216
3231
  type: "image";
3217
3232
  data: string;
3218
3233
  mimeType: string;
3219
- } | {
3220
- type: "thinking";
3221
- thinking: string;
3222
- thinkingSignature?: string;
3223
- redacted?: boolean;
3224
3234
  } | {
3225
3235
  addedToolNames?: string[];
3226
3236
  arguments: Record<string, any>;
3227
3237
  callID: string;
3228
3238
  name: string;
3229
3239
  namespace?: string;
3230
- partial?: {
3231
- content?: ({
3240
+ result: {
3241
+ content: ({
3232
3242
  type: "text";
3233
3243
  text: string;
3234
3244
  textSignature?: string;
@@ -3238,8 +3248,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3238
3248
  mimeType: string;
3239
3249
  })[];
3240
3250
  details?: any;
3251
+ isError: false;
3241
3252
  };
3242
- status: "running";
3253
+ status: "completed";
3243
3254
  thoughtSignature?: string;
3244
3255
  time: {
3245
3256
  start: number;
@@ -3263,9 +3274,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3263
3274
  mimeType: string;
3264
3275
  })[];
3265
3276
  details?: any;
3266
- isError: false;
3277
+ isError: true;
3267
3278
  };
3268
- status: "completed";
3279
+ status: "error";
3269
3280
  thoughtSignature?: string;
3270
3281
  time: {
3271
3282
  start: number;
@@ -3291,7 +3302,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3291
3302
  details?: any;
3292
3303
  isError: true;
3293
3304
  };
3294
- status: "error";
3305
+ status: "skipped";
3295
3306
  thoughtSignature?: string;
3296
3307
  time: {
3297
3308
  start: number;
@@ -3317,21 +3328,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3317
3328
  details?: any;
3318
3329
  isError: true;
3319
3330
  };
3320
- status: "skipped";
3331
+ status: "aborted";
3321
3332
  thoughtSignature?: string;
3322
3333
  time: {
3323
3334
  start: number;
3324
3335
  end: number;
3325
3336
  };
3326
3337
  type: "toolCall";
3338
+ } | {
3339
+ type: "thinking";
3340
+ thinking: string;
3341
+ thinkingSignature?: string;
3342
+ redacted?: boolean;
3327
3343
  } | {
3328
3344
  addedToolNames?: string[];
3329
3345
  arguments: Record<string, any>;
3330
3346
  callID: string;
3331
3347
  name: string;
3332
3348
  namespace?: string;
3333
- result: {
3334
- content: ({
3349
+ partial?: {
3350
+ content?: ({
3335
3351
  type: "text";
3336
3352
  text: string;
3337
3353
  textSignature?: string;
@@ -3341,9 +3357,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3341
3357
  mimeType: string;
3342
3358
  })[];
3343
3359
  details?: any;
3344
- isError: true;
3345
3360
  };
3346
- status: "aborted";
3361
+ status: "running";
3347
3362
  thoughtSignature?: string;
3348
3363
  time: {
3349
3364
  start: number;
@@ -3368,21 +3383,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3368
3383
  responseId?: string;
3369
3384
  responseModel?: string;
3370
3385
  messageId: string;
3371
- } | {
3372
- messageId: string;
3373
- role: "user";
3374
- time: {
3375
- created: number;
3376
- };
3377
- parts: ({
3378
- type: "text";
3379
- text: string;
3380
- textSignature?: string;
3381
- } | {
3382
- type: "image";
3383
- data: string;
3384
- mimeType: string;
3385
- })[];
3386
3386
  }, ContextDecodeError, never>;
3387
3387
  declare namespace context_d_exports {
3388
3388
  export { context_d_exports as Context, assemble_d_exports as ContextAssembly, codec_d_exports as ContextCodec, ContextDecodeError, ContextEncodeError, ContextInvariantError, ContextReadError, EncodedMessage, Interface$1 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$4 as layer, validateUserMessage };
@@ -4063,6 +4063,8 @@ interface Info$1 {
4063
4063
  readonly provider: string;
4064
4064
  readonly id: string;
4065
4065
  };
4066
+ /** The thinking level chosen for this session over settings; absent when settings decide. */
4067
+ readonly thinkingLevel?: Model.ThinkingLevel;
4066
4068
  }
4067
4069
  interface Handle {
4068
4070
  readonly id: ID$1;
@@ -4097,6 +4099,7 @@ declare const create$1: (input?: CreateInput | undefined) => Effect.Effect<{
4097
4099
  readonly provider: string;
4098
4100
  readonly id: string;
4099
4101
  };
4102
+ thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
4100
4103
  }, SessionNotFoundError, never>;
4101
4104
  prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
4102
4105
  run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4134,6 +4137,7 @@ declare const link: (input: {
4134
4137
  readonly provider: string;
4135
4138
  readonly id: string;
4136
4139
  };
4140
+ thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
4137
4141
  }, SessionNotFoundError, never>;
4138
4142
  prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
4139
4143
  run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4169,6 +4173,7 @@ declare const relink: (input: RelinkInput) => Effect.Effect<{
4169
4173
  readonly provider: string;
4170
4174
  readonly id: string;
4171
4175
  };
4176
+ thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
4172
4177
  }, SessionNotFoundError, never>;
4173
4178
  prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
4174
4179
  run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4868,19 +4873,14 @@ declare const LLMStarted: Schema.Struct<{
4868
4873
  type: "image";
4869
4874
  data: string;
4870
4875
  mimeType: string;
4871
- } | {
4872
- type: "thinking";
4873
- thinking: string;
4874
- thinkingSignature?: string;
4875
- redacted?: boolean;
4876
4876
  } | {
4877
4877
  addedToolNames?: string[];
4878
4878
  arguments: Record<string, any>;
4879
4879
  callID: string;
4880
4880
  name: string;
4881
4881
  namespace?: string;
4882
- partial?: {
4883
- content?: ({
4882
+ result: {
4883
+ content: ({
4884
4884
  type: "text";
4885
4885
  text: string;
4886
4886
  textSignature?: string;
@@ -4890,8 +4890,9 @@ declare const LLMStarted: Schema.Struct<{
4890
4890
  mimeType: string;
4891
4891
  })[];
4892
4892
  details?: any;
4893
+ isError: false;
4893
4894
  };
4894
- status: "running";
4895
+ status: "completed";
4895
4896
  thoughtSignature?: string;
4896
4897
  time: {
4897
4898
  start: number;
@@ -4915,9 +4916,9 @@ declare const LLMStarted: Schema.Struct<{
4915
4916
  mimeType: string;
4916
4917
  })[];
4917
4918
  details?: any;
4918
- isError: false;
4919
+ isError: true;
4919
4920
  };
4920
- status: "completed";
4921
+ status: "error";
4921
4922
  thoughtSignature?: string;
4922
4923
  time: {
4923
4924
  start: number;
@@ -4943,7 +4944,7 @@ declare const LLMStarted: Schema.Struct<{
4943
4944
  details?: any;
4944
4945
  isError: true;
4945
4946
  };
4946
- status: "error";
4947
+ status: "skipped";
4947
4948
  thoughtSignature?: string;
4948
4949
  time: {
4949
4950
  start: number;
@@ -4969,21 +4970,26 @@ declare const LLMStarted: Schema.Struct<{
4969
4970
  details?: any;
4970
4971
  isError: true;
4971
4972
  };
4972
- status: "skipped";
4973
+ status: "aborted";
4973
4974
  thoughtSignature?: string;
4974
4975
  time: {
4975
4976
  start: number;
4976
4977
  end: number;
4977
4978
  };
4978
4979
  type: "toolCall";
4980
+ } | {
4981
+ type: "thinking";
4982
+ thinking: string;
4983
+ thinkingSignature?: string;
4984
+ redacted?: boolean;
4979
4985
  } | {
4980
4986
  addedToolNames?: string[];
4981
4987
  arguments: Record<string, any>;
4982
4988
  callID: string;
4983
4989
  name: string;
4984
4990
  namespace?: string;
4985
- result: {
4986
- content: ({
4991
+ partial?: {
4992
+ content?: ({
4987
4993
  type: "text";
4988
4994
  text: string;
4989
4995
  textSignature?: string;
@@ -4993,9 +4999,8 @@ declare const LLMStarted: Schema.Struct<{
4993
4999
  mimeType: string;
4994
5000
  })[];
4995
5001
  details?: any;
4996
- isError: true;
4997
5002
  };
4998
- status: "aborted";
5003
+ status: "running";
4999
5004
  thoughtSignature?: string;
5000
5005
  time: {
5001
5006
  start: number;
@@ -5170,19 +5175,14 @@ declare const LLMStarted: Schema.Struct<{
5170
5175
  type: "image";
5171
5176
  data: string;
5172
5177
  mimeType: string;
5173
- } | {
5174
- type: "thinking";
5175
- thinking: string;
5176
- thinkingSignature?: string;
5177
- redacted?: boolean;
5178
5178
  } | {
5179
5179
  addedToolNames?: string[];
5180
5180
  arguments: Record<string, any>;
5181
5181
  callID: string;
5182
5182
  name: string;
5183
5183
  namespace?: string;
5184
- partial?: {
5185
- content?: ({
5184
+ result: {
5185
+ content: ({
5186
5186
  type: "text";
5187
5187
  text: string;
5188
5188
  textSignature?: string;
@@ -5192,8 +5192,9 @@ declare const LLMStarted: Schema.Struct<{
5192
5192
  mimeType: string;
5193
5193
  })[];
5194
5194
  details?: any;
5195
+ isError: false;
5195
5196
  };
5196
- status: "running";
5197
+ status: "completed";
5197
5198
  thoughtSignature?: string;
5198
5199
  time: {
5199
5200
  start: number;
@@ -5217,9 +5218,9 @@ declare const LLMStarted: Schema.Struct<{
5217
5218
  mimeType: string;
5218
5219
  })[];
5219
5220
  details?: any;
5220
- isError: false;
5221
+ isError: true;
5221
5222
  };
5222
- status: "completed";
5223
+ status: "error";
5223
5224
  thoughtSignature?: string;
5224
5225
  time: {
5225
5226
  start: number;
@@ -5245,7 +5246,7 @@ declare const LLMStarted: Schema.Struct<{
5245
5246
  details?: any;
5246
5247
  isError: true;
5247
5248
  };
5248
- status: "error";
5249
+ status: "skipped";
5249
5250
  thoughtSignature?: string;
5250
5251
  time: {
5251
5252
  start: number;
@@ -5271,21 +5272,26 @@ declare const LLMStarted: Schema.Struct<{
5271
5272
  details?: any;
5272
5273
  isError: true;
5273
5274
  };
5274
- status: "skipped";
5275
+ status: "aborted";
5275
5276
  thoughtSignature?: string;
5276
5277
  time: {
5277
5278
  start: number;
5278
5279
  end: number;
5279
5280
  };
5280
5281
  type: "toolCall";
5282
+ } | {
5283
+ type: "thinking";
5284
+ thinking: string;
5285
+ thinkingSignature?: string;
5286
+ redacted?: boolean;
5281
5287
  } | {
5282
5288
  addedToolNames?: string[];
5283
5289
  arguments: Record<string, any>;
5284
5290
  callID: string;
5285
5291
  name: string;
5286
5292
  namespace?: string;
5287
- result: {
5288
- content: ({
5293
+ partial?: {
5294
+ content?: ({
5289
5295
  type: "text";
5290
5296
  text: string;
5291
5297
  textSignature?: string;
@@ -5295,9 +5301,8 @@ declare const LLMStarted: Schema.Struct<{
5295
5301
  mimeType: string;
5296
5302
  })[];
5297
5303
  details?: any;
5298
- isError: true;
5299
5304
  };
5300
- status: "aborted";
5305
+ status: "running";
5301
5306
  thoughtSignature?: string;
5302
5307
  time: {
5303
5308
  start: number;
@@ -5490,19 +5495,14 @@ declare const LLMStarted: Schema.Struct<{
5490
5495
  type: "image";
5491
5496
  data: string;
5492
5497
  mimeType: string;
5493
- } | {
5494
- type: "thinking";
5495
- thinking: string;
5496
- thinkingSignature?: string;
5497
- redacted?: boolean;
5498
5498
  } | {
5499
5499
  addedToolNames?: string[];
5500
5500
  arguments: Record<string, any>;
5501
5501
  callID: string;
5502
5502
  name: string;
5503
5503
  namespace?: string;
5504
- partial?: {
5505
- content?: ({
5504
+ result: {
5505
+ content: ({
5506
5506
  type: "text";
5507
5507
  text: string;
5508
5508
  textSignature?: string;
@@ -5512,8 +5512,9 @@ declare const LLMStarted: Schema.Struct<{
5512
5512
  mimeType: string;
5513
5513
  })[];
5514
5514
  details?: any;
5515
+ isError: false;
5515
5516
  };
5516
- status: "running";
5517
+ status: "completed";
5517
5518
  thoughtSignature?: string;
5518
5519
  time: {
5519
5520
  start: number;
@@ -5537,9 +5538,9 @@ declare const LLMStarted: Schema.Struct<{
5537
5538
  mimeType: string;
5538
5539
  })[];
5539
5540
  details?: any;
5540
- isError: false;
5541
+ isError: true;
5541
5542
  };
5542
- status: "completed";
5543
+ status: "error";
5543
5544
  thoughtSignature?: string;
5544
5545
  time: {
5545
5546
  start: number;
@@ -5565,7 +5566,7 @@ declare const LLMStarted: Schema.Struct<{
5565
5566
  details?: any;
5566
5567
  isError: true;
5567
5568
  };
5568
- status: "error";
5569
+ status: "skipped";
5569
5570
  thoughtSignature?: string;
5570
5571
  time: {
5571
5572
  start: number;
@@ -5591,21 +5592,26 @@ declare const LLMStarted: Schema.Struct<{
5591
5592
  details?: any;
5592
5593
  isError: true;
5593
5594
  };
5594
- status: "skipped";
5595
+ status: "aborted";
5595
5596
  thoughtSignature?: string;
5596
5597
  time: {
5597
5598
  start: number;
5598
5599
  end: number;
5599
5600
  };
5600
5601
  type: "toolCall";
5602
+ } | {
5603
+ type: "thinking";
5604
+ thinking: string;
5605
+ thinkingSignature?: string;
5606
+ redacted?: boolean;
5601
5607
  } | {
5602
5608
  addedToolNames?: string[];
5603
5609
  arguments: Record<string, any>;
5604
5610
  callID: string;
5605
5611
  name: string;
5606
5612
  namespace?: string;
5607
- result: {
5608
- content: ({
5613
+ partial?: {
5614
+ content?: ({
5609
5615
  type: "text";
5610
5616
  text: string;
5611
5617
  textSignature?: string;
@@ -5615,9 +5621,8 @@ declare const LLMStarted: Schema.Struct<{
5615
5621
  mimeType: string;
5616
5622
  })[];
5617
5623
  details?: any;
5618
- isError: true;
5619
5624
  };
5620
- status: "aborted";
5625
+ status: "running";
5621
5626
  thoughtSignature?: string;
5622
5627
  time: {
5623
5628
  start: number;
@@ -5792,19 +5797,14 @@ declare const LLMStarted: Schema.Struct<{
5792
5797
  type: "image";
5793
5798
  data: string;
5794
5799
  mimeType: string;
5795
- } | {
5796
- type: "thinking";
5797
- thinking: string;
5798
- thinkingSignature?: string;
5799
- redacted?: boolean;
5800
5800
  } | {
5801
5801
  addedToolNames?: string[];
5802
5802
  arguments: Record<string, any>;
5803
5803
  callID: string;
5804
5804
  name: string;
5805
5805
  namespace?: string;
5806
- partial?: {
5807
- content?: ({
5806
+ result: {
5807
+ content: ({
5808
5808
  type: "text";
5809
5809
  text: string;
5810
5810
  textSignature?: string;
@@ -5814,8 +5814,9 @@ declare const LLMStarted: Schema.Struct<{
5814
5814
  mimeType: string;
5815
5815
  })[];
5816
5816
  details?: any;
5817
+ isError: false;
5817
5818
  };
5818
- status: "running";
5819
+ status: "completed";
5819
5820
  thoughtSignature?: string;
5820
5821
  time: {
5821
5822
  start: number;
@@ -5839,9 +5840,9 @@ declare const LLMStarted: Schema.Struct<{
5839
5840
  mimeType: string;
5840
5841
  })[];
5841
5842
  details?: any;
5842
- isError: false;
5843
+ isError: true;
5843
5844
  };
5844
- status: "completed";
5845
+ status: "error";
5845
5846
  thoughtSignature?: string;
5846
5847
  time: {
5847
5848
  start: number;
@@ -5867,7 +5868,7 @@ declare const LLMStarted: Schema.Struct<{
5867
5868
  details?: any;
5868
5869
  isError: true;
5869
5870
  };
5870
- status: "error";
5871
+ status: "skipped";
5871
5872
  thoughtSignature?: string;
5872
5873
  time: {
5873
5874
  start: number;
@@ -5893,21 +5894,26 @@ declare const LLMStarted: Schema.Struct<{
5893
5894
  details?: any;
5894
5895
  isError: true;
5895
5896
  };
5896
- status: "skipped";
5897
+ status: "aborted";
5897
5898
  thoughtSignature?: string;
5898
5899
  time: {
5899
5900
  start: number;
5900
5901
  end: number;
5901
5902
  };
5902
5903
  type: "toolCall";
5904
+ } | {
5905
+ type: "thinking";
5906
+ thinking: string;
5907
+ thinkingSignature?: string;
5908
+ redacted?: boolean;
5903
5909
  } | {
5904
5910
  addedToolNames?: string[];
5905
5911
  arguments: Record<string, any>;
5906
5912
  callID: string;
5907
5913
  name: string;
5908
5914
  namespace?: string;
5909
- result: {
5910
- content: ({
5915
+ partial?: {
5916
+ content?: ({
5911
5917
  type: "text";
5912
5918
  text: string;
5913
5919
  textSignature?: string;
@@ -5917,9 +5923,8 @@ declare const LLMStarted: Schema.Struct<{
5917
5923
  mimeType: string;
5918
5924
  })[];
5919
5925
  details?: any;
5920
- isError: true;
5921
5926
  };
5922
- status: "aborted";
5927
+ status: "running";
5923
5928
  thoughtSignature?: string;
5924
5929
  time: {
5925
5930
  start: number;
@@ -6415,19 +6420,14 @@ declare const LLMEnded: Schema.Struct<{
6415
6420
  type: "image";
6416
6421
  data: string;
6417
6422
  mimeType: string;
6418
- } | {
6419
- type: "thinking";
6420
- thinking: string;
6421
- thinkingSignature?: string;
6422
- redacted?: boolean;
6423
6423
  } | {
6424
6424
  addedToolNames?: string[];
6425
6425
  arguments: Record<string, any>;
6426
6426
  callID: string;
6427
6427
  name: string;
6428
6428
  namespace?: string;
6429
- partial?: {
6430
- content?: ({
6429
+ result: {
6430
+ content: ({
6431
6431
  type: "text";
6432
6432
  text: string;
6433
6433
  textSignature?: string;
@@ -6437,8 +6437,9 @@ declare const LLMEnded: Schema.Struct<{
6437
6437
  mimeType: string;
6438
6438
  })[];
6439
6439
  details?: any;
6440
+ isError: false;
6440
6441
  };
6441
- status: "running";
6442
+ status: "completed";
6442
6443
  thoughtSignature?: string;
6443
6444
  time: {
6444
6445
  start: number;
@@ -6462,9 +6463,9 @@ declare const LLMEnded: Schema.Struct<{
6462
6463
  mimeType: string;
6463
6464
  })[];
6464
6465
  details?: any;
6465
- isError: false;
6466
+ isError: true;
6466
6467
  };
6467
- status: "completed";
6468
+ status: "error";
6468
6469
  thoughtSignature?: string;
6469
6470
  time: {
6470
6471
  start: number;
@@ -6490,7 +6491,7 @@ declare const LLMEnded: Schema.Struct<{
6490
6491
  details?: any;
6491
6492
  isError: true;
6492
6493
  };
6493
- status: "error";
6494
+ status: "skipped";
6494
6495
  thoughtSignature?: string;
6495
6496
  time: {
6496
6497
  start: number;
@@ -6516,7 +6517,7 @@ declare const LLMEnded: Schema.Struct<{
6516
6517
  details?: any;
6517
6518
  isError: true;
6518
6519
  };
6519
- status: "skipped";
6520
+ status: "aborted";
6520
6521
  thoughtSignature?: string;
6521
6522
  time: {
6522
6523
  start: number;
@@ -6524,13 +6525,18 @@ declare const LLMEnded: Schema.Struct<{
6524
6525
  };
6525
6526
  type: "toolCall";
6526
6527
  } | {
6527
- addedToolNames?: string[];
6528
- arguments: Record<string, any>;
6529
- callID: string;
6528
+ type: "thinking";
6529
+ thinking: string;
6530
+ thinkingSignature?: string;
6531
+ redacted?: boolean;
6532
+ } | {
6533
+ addedToolNames?: string[];
6534
+ arguments: Record<string, any>;
6535
+ callID: string;
6530
6536
  name: string;
6531
6537
  namespace?: string;
6532
- result: {
6533
- content: ({
6538
+ partial?: {
6539
+ content?: ({
6534
6540
  type: "text";
6535
6541
  text: string;
6536
6542
  textSignature?: string;
@@ -6540,9 +6546,8 @@ declare const LLMEnded: Schema.Struct<{
6540
6546
  mimeType: string;
6541
6547
  })[];
6542
6548
  details?: any;
6543
- isError: true;
6544
6549
  };
6545
- status: "aborted";
6550
+ status: "running";
6546
6551
  thoughtSignature?: string;
6547
6552
  time: {
6548
6553
  start: number;
@@ -6717,19 +6722,14 @@ declare const LLMEnded: Schema.Struct<{
6717
6722
  type: "image";
6718
6723
  data: string;
6719
6724
  mimeType: string;
6720
- } | {
6721
- type: "thinking";
6722
- thinking: string;
6723
- thinkingSignature?: string;
6724
- redacted?: boolean;
6725
6725
  } | {
6726
6726
  addedToolNames?: string[];
6727
6727
  arguments: Record<string, any>;
6728
6728
  callID: string;
6729
6729
  name: string;
6730
6730
  namespace?: string;
6731
- partial?: {
6732
- content?: ({
6731
+ result: {
6732
+ content: ({
6733
6733
  type: "text";
6734
6734
  text: string;
6735
6735
  textSignature?: string;
@@ -6739,8 +6739,9 @@ declare const LLMEnded: Schema.Struct<{
6739
6739
  mimeType: string;
6740
6740
  })[];
6741
6741
  details?: any;
6742
+ isError: false;
6742
6743
  };
6743
- status: "running";
6744
+ status: "completed";
6744
6745
  thoughtSignature?: string;
6745
6746
  time: {
6746
6747
  start: number;
@@ -6764,9 +6765,9 @@ declare const LLMEnded: Schema.Struct<{
6764
6765
  mimeType: string;
6765
6766
  })[];
6766
6767
  details?: any;
6767
- isError: false;
6768
+ isError: true;
6768
6769
  };
6769
- status: "completed";
6770
+ status: "error";
6770
6771
  thoughtSignature?: string;
6771
6772
  time: {
6772
6773
  start: number;
@@ -6792,7 +6793,7 @@ declare const LLMEnded: Schema.Struct<{
6792
6793
  details?: any;
6793
6794
  isError: true;
6794
6795
  };
6795
- status: "error";
6796
+ status: "skipped";
6796
6797
  thoughtSignature?: string;
6797
6798
  time: {
6798
6799
  start: number;
@@ -6818,21 +6819,26 @@ declare const LLMEnded: Schema.Struct<{
6818
6819
  details?: any;
6819
6820
  isError: true;
6820
6821
  };
6821
- status: "skipped";
6822
+ status: "aborted";
6822
6823
  thoughtSignature?: string;
6823
6824
  time: {
6824
6825
  start: number;
6825
6826
  end: number;
6826
6827
  };
6827
6828
  type: "toolCall";
6829
+ } | {
6830
+ type: "thinking";
6831
+ thinking: string;
6832
+ thinkingSignature?: string;
6833
+ redacted?: boolean;
6828
6834
  } | {
6829
6835
  addedToolNames?: string[];
6830
6836
  arguments: Record<string, any>;
6831
6837
  callID: string;
6832
6838
  name: string;
6833
6839
  namespace?: string;
6834
- result: {
6835
- content: ({
6840
+ partial?: {
6841
+ content?: ({
6836
6842
  type: "text";
6837
6843
  text: string;
6838
6844
  textSignature?: string;
@@ -6842,9 +6848,8 @@ declare const LLMEnded: Schema.Struct<{
6842
6848
  mimeType: string;
6843
6849
  })[];
6844
6850
  details?: any;
6845
- isError: true;
6846
6851
  };
6847
- status: "aborted";
6852
+ status: "running";
6848
6853
  thoughtSignature?: string;
6849
6854
  time: {
6850
6855
  start: number;
@@ -7038,19 +7043,14 @@ declare const LLMEnded: Schema.Struct<{
7038
7043
  type: "image";
7039
7044
  data: string;
7040
7045
  mimeType: string;
7041
- } | {
7042
- type: "thinking";
7043
- thinking: string;
7044
- thinkingSignature?: string;
7045
- redacted?: boolean;
7046
7046
  } | {
7047
7047
  addedToolNames?: string[];
7048
7048
  arguments: Record<string, any>;
7049
7049
  callID: string;
7050
7050
  name: string;
7051
7051
  namespace?: string;
7052
- partial?: {
7053
- content?: ({
7052
+ result: {
7053
+ content: ({
7054
7054
  type: "text";
7055
7055
  text: string;
7056
7056
  textSignature?: string;
@@ -7060,8 +7060,9 @@ declare const LLMEnded: Schema.Struct<{
7060
7060
  mimeType: string;
7061
7061
  })[];
7062
7062
  details?: any;
7063
+ isError: false;
7063
7064
  };
7064
- status: "running";
7065
+ status: "completed";
7065
7066
  thoughtSignature?: string;
7066
7067
  time: {
7067
7068
  start: number;
@@ -7085,9 +7086,9 @@ declare const LLMEnded: Schema.Struct<{
7085
7086
  mimeType: string;
7086
7087
  })[];
7087
7088
  details?: any;
7088
- isError: false;
7089
+ isError: true;
7089
7090
  };
7090
- status: "completed";
7091
+ status: "error";
7091
7092
  thoughtSignature?: string;
7092
7093
  time: {
7093
7094
  start: number;
@@ -7113,7 +7114,7 @@ declare const LLMEnded: Schema.Struct<{
7113
7114
  details?: any;
7114
7115
  isError: true;
7115
7116
  };
7116
- status: "error";
7117
+ status: "skipped";
7117
7118
  thoughtSignature?: string;
7118
7119
  time: {
7119
7120
  start: number;
@@ -7139,21 +7140,26 @@ declare const LLMEnded: Schema.Struct<{
7139
7140
  details?: any;
7140
7141
  isError: true;
7141
7142
  };
7142
- status: "skipped";
7143
+ status: "aborted";
7143
7144
  thoughtSignature?: string;
7144
7145
  time: {
7145
7146
  start: number;
7146
7147
  end: number;
7147
7148
  };
7148
7149
  type: "toolCall";
7150
+ } | {
7151
+ type: "thinking";
7152
+ thinking: string;
7153
+ thinkingSignature?: string;
7154
+ redacted?: boolean;
7149
7155
  } | {
7150
7156
  addedToolNames?: string[];
7151
7157
  arguments: Record<string, any>;
7152
7158
  callID: string;
7153
7159
  name: string;
7154
7160
  namespace?: string;
7155
- result: {
7156
- content: ({
7161
+ partial?: {
7162
+ content?: ({
7157
7163
  type: "text";
7158
7164
  text: string;
7159
7165
  textSignature?: string;
@@ -7163,9 +7169,8 @@ declare const LLMEnded: Schema.Struct<{
7163
7169
  mimeType: string;
7164
7170
  })[];
7165
7171
  details?: any;
7166
- isError: true;
7167
7172
  };
7168
- status: "aborted";
7173
+ status: "running";
7169
7174
  thoughtSignature?: string;
7170
7175
  time: {
7171
7176
  start: number;
@@ -7340,19 +7345,14 @@ declare const LLMEnded: Schema.Struct<{
7340
7345
  type: "image";
7341
7346
  data: string;
7342
7347
  mimeType: string;
7343
- } | {
7344
- type: "thinking";
7345
- thinking: string;
7346
- thinkingSignature?: string;
7347
- redacted?: boolean;
7348
7348
  } | {
7349
7349
  addedToolNames?: string[];
7350
7350
  arguments: Record<string, any>;
7351
7351
  callID: string;
7352
7352
  name: string;
7353
7353
  namespace?: string;
7354
- partial?: {
7355
- content?: ({
7354
+ result: {
7355
+ content: ({
7356
7356
  type: "text";
7357
7357
  text: string;
7358
7358
  textSignature?: string;
@@ -7362,8 +7362,9 @@ declare const LLMEnded: Schema.Struct<{
7362
7362
  mimeType: string;
7363
7363
  })[];
7364
7364
  details?: any;
7365
+ isError: false;
7365
7366
  };
7366
- status: "running";
7367
+ status: "completed";
7367
7368
  thoughtSignature?: string;
7368
7369
  time: {
7369
7370
  start: number;
@@ -7387,9 +7388,9 @@ declare const LLMEnded: Schema.Struct<{
7387
7388
  mimeType: string;
7388
7389
  })[];
7389
7390
  details?: any;
7390
- isError: false;
7391
+ isError: true;
7391
7392
  };
7392
- status: "completed";
7393
+ status: "error";
7393
7394
  thoughtSignature?: string;
7394
7395
  time: {
7395
7396
  start: number;
@@ -7415,7 +7416,7 @@ declare const LLMEnded: Schema.Struct<{
7415
7416
  details?: any;
7416
7417
  isError: true;
7417
7418
  };
7418
- status: "error";
7419
+ status: "skipped";
7419
7420
  thoughtSignature?: string;
7420
7421
  time: {
7421
7422
  start: number;
@@ -7441,21 +7442,26 @@ declare const LLMEnded: Schema.Struct<{
7441
7442
  details?: any;
7442
7443
  isError: true;
7443
7444
  };
7444
- status: "skipped";
7445
+ status: "aborted";
7445
7446
  thoughtSignature?: string;
7446
7447
  time: {
7447
7448
  start: number;
7448
7449
  end: number;
7449
7450
  };
7450
7451
  type: "toolCall";
7452
+ } | {
7453
+ type: "thinking";
7454
+ thinking: string;
7455
+ thinkingSignature?: string;
7456
+ redacted?: boolean;
7451
7457
  } | {
7452
7458
  addedToolNames?: string[];
7453
7459
  arguments: Record<string, any>;
7454
7460
  callID: string;
7455
7461
  name: string;
7456
7462
  namespace?: string;
7457
- result: {
7458
- content: ({
7463
+ partial?: {
7464
+ content?: ({
7459
7465
  type: "text";
7460
7466
  text: string;
7461
7467
  textSignature?: string;
@@ -7465,9 +7471,8 @@ declare const LLMEnded: Schema.Struct<{
7465
7471
  mimeType: string;
7466
7472
  })[];
7467
7473
  details?: any;
7468
- isError: true;
7469
7474
  };
7470
- status: "aborted";
7475
+ status: "running";
7471
7476
  thoughtSignature?: string;
7472
7477
  time: {
7473
7478
  start: number;
@@ -7673,19 +7678,14 @@ declare const LLMFailed: Schema.Struct<{
7673
7678
  type: "image";
7674
7679
  data: string;
7675
7680
  mimeType: string;
7676
- } | {
7677
- type: "thinking";
7678
- thinking: string;
7679
- thinkingSignature?: string;
7680
- redacted?: boolean;
7681
7681
  } | {
7682
7682
  addedToolNames?: string[];
7683
7683
  arguments: Record<string, any>;
7684
7684
  callID: string;
7685
7685
  name: string;
7686
7686
  namespace?: string;
7687
- partial?: {
7688
- content?: ({
7687
+ result: {
7688
+ content: ({
7689
7689
  type: "text";
7690
7690
  text: string;
7691
7691
  textSignature?: string;
@@ -7695,8 +7695,9 @@ declare const LLMFailed: Schema.Struct<{
7695
7695
  mimeType: string;
7696
7696
  })[];
7697
7697
  details?: any;
7698
+ isError: false;
7698
7699
  };
7699
- status: "running";
7700
+ status: "completed";
7700
7701
  thoughtSignature?: string;
7701
7702
  time: {
7702
7703
  start: number;
@@ -7720,9 +7721,9 @@ declare const LLMFailed: Schema.Struct<{
7720
7721
  mimeType: string;
7721
7722
  })[];
7722
7723
  details?: any;
7723
- isError: false;
7724
+ isError: true;
7724
7725
  };
7725
- status: "completed";
7726
+ status: "error";
7726
7727
  thoughtSignature?: string;
7727
7728
  time: {
7728
7729
  start: number;
@@ -7748,7 +7749,7 @@ declare const LLMFailed: Schema.Struct<{
7748
7749
  details?: any;
7749
7750
  isError: true;
7750
7751
  };
7751
- status: "error";
7752
+ status: "skipped";
7752
7753
  thoughtSignature?: string;
7753
7754
  time: {
7754
7755
  start: number;
@@ -7774,21 +7775,26 @@ declare const LLMFailed: Schema.Struct<{
7774
7775
  details?: any;
7775
7776
  isError: true;
7776
7777
  };
7777
- status: "skipped";
7778
+ status: "aborted";
7778
7779
  thoughtSignature?: string;
7779
7780
  time: {
7780
7781
  start: number;
7781
7782
  end: number;
7782
7783
  };
7783
7784
  type: "toolCall";
7785
+ } | {
7786
+ type: "thinking";
7787
+ thinking: string;
7788
+ thinkingSignature?: string;
7789
+ redacted?: boolean;
7784
7790
  } | {
7785
7791
  addedToolNames?: string[];
7786
7792
  arguments: Record<string, any>;
7787
7793
  callID: string;
7788
7794
  name: string;
7789
7795
  namespace?: string;
7790
- result: {
7791
- content: ({
7796
+ partial?: {
7797
+ content?: ({
7792
7798
  type: "text";
7793
7799
  text: string;
7794
7800
  textSignature?: string;
@@ -7798,9 +7804,8 @@ declare const LLMFailed: Schema.Struct<{
7798
7804
  mimeType: string;
7799
7805
  })[];
7800
7806
  details?: any;
7801
- isError: true;
7802
7807
  };
7803
- status: "aborted";
7808
+ status: "running";
7804
7809
  thoughtSignature?: string;
7805
7810
  time: {
7806
7811
  start: number;
@@ -7975,19 +7980,14 @@ declare const LLMFailed: Schema.Struct<{
7975
7980
  type: "image";
7976
7981
  data: string;
7977
7982
  mimeType: string;
7978
- } | {
7979
- type: "thinking";
7980
- thinking: string;
7981
- thinkingSignature?: string;
7982
- redacted?: boolean;
7983
7983
  } | {
7984
7984
  addedToolNames?: string[];
7985
7985
  arguments: Record<string, any>;
7986
7986
  callID: string;
7987
7987
  name: string;
7988
7988
  namespace?: string;
7989
- partial?: {
7990
- content?: ({
7989
+ result: {
7990
+ content: ({
7991
7991
  type: "text";
7992
7992
  text: string;
7993
7993
  textSignature?: string;
@@ -7997,8 +7997,9 @@ declare const LLMFailed: Schema.Struct<{
7997
7997
  mimeType: string;
7998
7998
  })[];
7999
7999
  details?: any;
8000
+ isError: false;
8000
8001
  };
8001
- status: "running";
8002
+ status: "completed";
8002
8003
  thoughtSignature?: string;
8003
8004
  time: {
8004
8005
  start: number;
@@ -8022,9 +8023,9 @@ declare const LLMFailed: Schema.Struct<{
8022
8023
  mimeType: string;
8023
8024
  })[];
8024
8025
  details?: any;
8025
- isError: false;
8026
+ isError: true;
8026
8027
  };
8027
- status: "completed";
8028
+ status: "error";
8028
8029
  thoughtSignature?: string;
8029
8030
  time: {
8030
8031
  start: number;
@@ -8050,7 +8051,7 @@ declare const LLMFailed: Schema.Struct<{
8050
8051
  details?: any;
8051
8052
  isError: true;
8052
8053
  };
8053
- status: "error";
8054
+ status: "skipped";
8054
8055
  thoughtSignature?: string;
8055
8056
  time: {
8056
8057
  start: number;
@@ -8076,21 +8077,26 @@ declare const LLMFailed: Schema.Struct<{
8076
8077
  details?: any;
8077
8078
  isError: true;
8078
8079
  };
8079
- status: "skipped";
8080
+ status: "aborted";
8080
8081
  thoughtSignature?: string;
8081
8082
  time: {
8082
8083
  start: number;
8083
8084
  end: number;
8084
8085
  };
8085
8086
  type: "toolCall";
8087
+ } | {
8088
+ type: "thinking";
8089
+ thinking: string;
8090
+ thinkingSignature?: string;
8091
+ redacted?: boolean;
8086
8092
  } | {
8087
8093
  addedToolNames?: string[];
8088
8094
  arguments: Record<string, any>;
8089
8095
  callID: string;
8090
8096
  name: string;
8091
8097
  namespace?: string;
8092
- result: {
8093
- content: ({
8098
+ partial?: {
8099
+ content?: ({
8094
8100
  type: "text";
8095
8101
  text: string;
8096
8102
  textSignature?: string;
@@ -8100,9 +8106,8 @@ declare const LLMFailed: Schema.Struct<{
8100
8106
  mimeType: string;
8101
8107
  })[];
8102
8108
  details?: any;
8103
- isError: true;
8104
8109
  };
8105
- status: "aborted";
8110
+ status: "running";
8106
8111
  thoughtSignature?: string;
8107
8112
  time: {
8108
8113
  start: number;
@@ -8296,19 +8301,14 @@ declare const LLMFailed: Schema.Struct<{
8296
8301
  type: "image";
8297
8302
  data: string;
8298
8303
  mimeType: string;
8299
- } | {
8300
- type: "thinking";
8301
- thinking: string;
8302
- thinkingSignature?: string;
8303
- redacted?: boolean;
8304
8304
  } | {
8305
8305
  addedToolNames?: string[];
8306
8306
  arguments: Record<string, any>;
8307
8307
  callID: string;
8308
8308
  name: string;
8309
8309
  namespace?: string;
8310
- partial?: {
8311
- content?: ({
8310
+ result: {
8311
+ content: ({
8312
8312
  type: "text";
8313
8313
  text: string;
8314
8314
  textSignature?: string;
@@ -8318,8 +8318,9 @@ declare const LLMFailed: Schema.Struct<{
8318
8318
  mimeType: string;
8319
8319
  })[];
8320
8320
  details?: any;
8321
+ isError: false;
8321
8322
  };
8322
- status: "running";
8323
+ status: "completed";
8323
8324
  thoughtSignature?: string;
8324
8325
  time: {
8325
8326
  start: number;
@@ -8343,9 +8344,9 @@ declare const LLMFailed: Schema.Struct<{
8343
8344
  mimeType: string;
8344
8345
  })[];
8345
8346
  details?: any;
8346
- isError: false;
8347
+ isError: true;
8347
8348
  };
8348
- status: "completed";
8349
+ status: "error";
8349
8350
  thoughtSignature?: string;
8350
8351
  time: {
8351
8352
  start: number;
@@ -8371,7 +8372,7 @@ declare const LLMFailed: Schema.Struct<{
8371
8372
  details?: any;
8372
8373
  isError: true;
8373
8374
  };
8374
- status: "error";
8375
+ status: "skipped";
8375
8376
  thoughtSignature?: string;
8376
8377
  time: {
8377
8378
  start: number;
@@ -8397,21 +8398,26 @@ declare const LLMFailed: Schema.Struct<{
8397
8398
  details?: any;
8398
8399
  isError: true;
8399
8400
  };
8400
- status: "skipped";
8401
+ status: "aborted";
8401
8402
  thoughtSignature?: string;
8402
8403
  time: {
8403
8404
  start: number;
8404
8405
  end: number;
8405
8406
  };
8406
8407
  type: "toolCall";
8408
+ } | {
8409
+ type: "thinking";
8410
+ thinking: string;
8411
+ thinkingSignature?: string;
8412
+ redacted?: boolean;
8407
8413
  } | {
8408
8414
  addedToolNames?: string[];
8409
8415
  arguments: Record<string, any>;
8410
8416
  callID: string;
8411
8417
  name: string;
8412
8418
  namespace?: string;
8413
- result: {
8414
- content: ({
8419
+ partial?: {
8420
+ content?: ({
8415
8421
  type: "text";
8416
8422
  text: string;
8417
8423
  textSignature?: string;
@@ -8421,9 +8427,8 @@ declare const LLMFailed: Schema.Struct<{
8421
8427
  mimeType: string;
8422
8428
  })[];
8423
8429
  details?: any;
8424
- isError: true;
8425
8430
  };
8426
- status: "aborted";
8431
+ status: "running";
8427
8432
  thoughtSignature?: string;
8428
8433
  time: {
8429
8434
  start: number;
@@ -8598,19 +8603,14 @@ declare const LLMFailed: Schema.Struct<{
8598
8603
  type: "image";
8599
8604
  data: string;
8600
8605
  mimeType: string;
8601
- } | {
8602
- type: "thinking";
8603
- thinking: string;
8604
- thinkingSignature?: string;
8605
- redacted?: boolean;
8606
8606
  } | {
8607
8607
  addedToolNames?: string[];
8608
8608
  arguments: Record<string, any>;
8609
8609
  callID: string;
8610
8610
  name: string;
8611
8611
  namespace?: string;
8612
- partial?: {
8613
- content?: ({
8612
+ result: {
8613
+ content: ({
8614
8614
  type: "text";
8615
8615
  text: string;
8616
8616
  textSignature?: string;
@@ -8620,8 +8620,9 @@ declare const LLMFailed: Schema.Struct<{
8620
8620
  mimeType: string;
8621
8621
  })[];
8622
8622
  details?: any;
8623
+ isError: false;
8623
8624
  };
8624
- status: "running";
8625
+ status: "completed";
8625
8626
  thoughtSignature?: string;
8626
8627
  time: {
8627
8628
  start: number;
@@ -8645,9 +8646,9 @@ declare const LLMFailed: Schema.Struct<{
8645
8646
  mimeType: string;
8646
8647
  })[];
8647
8648
  details?: any;
8648
- isError: false;
8649
+ isError: true;
8649
8650
  };
8650
- status: "completed";
8651
+ status: "error";
8651
8652
  thoughtSignature?: string;
8652
8653
  time: {
8653
8654
  start: number;
@@ -8673,7 +8674,7 @@ declare const LLMFailed: Schema.Struct<{
8673
8674
  details?: any;
8674
8675
  isError: true;
8675
8676
  };
8676
- status: "error";
8677
+ status: "skipped";
8677
8678
  thoughtSignature?: string;
8678
8679
  time: {
8679
8680
  start: number;
@@ -8699,21 +8700,26 @@ declare const LLMFailed: Schema.Struct<{
8699
8700
  details?: any;
8700
8701
  isError: true;
8701
8702
  };
8702
- status: "skipped";
8703
+ status: "aborted";
8703
8704
  thoughtSignature?: string;
8704
8705
  time: {
8705
8706
  start: number;
8706
8707
  end: number;
8707
8708
  };
8708
8709
  type: "toolCall";
8710
+ } | {
8711
+ type: "thinking";
8712
+ thinking: string;
8713
+ thinkingSignature?: string;
8714
+ redacted?: boolean;
8709
8715
  } | {
8710
8716
  addedToolNames?: string[];
8711
8717
  arguments: Record<string, any>;
8712
8718
  callID: string;
8713
8719
  name: string;
8714
8720
  namespace?: string;
8715
- result: {
8716
- content: ({
8721
+ partial?: {
8722
+ content?: ({
8717
8723
  type: "text";
8718
8724
  text: string;
8719
8725
  textSignature?: string;
@@ -8723,9 +8729,8 @@ declare const LLMFailed: Schema.Struct<{
8723
8729
  mimeType: string;
8724
8730
  })[];
8725
8731
  details?: any;
8726
- isError: true;
8727
8732
  };
8728
- status: "aborted";
8733
+ status: "running";
8729
8734
  thoughtSignature?: string;
8730
8735
  time: {
8731
8736
  start: number;
@@ -10473,19 +10478,14 @@ declare const Definitions: readonly [Schema.Struct<{
10473
10478
  type: "image";
10474
10479
  data: string;
10475
10480
  mimeType: string;
10476
- } | {
10477
- type: "thinking";
10478
- thinking: string;
10479
- thinkingSignature?: string;
10480
- redacted?: boolean;
10481
10481
  } | {
10482
10482
  addedToolNames?: string[];
10483
10483
  arguments: Record<string, any>;
10484
10484
  callID: string;
10485
10485
  name: string;
10486
10486
  namespace?: string;
10487
- partial?: {
10488
- content?: ({
10487
+ result: {
10488
+ content: ({
10489
10489
  type: "text";
10490
10490
  text: string;
10491
10491
  textSignature?: string;
@@ -10495,8 +10495,9 @@ declare const Definitions: readonly [Schema.Struct<{
10495
10495
  mimeType: string;
10496
10496
  })[];
10497
10497
  details?: any;
10498
+ isError: false;
10498
10499
  };
10499
- status: "running";
10500
+ status: "completed";
10500
10501
  thoughtSignature?: string;
10501
10502
  time: {
10502
10503
  start: number;
@@ -10520,9 +10521,9 @@ declare const Definitions: readonly [Schema.Struct<{
10520
10521
  mimeType: string;
10521
10522
  })[];
10522
10523
  details?: any;
10523
- isError: false;
10524
+ isError: true;
10524
10525
  };
10525
- status: "completed";
10526
+ status: "error";
10526
10527
  thoughtSignature?: string;
10527
10528
  time: {
10528
10529
  start: number;
@@ -10548,7 +10549,7 @@ declare const Definitions: readonly [Schema.Struct<{
10548
10549
  details?: any;
10549
10550
  isError: true;
10550
10551
  };
10551
- status: "error";
10552
+ status: "skipped";
10552
10553
  thoughtSignature?: string;
10553
10554
  time: {
10554
10555
  start: number;
@@ -10574,21 +10575,26 @@ declare const Definitions: readonly [Schema.Struct<{
10574
10575
  details?: any;
10575
10576
  isError: true;
10576
10577
  };
10577
- status: "skipped";
10578
+ status: "aborted";
10578
10579
  thoughtSignature?: string;
10579
10580
  time: {
10580
10581
  start: number;
10581
10582
  end: number;
10582
10583
  };
10583
10584
  type: "toolCall";
10585
+ } | {
10586
+ type: "thinking";
10587
+ thinking: string;
10588
+ thinkingSignature?: string;
10589
+ redacted?: boolean;
10584
10590
  } | {
10585
10591
  addedToolNames?: string[];
10586
10592
  arguments: Record<string, any>;
10587
10593
  callID: string;
10588
10594
  name: string;
10589
10595
  namespace?: string;
10590
- result: {
10591
- content: ({
10596
+ partial?: {
10597
+ content?: ({
10592
10598
  type: "text";
10593
10599
  text: string;
10594
10600
  textSignature?: string;
@@ -10598,9 +10604,8 @@ declare const Definitions: readonly [Schema.Struct<{
10598
10604
  mimeType: string;
10599
10605
  })[];
10600
10606
  details?: any;
10601
- isError: true;
10602
10607
  };
10603
- status: "aborted";
10608
+ status: "running";
10604
10609
  thoughtSignature?: string;
10605
10610
  time: {
10606
10611
  start: number;
@@ -10775,19 +10780,14 @@ declare const Definitions: readonly [Schema.Struct<{
10775
10780
  type: "image";
10776
10781
  data: string;
10777
10782
  mimeType: string;
10778
- } | {
10779
- type: "thinking";
10780
- thinking: string;
10781
- thinkingSignature?: string;
10782
- redacted?: boolean;
10783
10783
  } | {
10784
10784
  addedToolNames?: string[];
10785
10785
  arguments: Record<string, any>;
10786
10786
  callID: string;
10787
10787
  name: string;
10788
10788
  namespace?: string;
10789
- partial?: {
10790
- content?: ({
10789
+ result: {
10790
+ content: ({
10791
10791
  type: "text";
10792
10792
  text: string;
10793
10793
  textSignature?: string;
@@ -10797,8 +10797,9 @@ declare const Definitions: readonly [Schema.Struct<{
10797
10797
  mimeType: string;
10798
10798
  })[];
10799
10799
  details?: any;
10800
+ isError: false;
10800
10801
  };
10801
- status: "running";
10802
+ status: "completed";
10802
10803
  thoughtSignature?: string;
10803
10804
  time: {
10804
10805
  start: number;
@@ -10822,9 +10823,9 @@ declare const Definitions: readonly [Schema.Struct<{
10822
10823
  mimeType: string;
10823
10824
  })[];
10824
10825
  details?: any;
10825
- isError: false;
10826
+ isError: true;
10826
10827
  };
10827
- status: "completed";
10828
+ status: "error";
10828
10829
  thoughtSignature?: string;
10829
10830
  time: {
10830
10831
  start: number;
@@ -10850,7 +10851,7 @@ declare const Definitions: readonly [Schema.Struct<{
10850
10851
  details?: any;
10851
10852
  isError: true;
10852
10853
  };
10853
- status: "error";
10854
+ status: "skipped";
10854
10855
  thoughtSignature?: string;
10855
10856
  time: {
10856
10857
  start: number;
@@ -10876,21 +10877,26 @@ declare const Definitions: readonly [Schema.Struct<{
10876
10877
  details?: any;
10877
10878
  isError: true;
10878
10879
  };
10879
- status: "skipped";
10880
+ status: "aborted";
10880
10881
  thoughtSignature?: string;
10881
10882
  time: {
10882
10883
  start: number;
10883
10884
  end: number;
10884
10885
  };
10885
10886
  type: "toolCall";
10887
+ } | {
10888
+ type: "thinking";
10889
+ thinking: string;
10890
+ thinkingSignature?: string;
10891
+ redacted?: boolean;
10886
10892
  } | {
10887
10893
  addedToolNames?: string[];
10888
10894
  arguments: Record<string, any>;
10889
10895
  callID: string;
10890
10896
  name: string;
10891
10897
  namespace?: string;
10892
- result: {
10893
- content: ({
10898
+ partial?: {
10899
+ content?: ({
10894
10900
  type: "text";
10895
10901
  text: string;
10896
10902
  textSignature?: string;
@@ -10900,9 +10906,8 @@ declare const Definitions: readonly [Schema.Struct<{
10900
10906
  mimeType: string;
10901
10907
  })[];
10902
10908
  details?: any;
10903
- isError: true;
10904
10909
  };
10905
- status: "aborted";
10910
+ status: "running";
10906
10911
  thoughtSignature?: string;
10907
10912
  time: {
10908
10913
  start: number;
@@ -11095,19 +11100,14 @@ declare const Definitions: readonly [Schema.Struct<{
11095
11100
  type: "image";
11096
11101
  data: string;
11097
11102
  mimeType: string;
11098
- } | {
11099
- type: "thinking";
11100
- thinking: string;
11101
- thinkingSignature?: string;
11102
- redacted?: boolean;
11103
11103
  } | {
11104
11104
  addedToolNames?: string[];
11105
11105
  arguments: Record<string, any>;
11106
11106
  callID: string;
11107
11107
  name: string;
11108
11108
  namespace?: string;
11109
- partial?: {
11110
- content?: ({
11109
+ result: {
11110
+ content: ({
11111
11111
  type: "text";
11112
11112
  text: string;
11113
11113
  textSignature?: string;
@@ -11117,8 +11117,9 @@ declare const Definitions: readonly [Schema.Struct<{
11117
11117
  mimeType: string;
11118
11118
  })[];
11119
11119
  details?: any;
11120
+ isError: false;
11120
11121
  };
11121
- status: "running";
11122
+ status: "completed";
11122
11123
  thoughtSignature?: string;
11123
11124
  time: {
11124
11125
  start: number;
@@ -11142,9 +11143,9 @@ declare const Definitions: readonly [Schema.Struct<{
11142
11143
  mimeType: string;
11143
11144
  })[];
11144
11145
  details?: any;
11145
- isError: false;
11146
+ isError: true;
11146
11147
  };
11147
- status: "completed";
11148
+ status: "error";
11148
11149
  thoughtSignature?: string;
11149
11150
  time: {
11150
11151
  start: number;
@@ -11170,7 +11171,7 @@ declare const Definitions: readonly [Schema.Struct<{
11170
11171
  details?: any;
11171
11172
  isError: true;
11172
11173
  };
11173
- status: "error";
11174
+ status: "skipped";
11174
11175
  thoughtSignature?: string;
11175
11176
  time: {
11176
11177
  start: number;
@@ -11196,21 +11197,26 @@ declare const Definitions: readonly [Schema.Struct<{
11196
11197
  details?: any;
11197
11198
  isError: true;
11198
11199
  };
11199
- status: "skipped";
11200
+ status: "aborted";
11200
11201
  thoughtSignature?: string;
11201
11202
  time: {
11202
11203
  start: number;
11203
11204
  end: number;
11204
11205
  };
11205
11206
  type: "toolCall";
11207
+ } | {
11208
+ type: "thinking";
11209
+ thinking: string;
11210
+ thinkingSignature?: string;
11211
+ redacted?: boolean;
11206
11212
  } | {
11207
11213
  addedToolNames?: string[];
11208
11214
  arguments: Record<string, any>;
11209
11215
  callID: string;
11210
11216
  name: string;
11211
11217
  namespace?: string;
11212
- result: {
11213
- content: ({
11218
+ partial?: {
11219
+ content?: ({
11214
11220
  type: "text";
11215
11221
  text: string;
11216
11222
  textSignature?: string;
@@ -11220,9 +11226,8 @@ declare const Definitions: readonly [Schema.Struct<{
11220
11226
  mimeType: string;
11221
11227
  })[];
11222
11228
  details?: any;
11223
- isError: true;
11224
11229
  };
11225
- status: "aborted";
11230
+ status: "running";
11226
11231
  thoughtSignature?: string;
11227
11232
  time: {
11228
11233
  start: number;
@@ -11397,19 +11402,14 @@ declare const Definitions: readonly [Schema.Struct<{
11397
11402
  type: "image";
11398
11403
  data: string;
11399
11404
  mimeType: string;
11400
- } | {
11401
- type: "thinking";
11402
- thinking: string;
11403
- thinkingSignature?: string;
11404
- redacted?: boolean;
11405
11405
  } | {
11406
11406
  addedToolNames?: string[];
11407
11407
  arguments: Record<string, any>;
11408
11408
  callID: string;
11409
11409
  name: string;
11410
11410
  namespace?: string;
11411
- partial?: {
11412
- content?: ({
11411
+ result: {
11412
+ content: ({
11413
11413
  type: "text";
11414
11414
  text: string;
11415
11415
  textSignature?: string;
@@ -11419,8 +11419,9 @@ declare const Definitions: readonly [Schema.Struct<{
11419
11419
  mimeType: string;
11420
11420
  })[];
11421
11421
  details?: any;
11422
+ isError: false;
11422
11423
  };
11423
- status: "running";
11424
+ status: "completed";
11424
11425
  thoughtSignature?: string;
11425
11426
  time: {
11426
11427
  start: number;
@@ -11444,9 +11445,9 @@ declare const Definitions: readonly [Schema.Struct<{
11444
11445
  mimeType: string;
11445
11446
  })[];
11446
11447
  details?: any;
11447
- isError: false;
11448
+ isError: true;
11448
11449
  };
11449
- status: "completed";
11450
+ status: "error";
11450
11451
  thoughtSignature?: string;
11451
11452
  time: {
11452
11453
  start: number;
@@ -11472,7 +11473,7 @@ declare const Definitions: readonly [Schema.Struct<{
11472
11473
  details?: any;
11473
11474
  isError: true;
11474
11475
  };
11475
- status: "error";
11476
+ status: "skipped";
11476
11477
  thoughtSignature?: string;
11477
11478
  time: {
11478
11479
  start: number;
@@ -11498,21 +11499,26 @@ declare const Definitions: readonly [Schema.Struct<{
11498
11499
  details?: any;
11499
11500
  isError: true;
11500
11501
  };
11501
- status: "skipped";
11502
+ status: "aborted";
11502
11503
  thoughtSignature?: string;
11503
11504
  time: {
11504
11505
  start: number;
11505
11506
  end: number;
11506
11507
  };
11507
11508
  type: "toolCall";
11509
+ } | {
11510
+ type: "thinking";
11511
+ thinking: string;
11512
+ thinkingSignature?: string;
11513
+ redacted?: boolean;
11508
11514
  } | {
11509
11515
  addedToolNames?: string[];
11510
11516
  arguments: Record<string, any>;
11511
11517
  callID: string;
11512
11518
  name: string;
11513
11519
  namespace?: string;
11514
- result: {
11515
- content: ({
11520
+ partial?: {
11521
+ content?: ({
11516
11522
  type: "text";
11517
11523
  text: string;
11518
11524
  textSignature?: string;
@@ -11522,9 +11528,8 @@ declare const Definitions: readonly [Schema.Struct<{
11522
11528
  mimeType: string;
11523
11529
  })[];
11524
11530
  details?: any;
11525
- isError: true;
11526
11531
  };
11527
- status: "aborted";
11532
+ status: "running";
11528
11533
  thoughtSignature?: string;
11529
11534
  time: {
11530
11535
  start: number;
@@ -12005,19 +12010,14 @@ declare const Definitions: readonly [Schema.Struct<{
12005
12010
  type: "image";
12006
12011
  data: string;
12007
12012
  mimeType: string;
12008
- } | {
12009
- type: "thinking";
12010
- thinking: string;
12011
- thinkingSignature?: string;
12012
- redacted?: boolean;
12013
12013
  } | {
12014
12014
  addedToolNames?: string[];
12015
12015
  arguments: Record<string, any>;
12016
12016
  callID: string;
12017
12017
  name: string;
12018
12018
  namespace?: string;
12019
- partial?: {
12020
- content?: ({
12019
+ result: {
12020
+ content: ({
12021
12021
  type: "text";
12022
12022
  text: string;
12023
12023
  textSignature?: string;
@@ -12027,8 +12027,9 @@ declare const Definitions: readonly [Schema.Struct<{
12027
12027
  mimeType: string;
12028
12028
  })[];
12029
12029
  details?: any;
12030
+ isError: false;
12030
12031
  };
12031
- status: "running";
12032
+ status: "completed";
12032
12033
  thoughtSignature?: string;
12033
12034
  time: {
12034
12035
  start: number;
@@ -12052,9 +12053,9 @@ declare const Definitions: readonly [Schema.Struct<{
12052
12053
  mimeType: string;
12053
12054
  })[];
12054
12055
  details?: any;
12055
- isError: false;
12056
+ isError: true;
12056
12057
  };
12057
- status: "completed";
12058
+ status: "error";
12058
12059
  thoughtSignature?: string;
12059
12060
  time: {
12060
12061
  start: number;
@@ -12080,7 +12081,7 @@ declare const Definitions: readonly [Schema.Struct<{
12080
12081
  details?: any;
12081
12082
  isError: true;
12082
12083
  };
12083
- status: "error";
12084
+ status: "skipped";
12084
12085
  thoughtSignature?: string;
12085
12086
  time: {
12086
12087
  start: number;
@@ -12106,21 +12107,26 @@ declare const Definitions: readonly [Schema.Struct<{
12106
12107
  details?: any;
12107
12108
  isError: true;
12108
12109
  };
12109
- status: "skipped";
12110
+ status: "aborted";
12110
12111
  thoughtSignature?: string;
12111
12112
  time: {
12112
12113
  start: number;
12113
12114
  end: number;
12114
12115
  };
12115
12116
  type: "toolCall";
12117
+ } | {
12118
+ type: "thinking";
12119
+ thinking: string;
12120
+ thinkingSignature?: string;
12121
+ redacted?: boolean;
12116
12122
  } | {
12117
12123
  addedToolNames?: string[];
12118
12124
  arguments: Record<string, any>;
12119
12125
  callID: string;
12120
12126
  name: string;
12121
12127
  namespace?: string;
12122
- result: {
12123
- content: ({
12128
+ partial?: {
12129
+ content?: ({
12124
12130
  type: "text";
12125
12131
  text: string;
12126
12132
  textSignature?: string;
@@ -12130,9 +12136,8 @@ declare const Definitions: readonly [Schema.Struct<{
12130
12136
  mimeType: string;
12131
12137
  })[];
12132
12138
  details?: any;
12133
- isError: true;
12134
12139
  };
12135
- status: "aborted";
12140
+ status: "running";
12136
12141
  thoughtSignature?: string;
12137
12142
  time: {
12138
12143
  start: number;
@@ -12307,19 +12312,14 @@ declare const Definitions: readonly [Schema.Struct<{
12307
12312
  type: "image";
12308
12313
  data: string;
12309
12314
  mimeType: string;
12310
- } | {
12311
- type: "thinking";
12312
- thinking: string;
12313
- thinkingSignature?: string;
12314
- redacted?: boolean;
12315
12315
  } | {
12316
12316
  addedToolNames?: string[];
12317
12317
  arguments: Record<string, any>;
12318
12318
  callID: string;
12319
12319
  name: string;
12320
12320
  namespace?: string;
12321
- partial?: {
12322
- content?: ({
12321
+ result: {
12322
+ content: ({
12323
12323
  type: "text";
12324
12324
  text: string;
12325
12325
  textSignature?: string;
@@ -12329,8 +12329,9 @@ declare const Definitions: readonly [Schema.Struct<{
12329
12329
  mimeType: string;
12330
12330
  })[];
12331
12331
  details?: any;
12332
+ isError: false;
12332
12333
  };
12333
- status: "running";
12334
+ status: "completed";
12334
12335
  thoughtSignature?: string;
12335
12336
  time: {
12336
12337
  start: number;
@@ -12354,9 +12355,9 @@ declare const Definitions: readonly [Schema.Struct<{
12354
12355
  mimeType: string;
12355
12356
  })[];
12356
12357
  details?: any;
12357
- isError: false;
12358
+ isError: true;
12358
12359
  };
12359
- status: "completed";
12360
+ status: "error";
12360
12361
  thoughtSignature?: string;
12361
12362
  time: {
12362
12363
  start: number;
@@ -12382,7 +12383,7 @@ declare const Definitions: readonly [Schema.Struct<{
12382
12383
  details?: any;
12383
12384
  isError: true;
12384
12385
  };
12385
- status: "error";
12386
+ status: "skipped";
12386
12387
  thoughtSignature?: string;
12387
12388
  time: {
12388
12389
  start: number;
@@ -12408,21 +12409,26 @@ declare const Definitions: readonly [Schema.Struct<{
12408
12409
  details?: any;
12409
12410
  isError: true;
12410
12411
  };
12411
- status: "skipped";
12412
+ status: "aborted";
12412
12413
  thoughtSignature?: string;
12413
12414
  time: {
12414
12415
  start: number;
12415
12416
  end: number;
12416
12417
  };
12417
12418
  type: "toolCall";
12419
+ } | {
12420
+ type: "thinking";
12421
+ thinking: string;
12422
+ thinkingSignature?: string;
12423
+ redacted?: boolean;
12418
12424
  } | {
12419
12425
  addedToolNames?: string[];
12420
12426
  arguments: Record<string, any>;
12421
12427
  callID: string;
12422
12428
  name: string;
12423
12429
  namespace?: string;
12424
- result: {
12425
- content: ({
12430
+ partial?: {
12431
+ content?: ({
12426
12432
  type: "text";
12427
12433
  text: string;
12428
12434
  textSignature?: string;
@@ -12432,9 +12438,8 @@ declare const Definitions: readonly [Schema.Struct<{
12432
12438
  mimeType: string;
12433
12439
  })[];
12434
12440
  details?: any;
12435
- isError: true;
12436
12441
  };
12437
- status: "aborted";
12442
+ status: "running";
12438
12443
  thoughtSignature?: string;
12439
12444
  time: {
12440
12445
  start: number;
@@ -12628,19 +12633,14 @@ declare const Definitions: readonly [Schema.Struct<{
12628
12633
  type: "image";
12629
12634
  data: string;
12630
12635
  mimeType: string;
12631
- } | {
12632
- type: "thinking";
12633
- thinking: string;
12634
- thinkingSignature?: string;
12635
- redacted?: boolean;
12636
12636
  } | {
12637
12637
  addedToolNames?: string[];
12638
12638
  arguments: Record<string, any>;
12639
12639
  callID: string;
12640
12640
  name: string;
12641
12641
  namespace?: string;
12642
- partial?: {
12643
- content?: ({
12642
+ result: {
12643
+ content: ({
12644
12644
  type: "text";
12645
12645
  text: string;
12646
12646
  textSignature?: string;
@@ -12650,8 +12650,9 @@ declare const Definitions: readonly [Schema.Struct<{
12650
12650
  mimeType: string;
12651
12651
  })[];
12652
12652
  details?: any;
12653
+ isError: false;
12653
12654
  };
12654
- status: "running";
12655
+ status: "completed";
12655
12656
  thoughtSignature?: string;
12656
12657
  time: {
12657
12658
  start: number;
@@ -12675,9 +12676,9 @@ declare const Definitions: readonly [Schema.Struct<{
12675
12676
  mimeType: string;
12676
12677
  })[];
12677
12678
  details?: any;
12678
- isError: false;
12679
+ isError: true;
12679
12680
  };
12680
- status: "completed";
12681
+ status: "error";
12681
12682
  thoughtSignature?: string;
12682
12683
  time: {
12683
12684
  start: number;
@@ -12703,7 +12704,7 @@ declare const Definitions: readonly [Schema.Struct<{
12703
12704
  details?: any;
12704
12705
  isError: true;
12705
12706
  };
12706
- status: "error";
12707
+ status: "skipped";
12707
12708
  thoughtSignature?: string;
12708
12709
  time: {
12709
12710
  start: number;
@@ -12729,21 +12730,26 @@ declare const Definitions: readonly [Schema.Struct<{
12729
12730
  details?: any;
12730
12731
  isError: true;
12731
12732
  };
12732
- status: "skipped";
12733
+ status: "aborted";
12733
12734
  thoughtSignature?: string;
12734
12735
  time: {
12735
12736
  start: number;
12736
12737
  end: number;
12737
12738
  };
12738
12739
  type: "toolCall";
12740
+ } | {
12741
+ type: "thinking";
12742
+ thinking: string;
12743
+ thinkingSignature?: string;
12744
+ redacted?: boolean;
12739
12745
  } | {
12740
12746
  addedToolNames?: string[];
12741
12747
  arguments: Record<string, any>;
12742
12748
  callID: string;
12743
12749
  name: string;
12744
12750
  namespace?: string;
12745
- result: {
12746
- content: ({
12751
+ partial?: {
12752
+ content?: ({
12747
12753
  type: "text";
12748
12754
  text: string;
12749
12755
  textSignature?: string;
@@ -12753,9 +12759,8 @@ declare const Definitions: readonly [Schema.Struct<{
12753
12759
  mimeType: string;
12754
12760
  })[];
12755
12761
  details?: any;
12756
- isError: true;
12757
12762
  };
12758
- status: "aborted";
12763
+ status: "running";
12759
12764
  thoughtSignature?: string;
12760
12765
  time: {
12761
12766
  start: number;
@@ -12930,19 +12935,14 @@ declare const Definitions: readonly [Schema.Struct<{
12930
12935
  type: "image";
12931
12936
  data: string;
12932
12937
  mimeType: string;
12933
- } | {
12934
- type: "thinking";
12935
- thinking: string;
12936
- thinkingSignature?: string;
12937
- redacted?: boolean;
12938
12938
  } | {
12939
12939
  addedToolNames?: string[];
12940
12940
  arguments: Record<string, any>;
12941
12941
  callID: string;
12942
12942
  name: string;
12943
12943
  namespace?: string;
12944
- partial?: {
12945
- content?: ({
12944
+ result: {
12945
+ content: ({
12946
12946
  type: "text";
12947
12947
  text: string;
12948
12948
  textSignature?: string;
@@ -12952,8 +12952,9 @@ declare const Definitions: readonly [Schema.Struct<{
12952
12952
  mimeType: string;
12953
12953
  })[];
12954
12954
  details?: any;
12955
+ isError: false;
12955
12956
  };
12956
- status: "running";
12957
+ status: "completed";
12957
12958
  thoughtSignature?: string;
12958
12959
  time: {
12959
12960
  start: number;
@@ -12977,9 +12978,9 @@ declare const Definitions: readonly [Schema.Struct<{
12977
12978
  mimeType: string;
12978
12979
  })[];
12979
12980
  details?: any;
12980
- isError: false;
12981
+ isError: true;
12981
12982
  };
12982
- status: "completed";
12983
+ status: "error";
12983
12984
  thoughtSignature?: string;
12984
12985
  time: {
12985
12986
  start: number;
@@ -13005,7 +13006,7 @@ declare const Definitions: readonly [Schema.Struct<{
13005
13006
  details?: any;
13006
13007
  isError: true;
13007
13008
  };
13008
- status: "error";
13009
+ status: "skipped";
13009
13010
  thoughtSignature?: string;
13010
13011
  time: {
13011
13012
  start: number;
@@ -13031,21 +13032,26 @@ declare const Definitions: readonly [Schema.Struct<{
13031
13032
  details?: any;
13032
13033
  isError: true;
13033
13034
  };
13034
- status: "skipped";
13035
+ status: "aborted";
13035
13036
  thoughtSignature?: string;
13036
13037
  time: {
13037
13038
  start: number;
13038
13039
  end: number;
13039
13040
  };
13040
13041
  type: "toolCall";
13042
+ } | {
13043
+ type: "thinking";
13044
+ thinking: string;
13045
+ thinkingSignature?: string;
13046
+ redacted?: boolean;
13041
13047
  } | {
13042
13048
  addedToolNames?: string[];
13043
13049
  arguments: Record<string, any>;
13044
13050
  callID: string;
13045
13051
  name: string;
13046
13052
  namespace?: string;
13047
- result: {
13048
- content: ({
13053
+ partial?: {
13054
+ content?: ({
13049
13055
  type: "text";
13050
13056
  text: string;
13051
13057
  textSignature?: string;
@@ -13055,9 +13061,8 @@ declare const Definitions: readonly [Schema.Struct<{
13055
13061
  mimeType: string;
13056
13062
  })[];
13057
13063
  details?: any;
13058
- isError: true;
13059
13064
  };
13060
- status: "aborted";
13065
+ status: "running";
13061
13066
  thoughtSignature?: string;
13062
13067
  time: {
13063
13068
  start: number;
@@ -13260,19 +13265,14 @@ declare const Definitions: readonly [Schema.Struct<{
13260
13265
  type: "image";
13261
13266
  data: string;
13262
13267
  mimeType: string;
13263
- } | {
13264
- type: "thinking";
13265
- thinking: string;
13266
- thinkingSignature?: string;
13267
- redacted?: boolean;
13268
13268
  } | {
13269
13269
  addedToolNames?: string[];
13270
13270
  arguments: Record<string, any>;
13271
13271
  callID: string;
13272
13272
  name: string;
13273
13273
  namespace?: string;
13274
- partial?: {
13275
- content?: ({
13274
+ result: {
13275
+ content: ({
13276
13276
  type: "text";
13277
13277
  text: string;
13278
13278
  textSignature?: string;
@@ -13282,8 +13282,9 @@ declare const Definitions: readonly [Schema.Struct<{
13282
13282
  mimeType: string;
13283
13283
  })[];
13284
13284
  details?: any;
13285
+ isError: false;
13285
13286
  };
13286
- status: "running";
13287
+ status: "completed";
13287
13288
  thoughtSignature?: string;
13288
13289
  time: {
13289
13290
  start: number;
@@ -13307,9 +13308,9 @@ declare const Definitions: readonly [Schema.Struct<{
13307
13308
  mimeType: string;
13308
13309
  })[];
13309
13310
  details?: any;
13310
- isError: false;
13311
+ isError: true;
13311
13312
  };
13312
- status: "completed";
13313
+ status: "error";
13313
13314
  thoughtSignature?: string;
13314
13315
  time: {
13315
13316
  start: number;
@@ -13335,7 +13336,7 @@ declare const Definitions: readonly [Schema.Struct<{
13335
13336
  details?: any;
13336
13337
  isError: true;
13337
13338
  };
13338
- status: "error";
13339
+ status: "skipped";
13339
13340
  thoughtSignature?: string;
13340
13341
  time: {
13341
13342
  start: number;
@@ -13361,21 +13362,26 @@ declare const Definitions: readonly [Schema.Struct<{
13361
13362
  details?: any;
13362
13363
  isError: true;
13363
13364
  };
13364
- status: "skipped";
13365
+ status: "aborted";
13365
13366
  thoughtSignature?: string;
13366
13367
  time: {
13367
13368
  start: number;
13368
13369
  end: number;
13369
13370
  };
13370
13371
  type: "toolCall";
13372
+ } | {
13373
+ type: "thinking";
13374
+ thinking: string;
13375
+ thinkingSignature?: string;
13376
+ redacted?: boolean;
13371
13377
  } | {
13372
13378
  addedToolNames?: string[];
13373
13379
  arguments: Record<string, any>;
13374
13380
  callID: string;
13375
13381
  name: string;
13376
13382
  namespace?: string;
13377
- result: {
13378
- content: ({
13383
+ partial?: {
13384
+ content?: ({
13379
13385
  type: "text";
13380
13386
  text: string;
13381
13387
  textSignature?: string;
@@ -13385,9 +13391,8 @@ declare const Definitions: readonly [Schema.Struct<{
13385
13391
  mimeType: string;
13386
13392
  })[];
13387
13393
  details?: any;
13388
- isError: true;
13389
13394
  };
13390
- status: "aborted";
13395
+ status: "running";
13391
13396
  thoughtSignature?: string;
13392
13397
  time: {
13393
13398
  start: number;
@@ -13562,19 +13567,14 @@ declare const Definitions: readonly [Schema.Struct<{
13562
13567
  type: "image";
13563
13568
  data: string;
13564
13569
  mimeType: string;
13565
- } | {
13566
- type: "thinking";
13567
- thinking: string;
13568
- thinkingSignature?: string;
13569
- redacted?: boolean;
13570
13570
  } | {
13571
13571
  addedToolNames?: string[];
13572
13572
  arguments: Record<string, any>;
13573
13573
  callID: string;
13574
13574
  name: string;
13575
13575
  namespace?: string;
13576
- partial?: {
13577
- content?: ({
13576
+ result: {
13577
+ content: ({
13578
13578
  type: "text";
13579
13579
  text: string;
13580
13580
  textSignature?: string;
@@ -13584,8 +13584,9 @@ declare const Definitions: readonly [Schema.Struct<{
13584
13584
  mimeType: string;
13585
13585
  })[];
13586
13586
  details?: any;
13587
+ isError: false;
13587
13588
  };
13588
- status: "running";
13589
+ status: "completed";
13589
13590
  thoughtSignature?: string;
13590
13591
  time: {
13591
13592
  start: number;
@@ -13609,9 +13610,9 @@ declare const Definitions: readonly [Schema.Struct<{
13609
13610
  mimeType: string;
13610
13611
  })[];
13611
13612
  details?: any;
13612
- isError: false;
13613
+ isError: true;
13613
13614
  };
13614
- status: "completed";
13615
+ status: "error";
13615
13616
  thoughtSignature?: string;
13616
13617
  time: {
13617
13618
  start: number;
@@ -13637,7 +13638,7 @@ declare const Definitions: readonly [Schema.Struct<{
13637
13638
  details?: any;
13638
13639
  isError: true;
13639
13640
  };
13640
- status: "error";
13641
+ status: "skipped";
13641
13642
  thoughtSignature?: string;
13642
13643
  time: {
13643
13644
  start: number;
@@ -13663,21 +13664,26 @@ declare const Definitions: readonly [Schema.Struct<{
13663
13664
  details?: any;
13664
13665
  isError: true;
13665
13666
  };
13666
- status: "skipped";
13667
+ status: "aborted";
13667
13668
  thoughtSignature?: string;
13668
13669
  time: {
13669
13670
  start: number;
13670
13671
  end: number;
13671
13672
  };
13672
13673
  type: "toolCall";
13674
+ } | {
13675
+ type: "thinking";
13676
+ thinking: string;
13677
+ thinkingSignature?: string;
13678
+ redacted?: boolean;
13673
13679
  } | {
13674
13680
  addedToolNames?: string[];
13675
13681
  arguments: Record<string, any>;
13676
13682
  callID: string;
13677
13683
  name: string;
13678
13684
  namespace?: string;
13679
- result: {
13680
- content: ({
13685
+ partial?: {
13686
+ content?: ({
13681
13687
  type: "text";
13682
13688
  text: string;
13683
13689
  textSignature?: string;
@@ -13687,9 +13693,8 @@ declare const Definitions: readonly [Schema.Struct<{
13687
13693
  mimeType: string;
13688
13694
  })[];
13689
13695
  details?: any;
13690
- isError: true;
13691
13696
  };
13692
- status: "aborted";
13697
+ status: "running";
13693
13698
  thoughtSignature?: string;
13694
13699
  time: {
13695
13700
  start: number;
@@ -13883,19 +13888,14 @@ declare const Definitions: readonly [Schema.Struct<{
13883
13888
  type: "image";
13884
13889
  data: string;
13885
13890
  mimeType: string;
13886
- } | {
13887
- type: "thinking";
13888
- thinking: string;
13889
- thinkingSignature?: string;
13890
- redacted?: boolean;
13891
13891
  } | {
13892
13892
  addedToolNames?: string[];
13893
13893
  arguments: Record<string, any>;
13894
13894
  callID: string;
13895
13895
  name: string;
13896
13896
  namespace?: string;
13897
- partial?: {
13898
- content?: ({
13897
+ result: {
13898
+ content: ({
13899
13899
  type: "text";
13900
13900
  text: string;
13901
13901
  textSignature?: string;
@@ -13905,8 +13905,9 @@ declare const Definitions: readonly [Schema.Struct<{
13905
13905
  mimeType: string;
13906
13906
  })[];
13907
13907
  details?: any;
13908
+ isError: false;
13908
13909
  };
13909
- status: "running";
13910
+ status: "completed";
13910
13911
  thoughtSignature?: string;
13911
13912
  time: {
13912
13913
  start: number;
@@ -13930,9 +13931,9 @@ declare const Definitions: readonly [Schema.Struct<{
13930
13931
  mimeType: string;
13931
13932
  })[];
13932
13933
  details?: any;
13933
- isError: false;
13934
+ isError: true;
13934
13935
  };
13935
- status: "completed";
13936
+ status: "error";
13936
13937
  thoughtSignature?: string;
13937
13938
  time: {
13938
13939
  start: number;
@@ -13958,7 +13959,7 @@ declare const Definitions: readonly [Schema.Struct<{
13958
13959
  details?: any;
13959
13960
  isError: true;
13960
13961
  };
13961
- status: "error";
13962
+ status: "skipped";
13962
13963
  thoughtSignature?: string;
13963
13964
  time: {
13964
13965
  start: number;
@@ -13984,21 +13985,26 @@ declare const Definitions: readonly [Schema.Struct<{
13984
13985
  details?: any;
13985
13986
  isError: true;
13986
13987
  };
13987
- status: "skipped";
13988
+ status: "aborted";
13988
13989
  thoughtSignature?: string;
13989
13990
  time: {
13990
13991
  start: number;
13991
13992
  end: number;
13992
13993
  };
13993
13994
  type: "toolCall";
13995
+ } | {
13996
+ type: "thinking";
13997
+ thinking: string;
13998
+ thinkingSignature?: string;
13999
+ redacted?: boolean;
13994
14000
  } | {
13995
14001
  addedToolNames?: string[];
13996
14002
  arguments: Record<string, any>;
13997
14003
  callID: string;
13998
14004
  name: string;
13999
14005
  namespace?: string;
14000
- result: {
14001
- content: ({
14006
+ partial?: {
14007
+ content?: ({
14002
14008
  type: "text";
14003
14009
  text: string;
14004
14010
  textSignature?: string;
@@ -14008,9 +14014,8 @@ declare const Definitions: readonly [Schema.Struct<{
14008
14014
  mimeType: string;
14009
14015
  })[];
14010
14016
  details?: any;
14011
- isError: true;
14012
14017
  };
14013
- status: "aborted";
14018
+ status: "running";
14014
14019
  thoughtSignature?: string;
14015
14020
  time: {
14016
14021
  start: number;
@@ -14185,19 +14190,14 @@ declare const Definitions: readonly [Schema.Struct<{
14185
14190
  type: "image";
14186
14191
  data: string;
14187
14192
  mimeType: string;
14188
- } | {
14189
- type: "thinking";
14190
- thinking: string;
14191
- thinkingSignature?: string;
14192
- redacted?: boolean;
14193
14193
  } | {
14194
14194
  addedToolNames?: string[];
14195
14195
  arguments: Record<string, any>;
14196
14196
  callID: string;
14197
14197
  name: string;
14198
14198
  namespace?: string;
14199
- partial?: {
14200
- content?: ({
14199
+ result: {
14200
+ content: ({
14201
14201
  type: "text";
14202
14202
  text: string;
14203
14203
  textSignature?: string;
@@ -14207,8 +14207,9 @@ declare const Definitions: readonly [Schema.Struct<{
14207
14207
  mimeType: string;
14208
14208
  })[];
14209
14209
  details?: any;
14210
+ isError: false;
14210
14211
  };
14211
- status: "running";
14212
+ status: "completed";
14212
14213
  thoughtSignature?: string;
14213
14214
  time: {
14214
14215
  start: number;
@@ -14232,9 +14233,9 @@ declare const Definitions: readonly [Schema.Struct<{
14232
14233
  mimeType: string;
14233
14234
  })[];
14234
14235
  details?: any;
14235
- isError: false;
14236
+ isError: true;
14236
14237
  };
14237
- status: "completed";
14238
+ status: "error";
14238
14239
  thoughtSignature?: string;
14239
14240
  time: {
14240
14241
  start: number;
@@ -14260,7 +14261,7 @@ declare const Definitions: readonly [Schema.Struct<{
14260
14261
  details?: any;
14261
14262
  isError: true;
14262
14263
  };
14263
- status: "error";
14264
+ status: "skipped";
14264
14265
  thoughtSignature?: string;
14265
14266
  time: {
14266
14267
  start: number;
@@ -14286,21 +14287,26 @@ declare const Definitions: readonly [Schema.Struct<{
14286
14287
  details?: any;
14287
14288
  isError: true;
14288
14289
  };
14289
- status: "skipped";
14290
+ status: "aborted";
14290
14291
  thoughtSignature?: string;
14291
14292
  time: {
14292
14293
  start: number;
14293
14294
  end: number;
14294
14295
  };
14295
14296
  type: "toolCall";
14297
+ } | {
14298
+ type: "thinking";
14299
+ thinking: string;
14300
+ thinkingSignature?: string;
14301
+ redacted?: boolean;
14296
14302
  } | {
14297
14303
  addedToolNames?: string[];
14298
14304
  arguments: Record<string, any>;
14299
14305
  callID: string;
14300
14306
  name: string;
14301
14307
  namespace?: string;
14302
- result: {
14303
- content: ({
14308
+ partial?: {
14309
+ content?: ({
14304
14310
  type: "text";
14305
14311
  text: string;
14306
14312
  textSignature?: string;
@@ -14310,9 +14316,8 @@ declare const Definitions: readonly [Schema.Struct<{
14310
14316
  mimeType: string;
14311
14317
  })[];
14312
14318
  details?: any;
14313
- isError: true;
14314
14319
  };
14315
- status: "aborted";
14320
+ status: "running";
14316
14321
  thoughtSignature?: string;
14317
14322
  time: {
14318
14323
  start: number;
@@ -15821,19 +15826,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15821
15826
  type: "image";
15822
15827
  data: string;
15823
15828
  mimeType: string;
15824
- } | {
15825
- type: "thinking";
15826
- thinking: string;
15827
- thinkingSignature?: string;
15828
- redacted?: boolean;
15829
15829
  } | {
15830
15830
  addedToolNames?: string[];
15831
15831
  arguments: Record<string, any>;
15832
15832
  callID: string;
15833
15833
  name: string;
15834
15834
  namespace?: string;
15835
- partial?: {
15836
- content?: ({
15835
+ result: {
15836
+ content: ({
15837
15837
  type: "text";
15838
15838
  text: string;
15839
15839
  textSignature?: string;
@@ -15843,8 +15843,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15843
15843
  mimeType: string;
15844
15844
  })[];
15845
15845
  details?: any;
15846
+ isError: false;
15846
15847
  };
15847
- status: "running";
15848
+ status: "completed";
15848
15849
  thoughtSignature?: string;
15849
15850
  time: {
15850
15851
  start: number;
@@ -15868,9 +15869,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15868
15869
  mimeType: string;
15869
15870
  })[];
15870
15871
  details?: any;
15871
- isError: false;
15872
+ isError: true;
15872
15873
  };
15873
- status: "completed";
15874
+ status: "error";
15874
15875
  thoughtSignature?: string;
15875
15876
  time: {
15876
15877
  start: number;
@@ -15896,7 +15897,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15896
15897
  details?: any;
15897
15898
  isError: true;
15898
15899
  };
15899
- status: "error";
15900
+ status: "skipped";
15900
15901
  thoughtSignature?: string;
15901
15902
  time: {
15902
15903
  start: number;
@@ -15922,21 +15923,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15922
15923
  details?: any;
15923
15924
  isError: true;
15924
15925
  };
15925
- status: "skipped";
15926
+ status: "aborted";
15926
15927
  thoughtSignature?: string;
15927
15928
  time: {
15928
15929
  start: number;
15929
15930
  end: number;
15930
15931
  };
15931
15932
  type: "toolCall";
15933
+ } | {
15934
+ type: "thinking";
15935
+ thinking: string;
15936
+ thinkingSignature?: string;
15937
+ redacted?: boolean;
15932
15938
  } | {
15933
15939
  addedToolNames?: string[];
15934
15940
  arguments: Record<string, any>;
15935
15941
  callID: string;
15936
15942
  name: string;
15937
15943
  namespace?: string;
15938
- result: {
15939
- content: ({
15944
+ partial?: {
15945
+ content?: ({
15940
15946
  type: "text";
15941
15947
  text: string;
15942
15948
  textSignature?: string;
@@ -15946,9 +15952,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15946
15952
  mimeType: string;
15947
15953
  })[];
15948
15954
  details?: any;
15949
- isError: true;
15950
15955
  };
15951
- status: "aborted";
15956
+ status: "running";
15952
15957
  thoughtSignature?: string;
15953
15958
  time: {
15954
15959
  start: number;
@@ -16123,19 +16128,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16123
16128
  type: "image";
16124
16129
  data: string;
16125
16130
  mimeType: string;
16126
- } | {
16127
- type: "thinking";
16128
- thinking: string;
16129
- thinkingSignature?: string;
16130
- redacted?: boolean;
16131
16131
  } | {
16132
16132
  addedToolNames?: string[];
16133
16133
  arguments: Record<string, any>;
16134
16134
  callID: string;
16135
16135
  name: string;
16136
16136
  namespace?: string;
16137
- partial?: {
16138
- content?: ({
16137
+ result: {
16138
+ content: ({
16139
16139
  type: "text";
16140
16140
  text: string;
16141
16141
  textSignature?: string;
@@ -16145,8 +16145,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16145
16145
  mimeType: string;
16146
16146
  })[];
16147
16147
  details?: any;
16148
+ isError: false;
16148
16149
  };
16149
- status: "running";
16150
+ status: "completed";
16150
16151
  thoughtSignature?: string;
16151
16152
  time: {
16152
16153
  start: number;
@@ -16170,9 +16171,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16170
16171
  mimeType: string;
16171
16172
  })[];
16172
16173
  details?: any;
16173
- isError: false;
16174
+ isError: true;
16174
16175
  };
16175
- status: "completed";
16176
+ status: "error";
16176
16177
  thoughtSignature?: string;
16177
16178
  time: {
16178
16179
  start: number;
@@ -16198,7 +16199,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16198
16199
  details?: any;
16199
16200
  isError: true;
16200
16201
  };
16201
- status: "error";
16202
+ status: "skipped";
16202
16203
  thoughtSignature?: string;
16203
16204
  time: {
16204
16205
  start: number;
@@ -16224,21 +16225,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16224
16225
  details?: any;
16225
16226
  isError: true;
16226
16227
  };
16227
- status: "skipped";
16228
+ status: "aborted";
16228
16229
  thoughtSignature?: string;
16229
16230
  time: {
16230
16231
  start: number;
16231
16232
  end: number;
16232
16233
  };
16233
16234
  type: "toolCall";
16235
+ } | {
16236
+ type: "thinking";
16237
+ thinking: string;
16238
+ thinkingSignature?: string;
16239
+ redacted?: boolean;
16234
16240
  } | {
16235
16241
  addedToolNames?: string[];
16236
16242
  arguments: Record<string, any>;
16237
16243
  callID: string;
16238
16244
  name: string;
16239
16245
  namespace?: string;
16240
- result: {
16241
- content: ({
16246
+ partial?: {
16247
+ content?: ({
16242
16248
  type: "text";
16243
16249
  text: string;
16244
16250
  textSignature?: string;
@@ -16248,9 +16254,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16248
16254
  mimeType: string;
16249
16255
  })[];
16250
16256
  details?: any;
16251
- isError: true;
16252
16257
  };
16253
- status: "aborted";
16258
+ status: "running";
16254
16259
  thoughtSignature?: string;
16255
16260
  time: {
16256
16261
  start: number;
@@ -16443,19 +16448,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16443
16448
  type: "image";
16444
16449
  data: string;
16445
16450
  mimeType: string;
16446
- } | {
16447
- type: "thinking";
16448
- thinking: string;
16449
- thinkingSignature?: string;
16450
- redacted?: boolean;
16451
16451
  } | {
16452
16452
  addedToolNames?: string[];
16453
16453
  arguments: Record<string, any>;
16454
16454
  callID: string;
16455
16455
  name: string;
16456
16456
  namespace?: string;
16457
- partial?: {
16458
- content?: ({
16457
+ result: {
16458
+ content: ({
16459
16459
  type: "text";
16460
16460
  text: string;
16461
16461
  textSignature?: string;
@@ -16465,8 +16465,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16465
16465
  mimeType: string;
16466
16466
  })[];
16467
16467
  details?: any;
16468
+ isError: false;
16468
16469
  };
16469
- status: "running";
16470
+ status: "completed";
16470
16471
  thoughtSignature?: string;
16471
16472
  time: {
16472
16473
  start: number;
@@ -16490,9 +16491,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16490
16491
  mimeType: string;
16491
16492
  })[];
16492
16493
  details?: any;
16493
- isError: false;
16494
+ isError: true;
16494
16495
  };
16495
- status: "completed";
16496
+ status: "error";
16496
16497
  thoughtSignature?: string;
16497
16498
  time: {
16498
16499
  start: number;
@@ -16518,7 +16519,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16518
16519
  details?: any;
16519
16520
  isError: true;
16520
16521
  };
16521
- status: "error";
16522
+ status: "skipped";
16522
16523
  thoughtSignature?: string;
16523
16524
  time: {
16524
16525
  start: number;
@@ -16544,21 +16545,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16544
16545
  details?: any;
16545
16546
  isError: true;
16546
16547
  };
16547
- status: "skipped";
16548
+ status: "aborted";
16548
16549
  thoughtSignature?: string;
16549
16550
  time: {
16550
16551
  start: number;
16551
16552
  end: number;
16552
16553
  };
16553
16554
  type: "toolCall";
16555
+ } | {
16556
+ type: "thinking";
16557
+ thinking: string;
16558
+ thinkingSignature?: string;
16559
+ redacted?: boolean;
16554
16560
  } | {
16555
16561
  addedToolNames?: string[];
16556
16562
  arguments: Record<string, any>;
16557
16563
  callID: string;
16558
16564
  name: string;
16559
16565
  namespace?: string;
16560
- result: {
16561
- content: ({
16566
+ partial?: {
16567
+ content?: ({
16562
16568
  type: "text";
16563
16569
  text: string;
16564
16570
  textSignature?: string;
@@ -16568,9 +16574,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16568
16574
  mimeType: string;
16569
16575
  })[];
16570
16576
  details?: any;
16571
- isError: true;
16572
16577
  };
16573
- status: "aborted";
16578
+ status: "running";
16574
16579
  thoughtSignature?: string;
16575
16580
  time: {
16576
16581
  start: number;
@@ -16745,19 +16750,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16745
16750
  type: "image";
16746
16751
  data: string;
16747
16752
  mimeType: string;
16748
- } | {
16749
- type: "thinking";
16750
- thinking: string;
16751
- thinkingSignature?: string;
16752
- redacted?: boolean;
16753
16753
  } | {
16754
16754
  addedToolNames?: string[];
16755
16755
  arguments: Record<string, any>;
16756
16756
  callID: string;
16757
16757
  name: string;
16758
16758
  namespace?: string;
16759
- partial?: {
16760
- content?: ({
16759
+ result: {
16760
+ content: ({
16761
16761
  type: "text";
16762
16762
  text: string;
16763
16763
  textSignature?: string;
@@ -16767,8 +16767,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16767
16767
  mimeType: string;
16768
16768
  })[];
16769
16769
  details?: any;
16770
+ isError: false;
16770
16771
  };
16771
- status: "running";
16772
+ status: "completed";
16772
16773
  thoughtSignature?: string;
16773
16774
  time: {
16774
16775
  start: number;
@@ -16792,9 +16793,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16792
16793
  mimeType: string;
16793
16794
  })[];
16794
16795
  details?: any;
16795
- isError: false;
16796
+ isError: true;
16796
16797
  };
16797
- status: "completed";
16798
+ status: "error";
16798
16799
  thoughtSignature?: string;
16799
16800
  time: {
16800
16801
  start: number;
@@ -16820,7 +16821,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16820
16821
  details?: any;
16821
16822
  isError: true;
16822
16823
  };
16823
- status: "error";
16824
+ status: "skipped";
16824
16825
  thoughtSignature?: string;
16825
16826
  time: {
16826
16827
  start: number;
@@ -16846,21 +16847,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16846
16847
  details?: any;
16847
16848
  isError: true;
16848
16849
  };
16849
- status: "skipped";
16850
+ status: "aborted";
16850
16851
  thoughtSignature?: string;
16851
16852
  time: {
16852
16853
  start: number;
16853
16854
  end: number;
16854
16855
  };
16855
16856
  type: "toolCall";
16857
+ } | {
16858
+ type: "thinking";
16859
+ thinking: string;
16860
+ thinkingSignature?: string;
16861
+ redacted?: boolean;
16856
16862
  } | {
16857
16863
  addedToolNames?: string[];
16858
16864
  arguments: Record<string, any>;
16859
16865
  callID: string;
16860
16866
  name: string;
16861
16867
  namespace?: string;
16862
- result: {
16863
- content: ({
16868
+ partial?: {
16869
+ content?: ({
16864
16870
  type: "text";
16865
16871
  text: string;
16866
16872
  textSignature?: string;
@@ -16870,9 +16876,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16870
16876
  mimeType: string;
16871
16877
  })[];
16872
16878
  details?: any;
16873
- isError: true;
16874
16879
  };
16875
- status: "aborted";
16880
+ status: "running";
16876
16881
  thoughtSignature?: string;
16877
16882
  time: {
16878
16883
  start: number;
@@ -17353,19 +17358,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17353
17358
  type: "image";
17354
17359
  data: string;
17355
17360
  mimeType: string;
17356
- } | {
17357
- type: "thinking";
17358
- thinking: string;
17359
- thinkingSignature?: string;
17360
- redacted?: boolean;
17361
17361
  } | {
17362
17362
  addedToolNames?: string[];
17363
17363
  arguments: Record<string, any>;
17364
17364
  callID: string;
17365
17365
  name: string;
17366
17366
  namespace?: string;
17367
- partial?: {
17368
- content?: ({
17367
+ result: {
17368
+ content: ({
17369
17369
  type: "text";
17370
17370
  text: string;
17371
17371
  textSignature?: string;
@@ -17375,8 +17375,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17375
17375
  mimeType: string;
17376
17376
  })[];
17377
17377
  details?: any;
17378
+ isError: false;
17378
17379
  };
17379
- status: "running";
17380
+ status: "completed";
17380
17381
  thoughtSignature?: string;
17381
17382
  time: {
17382
17383
  start: number;
@@ -17400,9 +17401,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17400
17401
  mimeType: string;
17401
17402
  })[];
17402
17403
  details?: any;
17403
- isError: false;
17404
+ isError: true;
17404
17405
  };
17405
- status: "completed";
17406
+ status: "error";
17406
17407
  thoughtSignature?: string;
17407
17408
  time: {
17408
17409
  start: number;
@@ -17428,7 +17429,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17428
17429
  details?: any;
17429
17430
  isError: true;
17430
17431
  };
17431
- status: "error";
17432
+ status: "skipped";
17432
17433
  thoughtSignature?: string;
17433
17434
  time: {
17434
17435
  start: number;
@@ -17454,21 +17455,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17454
17455
  details?: any;
17455
17456
  isError: true;
17456
17457
  };
17457
- status: "skipped";
17458
+ status: "aborted";
17458
17459
  thoughtSignature?: string;
17459
17460
  time: {
17460
17461
  start: number;
17461
17462
  end: number;
17462
17463
  };
17463
17464
  type: "toolCall";
17465
+ } | {
17466
+ type: "thinking";
17467
+ thinking: string;
17468
+ thinkingSignature?: string;
17469
+ redacted?: boolean;
17464
17470
  } | {
17465
17471
  addedToolNames?: string[];
17466
17472
  arguments: Record<string, any>;
17467
17473
  callID: string;
17468
17474
  name: string;
17469
17475
  namespace?: string;
17470
- result: {
17471
- content: ({
17476
+ partial?: {
17477
+ content?: ({
17472
17478
  type: "text";
17473
17479
  text: string;
17474
17480
  textSignature?: string;
@@ -17478,9 +17484,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17478
17484
  mimeType: string;
17479
17485
  })[];
17480
17486
  details?: any;
17481
- isError: true;
17482
17487
  };
17483
- status: "aborted";
17488
+ status: "running";
17484
17489
  thoughtSignature?: string;
17485
17490
  time: {
17486
17491
  start: number;
@@ -17655,19 +17660,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17655
17660
  type: "image";
17656
17661
  data: string;
17657
17662
  mimeType: string;
17658
- } | {
17659
- type: "thinking";
17660
- thinking: string;
17661
- thinkingSignature?: string;
17662
- redacted?: boolean;
17663
17663
  } | {
17664
17664
  addedToolNames?: string[];
17665
17665
  arguments: Record<string, any>;
17666
17666
  callID: string;
17667
17667
  name: string;
17668
17668
  namespace?: string;
17669
- partial?: {
17670
- content?: ({
17669
+ result: {
17670
+ content: ({
17671
17671
  type: "text";
17672
17672
  text: string;
17673
17673
  textSignature?: string;
@@ -17677,8 +17677,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17677
17677
  mimeType: string;
17678
17678
  })[];
17679
17679
  details?: any;
17680
+ isError: false;
17680
17681
  };
17681
- status: "running";
17682
+ status: "completed";
17682
17683
  thoughtSignature?: string;
17683
17684
  time: {
17684
17685
  start: number;
@@ -17702,9 +17703,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17702
17703
  mimeType: string;
17703
17704
  })[];
17704
17705
  details?: any;
17705
- isError: false;
17706
+ isError: true;
17706
17707
  };
17707
- status: "completed";
17708
+ status: "error";
17708
17709
  thoughtSignature?: string;
17709
17710
  time: {
17710
17711
  start: number;
@@ -17730,7 +17731,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17730
17731
  details?: any;
17731
17732
  isError: true;
17732
17733
  };
17733
- status: "error";
17734
+ status: "skipped";
17734
17735
  thoughtSignature?: string;
17735
17736
  time: {
17736
17737
  start: number;
@@ -17756,21 +17757,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17756
17757
  details?: any;
17757
17758
  isError: true;
17758
17759
  };
17759
- status: "skipped";
17760
+ status: "aborted";
17760
17761
  thoughtSignature?: string;
17761
17762
  time: {
17762
17763
  start: number;
17763
17764
  end: number;
17764
17765
  };
17765
17766
  type: "toolCall";
17767
+ } | {
17768
+ type: "thinking";
17769
+ thinking: string;
17770
+ thinkingSignature?: string;
17771
+ redacted?: boolean;
17766
17772
  } | {
17767
17773
  addedToolNames?: string[];
17768
17774
  arguments: Record<string, any>;
17769
17775
  callID: string;
17770
17776
  name: string;
17771
17777
  namespace?: string;
17772
- result: {
17773
- content: ({
17778
+ partial?: {
17779
+ content?: ({
17774
17780
  type: "text";
17775
17781
  text: string;
17776
17782
  textSignature?: string;
@@ -17780,9 +17786,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17780
17786
  mimeType: string;
17781
17787
  })[];
17782
17788
  details?: any;
17783
- isError: true;
17784
17789
  };
17785
- status: "aborted";
17790
+ status: "running";
17786
17791
  thoughtSignature?: string;
17787
17792
  time: {
17788
17793
  start: number;
@@ -17976,19 +17981,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17976
17981
  type: "image";
17977
17982
  data: string;
17978
17983
  mimeType: string;
17979
- } | {
17980
- type: "thinking";
17981
- thinking: string;
17982
- thinkingSignature?: string;
17983
- redacted?: boolean;
17984
17984
  } | {
17985
17985
  addedToolNames?: string[];
17986
17986
  arguments: Record<string, any>;
17987
17987
  callID: string;
17988
17988
  name: string;
17989
17989
  namespace?: string;
17990
- partial?: {
17991
- content?: ({
17990
+ result: {
17991
+ content: ({
17992
17992
  type: "text";
17993
17993
  text: string;
17994
17994
  textSignature?: string;
@@ -17998,8 +17998,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17998
17998
  mimeType: string;
17999
17999
  })[];
18000
18000
  details?: any;
18001
+ isError: false;
18001
18002
  };
18002
- status: "running";
18003
+ status: "completed";
18003
18004
  thoughtSignature?: string;
18004
18005
  time: {
18005
18006
  start: number;
@@ -18023,9 +18024,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18023
18024
  mimeType: string;
18024
18025
  })[];
18025
18026
  details?: any;
18026
- isError: false;
18027
+ isError: true;
18027
18028
  };
18028
- status: "completed";
18029
+ status: "error";
18029
18030
  thoughtSignature?: string;
18030
18031
  time: {
18031
18032
  start: number;
@@ -18051,7 +18052,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18051
18052
  details?: any;
18052
18053
  isError: true;
18053
18054
  };
18054
- status: "error";
18055
+ status: "skipped";
18055
18056
  thoughtSignature?: string;
18056
18057
  time: {
18057
18058
  start: number;
@@ -18077,21 +18078,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18077
18078
  details?: any;
18078
18079
  isError: true;
18079
18080
  };
18080
- status: "skipped";
18081
+ status: "aborted";
18081
18082
  thoughtSignature?: string;
18082
18083
  time: {
18083
18084
  start: number;
18084
18085
  end: number;
18085
18086
  };
18086
18087
  type: "toolCall";
18088
+ } | {
18089
+ type: "thinking";
18090
+ thinking: string;
18091
+ thinkingSignature?: string;
18092
+ redacted?: boolean;
18087
18093
  } | {
18088
18094
  addedToolNames?: string[];
18089
18095
  arguments: Record<string, any>;
18090
18096
  callID: string;
18091
18097
  name: string;
18092
18098
  namespace?: string;
18093
- result: {
18094
- content: ({
18099
+ partial?: {
18100
+ content?: ({
18095
18101
  type: "text";
18096
18102
  text: string;
18097
18103
  textSignature?: string;
@@ -18101,9 +18107,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18101
18107
  mimeType: string;
18102
18108
  })[];
18103
18109
  details?: any;
18104
- isError: true;
18105
18110
  };
18106
- status: "aborted";
18111
+ status: "running";
18107
18112
  thoughtSignature?: string;
18108
18113
  time: {
18109
18114
  start: number;
@@ -18278,19 +18283,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18278
18283
  type: "image";
18279
18284
  data: string;
18280
18285
  mimeType: string;
18281
- } | {
18282
- type: "thinking";
18283
- thinking: string;
18284
- thinkingSignature?: string;
18285
- redacted?: boolean;
18286
18286
  } | {
18287
18287
  addedToolNames?: string[];
18288
18288
  arguments: Record<string, any>;
18289
18289
  callID: string;
18290
18290
  name: string;
18291
18291
  namespace?: string;
18292
- partial?: {
18293
- content?: ({
18292
+ result: {
18293
+ content: ({
18294
18294
  type: "text";
18295
18295
  text: string;
18296
18296
  textSignature?: string;
@@ -18300,8 +18300,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18300
18300
  mimeType: string;
18301
18301
  })[];
18302
18302
  details?: any;
18303
+ isError: false;
18303
18304
  };
18304
- status: "running";
18305
+ status: "completed";
18305
18306
  thoughtSignature?: string;
18306
18307
  time: {
18307
18308
  start: number;
@@ -18325,9 +18326,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18325
18326
  mimeType: string;
18326
18327
  })[];
18327
18328
  details?: any;
18328
- isError: false;
18329
+ isError: true;
18329
18330
  };
18330
- status: "completed";
18331
+ status: "error";
18331
18332
  thoughtSignature?: string;
18332
18333
  time: {
18333
18334
  start: number;
@@ -18353,7 +18354,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18353
18354
  details?: any;
18354
18355
  isError: true;
18355
18356
  };
18356
- status: "error";
18357
+ status: "skipped";
18357
18358
  thoughtSignature?: string;
18358
18359
  time: {
18359
18360
  start: number;
@@ -18379,21 +18380,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18379
18380
  details?: any;
18380
18381
  isError: true;
18381
18382
  };
18382
- status: "skipped";
18383
+ status: "aborted";
18383
18384
  thoughtSignature?: string;
18384
18385
  time: {
18385
18386
  start: number;
18386
18387
  end: number;
18387
18388
  };
18388
18389
  type: "toolCall";
18390
+ } | {
18391
+ type: "thinking";
18392
+ thinking: string;
18393
+ thinkingSignature?: string;
18394
+ redacted?: boolean;
18389
18395
  } | {
18390
18396
  addedToolNames?: string[];
18391
18397
  arguments: Record<string, any>;
18392
18398
  callID: string;
18393
18399
  name: string;
18394
18400
  namespace?: string;
18395
- result: {
18396
- content: ({
18401
+ partial?: {
18402
+ content?: ({
18397
18403
  type: "text";
18398
18404
  text: string;
18399
18405
  textSignature?: string;
@@ -18403,9 +18409,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18403
18409
  mimeType: string;
18404
18410
  })[];
18405
18411
  details?: any;
18406
- isError: true;
18407
18412
  };
18408
- status: "aborted";
18413
+ status: "running";
18409
18414
  thoughtSignature?: string;
18410
18415
  time: {
18411
18416
  start: number;
@@ -18608,19 +18613,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18608
18613
  type: "image";
18609
18614
  data: string;
18610
18615
  mimeType: string;
18611
- } | {
18612
- type: "thinking";
18613
- thinking: string;
18614
- thinkingSignature?: string;
18615
- redacted?: boolean;
18616
18616
  } | {
18617
18617
  addedToolNames?: string[];
18618
18618
  arguments: Record<string, any>;
18619
18619
  callID: string;
18620
18620
  name: string;
18621
18621
  namespace?: string;
18622
- partial?: {
18623
- content?: ({
18622
+ result: {
18623
+ content: ({
18624
18624
  type: "text";
18625
18625
  text: string;
18626
18626
  textSignature?: string;
@@ -18630,8 +18630,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18630
18630
  mimeType: string;
18631
18631
  })[];
18632
18632
  details?: any;
18633
+ isError: false;
18633
18634
  };
18634
- status: "running";
18635
+ status: "completed";
18635
18636
  thoughtSignature?: string;
18636
18637
  time: {
18637
18638
  start: number;
@@ -18655,9 +18656,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18655
18656
  mimeType: string;
18656
18657
  })[];
18657
18658
  details?: any;
18658
- isError: false;
18659
+ isError: true;
18659
18660
  };
18660
- status: "completed";
18661
+ status: "error";
18661
18662
  thoughtSignature?: string;
18662
18663
  time: {
18663
18664
  start: number;
@@ -18683,7 +18684,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18683
18684
  details?: any;
18684
18685
  isError: true;
18685
18686
  };
18686
- status: "error";
18687
+ status: "skipped";
18687
18688
  thoughtSignature?: string;
18688
18689
  time: {
18689
18690
  start: number;
@@ -18709,21 +18710,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18709
18710
  details?: any;
18710
18711
  isError: true;
18711
18712
  };
18712
- status: "skipped";
18713
+ status: "aborted";
18713
18714
  thoughtSignature?: string;
18714
18715
  time: {
18715
18716
  start: number;
18716
18717
  end: number;
18717
18718
  };
18718
18719
  type: "toolCall";
18720
+ } | {
18721
+ type: "thinking";
18722
+ thinking: string;
18723
+ thinkingSignature?: string;
18724
+ redacted?: boolean;
18719
18725
  } | {
18720
18726
  addedToolNames?: string[];
18721
18727
  arguments: Record<string, any>;
18722
18728
  callID: string;
18723
18729
  name: string;
18724
18730
  namespace?: string;
18725
- result: {
18726
- content: ({
18731
+ partial?: {
18732
+ content?: ({
18727
18733
  type: "text";
18728
18734
  text: string;
18729
18735
  textSignature?: string;
@@ -18733,9 +18739,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18733
18739
  mimeType: string;
18734
18740
  })[];
18735
18741
  details?: any;
18736
- isError: true;
18737
18742
  };
18738
- status: "aborted";
18743
+ status: "running";
18739
18744
  thoughtSignature?: string;
18740
18745
  time: {
18741
18746
  start: number;
@@ -18910,19 +18915,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18910
18915
  type: "image";
18911
18916
  data: string;
18912
18917
  mimeType: string;
18913
- } | {
18914
- type: "thinking";
18915
- thinking: string;
18916
- thinkingSignature?: string;
18917
- redacted?: boolean;
18918
18918
  } | {
18919
18919
  addedToolNames?: string[];
18920
18920
  arguments: Record<string, any>;
18921
18921
  callID: string;
18922
18922
  name: string;
18923
18923
  namespace?: string;
18924
- partial?: {
18925
- content?: ({
18924
+ result: {
18925
+ content: ({
18926
18926
  type: "text";
18927
18927
  text: string;
18928
18928
  textSignature?: string;
@@ -18932,8 +18932,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18932
18932
  mimeType: string;
18933
18933
  })[];
18934
18934
  details?: any;
18935
+ isError: false;
18935
18936
  };
18936
- status: "running";
18937
+ status: "completed";
18937
18938
  thoughtSignature?: string;
18938
18939
  time: {
18939
18940
  start: number;
@@ -18957,9 +18958,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18957
18958
  mimeType: string;
18958
18959
  })[];
18959
18960
  details?: any;
18960
- isError: false;
18961
+ isError: true;
18961
18962
  };
18962
- status: "completed";
18963
+ status: "error";
18963
18964
  thoughtSignature?: string;
18964
18965
  time: {
18965
18966
  start: number;
@@ -18985,7 +18986,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18985
18986
  details?: any;
18986
18987
  isError: true;
18987
18988
  };
18988
- status: "error";
18989
+ status: "skipped";
18989
18990
  thoughtSignature?: string;
18990
18991
  time: {
18991
18992
  start: number;
@@ -19011,21 +19012,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19011
19012
  details?: any;
19012
19013
  isError: true;
19013
19014
  };
19014
- status: "skipped";
19015
+ status: "aborted";
19015
19016
  thoughtSignature?: string;
19016
19017
  time: {
19017
19018
  start: number;
19018
19019
  end: number;
19019
19020
  };
19020
19021
  type: "toolCall";
19022
+ } | {
19023
+ type: "thinking";
19024
+ thinking: string;
19025
+ thinkingSignature?: string;
19026
+ redacted?: boolean;
19021
19027
  } | {
19022
19028
  addedToolNames?: string[];
19023
19029
  arguments: Record<string, any>;
19024
19030
  callID: string;
19025
19031
  name: string;
19026
19032
  namespace?: string;
19027
- result: {
19028
- content: ({
19033
+ partial?: {
19034
+ content?: ({
19029
19035
  type: "text";
19030
19036
  text: string;
19031
19037
  textSignature?: string;
@@ -19035,9 +19041,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19035
19041
  mimeType: string;
19036
19042
  })[];
19037
19043
  details?: any;
19038
- isError: true;
19039
19044
  };
19040
- status: "aborted";
19045
+ status: "running";
19041
19046
  thoughtSignature?: string;
19042
19047
  time: {
19043
19048
  start: number;
@@ -19231,19 +19236,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19231
19236
  type: "image";
19232
19237
  data: string;
19233
19238
  mimeType: string;
19234
- } | {
19235
- type: "thinking";
19236
- thinking: string;
19237
- thinkingSignature?: string;
19238
- redacted?: boolean;
19239
19239
  } | {
19240
19240
  addedToolNames?: string[];
19241
19241
  arguments: Record<string, any>;
19242
19242
  callID: string;
19243
19243
  name: string;
19244
19244
  namespace?: string;
19245
- partial?: {
19246
- content?: ({
19245
+ result: {
19246
+ content: ({
19247
19247
  type: "text";
19248
19248
  text: string;
19249
19249
  textSignature?: string;
@@ -19253,8 +19253,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19253
19253
  mimeType: string;
19254
19254
  })[];
19255
19255
  details?: any;
19256
+ isError: false;
19256
19257
  };
19257
- status: "running";
19258
+ status: "completed";
19258
19259
  thoughtSignature?: string;
19259
19260
  time: {
19260
19261
  start: number;
@@ -19278,9 +19279,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19278
19279
  mimeType: string;
19279
19280
  })[];
19280
19281
  details?: any;
19281
- isError: false;
19282
+ isError: true;
19282
19283
  };
19283
- status: "completed";
19284
+ status: "error";
19284
19285
  thoughtSignature?: string;
19285
19286
  time: {
19286
19287
  start: number;
@@ -19306,7 +19307,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19306
19307
  details?: any;
19307
19308
  isError: true;
19308
19309
  };
19309
- status: "error";
19310
+ status: "skipped";
19310
19311
  thoughtSignature?: string;
19311
19312
  time: {
19312
19313
  start: number;
@@ -19332,21 +19333,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19332
19333
  details?: any;
19333
19334
  isError: true;
19334
19335
  };
19335
- status: "skipped";
19336
+ status: "aborted";
19336
19337
  thoughtSignature?: string;
19337
19338
  time: {
19338
19339
  start: number;
19339
19340
  end: number;
19340
19341
  };
19341
19342
  type: "toolCall";
19343
+ } | {
19344
+ type: "thinking";
19345
+ thinking: string;
19346
+ thinkingSignature?: string;
19347
+ redacted?: boolean;
19342
19348
  } | {
19343
19349
  addedToolNames?: string[];
19344
19350
  arguments: Record<string, any>;
19345
19351
  callID: string;
19346
19352
  name: string;
19347
19353
  namespace?: string;
19348
- result: {
19349
- content: ({
19354
+ partial?: {
19355
+ content?: ({
19350
19356
  type: "text";
19351
19357
  text: string;
19352
19358
  textSignature?: string;
@@ -19356,9 +19362,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19356
19362
  mimeType: string;
19357
19363
  })[];
19358
19364
  details?: any;
19359
- isError: true;
19360
19365
  };
19361
- status: "aborted";
19366
+ status: "running";
19362
19367
  thoughtSignature?: string;
19363
19368
  time: {
19364
19369
  start: number;
@@ -19533,19 +19538,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19533
19538
  type: "image";
19534
19539
  data: string;
19535
19540
  mimeType: string;
19536
- } | {
19537
- type: "thinking";
19538
- thinking: string;
19539
- thinkingSignature?: string;
19540
- redacted?: boolean;
19541
19541
  } | {
19542
19542
  addedToolNames?: string[];
19543
19543
  arguments: Record<string, any>;
19544
19544
  callID: string;
19545
19545
  name: string;
19546
19546
  namespace?: string;
19547
- partial?: {
19548
- content?: ({
19547
+ result: {
19548
+ content: ({
19549
19549
  type: "text";
19550
19550
  text: string;
19551
19551
  textSignature?: string;
@@ -19555,8 +19555,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19555
19555
  mimeType: string;
19556
19556
  })[];
19557
19557
  details?: any;
19558
+ isError: false;
19558
19559
  };
19559
- status: "running";
19560
+ status: "completed";
19560
19561
  thoughtSignature?: string;
19561
19562
  time: {
19562
19563
  start: number;
@@ -19580,9 +19581,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19580
19581
  mimeType: string;
19581
19582
  })[];
19582
19583
  details?: any;
19583
- isError: false;
19584
+ isError: true;
19584
19585
  };
19585
- status: "completed";
19586
+ status: "error";
19586
19587
  thoughtSignature?: string;
19587
19588
  time: {
19588
19589
  start: number;
@@ -19608,7 +19609,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19608
19609
  details?: any;
19609
19610
  isError: true;
19610
19611
  };
19611
- status: "error";
19612
+ status: "skipped";
19612
19613
  thoughtSignature?: string;
19613
19614
  time: {
19614
19615
  start: number;
@@ -19634,21 +19635,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19634
19635
  details?: any;
19635
19636
  isError: true;
19636
19637
  };
19637
- status: "skipped";
19638
+ status: "aborted";
19638
19639
  thoughtSignature?: string;
19639
19640
  time: {
19640
19641
  start: number;
19641
19642
  end: number;
19642
19643
  };
19643
19644
  type: "toolCall";
19645
+ } | {
19646
+ type: "thinking";
19647
+ thinking: string;
19648
+ thinkingSignature?: string;
19649
+ redacted?: boolean;
19644
19650
  } | {
19645
19651
  addedToolNames?: string[];
19646
19652
  arguments: Record<string, any>;
19647
19653
  callID: string;
19648
19654
  name: string;
19649
19655
  namespace?: string;
19650
- result: {
19651
- content: ({
19656
+ partial?: {
19657
+ content?: ({
19652
19658
  type: "text";
19653
19659
  text: string;
19654
19660
  textSignature?: string;
@@ -19658,9 +19664,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19658
19664
  mimeType: string;
19659
19665
  })[];
19660
19666
  details?: any;
19661
- isError: true;
19662
19667
  };
19663
- status: "aborted";
19668
+ status: "running";
19664
19669
  thoughtSignature?: string;
19665
19670
  time: {
19666
19671
  start: number;
@@ -20848,19 +20853,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20848
20853
  type: "image";
20849
20854
  data: string;
20850
20855
  mimeType: string;
20851
- } | {
20852
- type: "thinking";
20853
- thinking: string;
20854
- thinkingSignature?: string;
20855
- redacted?: boolean;
20856
20856
  } | {
20857
20857
  addedToolNames?: string[];
20858
20858
  arguments: Record<string, any>;
20859
20859
  callID: string;
20860
20860
  name: string;
20861
20861
  namespace?: string;
20862
- partial?: {
20863
- content?: ({
20862
+ result: {
20863
+ content: ({
20864
20864
  type: "text";
20865
20865
  text: string;
20866
20866
  textSignature?: string;
@@ -20870,8 +20870,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20870
20870
  mimeType: string;
20871
20871
  })[];
20872
20872
  details?: any;
20873
+ isError: false;
20873
20874
  };
20874
- status: "running";
20875
+ status: "completed";
20875
20876
  thoughtSignature?: string;
20876
20877
  time: {
20877
20878
  start: number;
@@ -20895,9 +20896,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20895
20896
  mimeType: string;
20896
20897
  })[];
20897
20898
  details?: any;
20898
- isError: false;
20899
+ isError: true;
20899
20900
  };
20900
- status: "completed";
20901
+ status: "error";
20901
20902
  thoughtSignature?: string;
20902
20903
  time: {
20903
20904
  start: number;
@@ -20923,7 +20924,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20923
20924
  details?: any;
20924
20925
  isError: true;
20925
20926
  };
20926
- status: "error";
20927
+ status: "skipped";
20927
20928
  thoughtSignature?: string;
20928
20929
  time: {
20929
20930
  start: number;
@@ -20949,21 +20950,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20949
20950
  details?: any;
20950
20951
  isError: true;
20951
20952
  };
20952
- status: "skipped";
20953
+ status: "aborted";
20953
20954
  thoughtSignature?: string;
20954
20955
  time: {
20955
20956
  start: number;
20956
20957
  end: number;
20957
20958
  };
20958
20959
  type: "toolCall";
20960
+ } | {
20961
+ type: "thinking";
20962
+ thinking: string;
20963
+ thinkingSignature?: string;
20964
+ redacted?: boolean;
20959
20965
  } | {
20960
20966
  addedToolNames?: string[];
20961
20967
  arguments: Record<string, any>;
20962
20968
  callID: string;
20963
20969
  name: string;
20964
20970
  namespace?: string;
20965
- result: {
20966
- content: ({
20971
+ partial?: {
20972
+ content?: ({
20967
20973
  type: "text";
20968
20974
  text: string;
20969
20975
  textSignature?: string;
@@ -20973,9 +20979,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20973
20979
  mimeType: string;
20974
20980
  })[];
20975
20981
  details?: any;
20976
- isError: true;
20977
20982
  };
20978
- status: "aborted";
20983
+ status: "running";
20979
20984
  thoughtSignature?: string;
20980
20985
  time: {
20981
20986
  start: number;
@@ -21150,19 +21155,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21150
21155
  type: "image";
21151
21156
  data: string;
21152
21157
  mimeType: string;
21153
- } | {
21154
- type: "thinking";
21155
- thinking: string;
21156
- thinkingSignature?: string;
21157
- redacted?: boolean;
21158
21158
  } | {
21159
21159
  addedToolNames?: string[];
21160
21160
  arguments: Record<string, any>;
21161
21161
  callID: string;
21162
21162
  name: string;
21163
21163
  namespace?: string;
21164
- partial?: {
21165
- content?: ({
21164
+ result: {
21165
+ content: ({
21166
21166
  type: "text";
21167
21167
  text: string;
21168
21168
  textSignature?: string;
@@ -21172,8 +21172,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21172
21172
  mimeType: string;
21173
21173
  })[];
21174
21174
  details?: any;
21175
+ isError: false;
21175
21176
  };
21176
- status: "running";
21177
+ status: "completed";
21177
21178
  thoughtSignature?: string;
21178
21179
  time: {
21179
21180
  start: number;
@@ -21197,9 +21198,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21197
21198
  mimeType: string;
21198
21199
  })[];
21199
21200
  details?: any;
21200
- isError: false;
21201
+ isError: true;
21201
21202
  };
21202
- status: "completed";
21203
+ status: "error";
21203
21204
  thoughtSignature?: string;
21204
21205
  time: {
21205
21206
  start: number;
@@ -21225,7 +21226,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21225
21226
  details?: any;
21226
21227
  isError: true;
21227
21228
  };
21228
- status: "error";
21229
+ status: "skipped";
21229
21230
  thoughtSignature?: string;
21230
21231
  time: {
21231
21232
  start: number;
@@ -21251,21 +21252,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21251
21252
  details?: any;
21252
21253
  isError: true;
21253
21254
  };
21254
- status: "skipped";
21255
+ status: "aborted";
21255
21256
  thoughtSignature?: string;
21256
21257
  time: {
21257
21258
  start: number;
21258
21259
  end: number;
21259
21260
  };
21260
21261
  type: "toolCall";
21262
+ } | {
21263
+ type: "thinking";
21264
+ thinking: string;
21265
+ thinkingSignature?: string;
21266
+ redacted?: boolean;
21261
21267
  } | {
21262
21268
  addedToolNames?: string[];
21263
21269
  arguments: Record<string, any>;
21264
21270
  callID: string;
21265
21271
  name: string;
21266
21272
  namespace?: string;
21267
- result: {
21268
- content: ({
21273
+ partial?: {
21274
+ content?: ({
21269
21275
  type: "text";
21270
21276
  text: string;
21271
21277
  textSignature?: string;
@@ -21275,9 +21281,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21275
21281
  mimeType: string;
21276
21282
  })[];
21277
21283
  details?: any;
21278
- isError: true;
21279
21284
  };
21280
- status: "aborted";
21285
+ status: "running";
21281
21286
  thoughtSignature?: string;
21282
21287
  time: {
21283
21288
  start: number;
@@ -21470,19 +21475,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21470
21475
  type: "image";
21471
21476
  data: string;
21472
21477
  mimeType: string;
21473
- } | {
21474
- type: "thinking";
21475
- thinking: string;
21476
- thinkingSignature?: string;
21477
- redacted?: boolean;
21478
21478
  } | {
21479
21479
  addedToolNames?: string[];
21480
21480
  arguments: Record<string, any>;
21481
21481
  callID: string;
21482
21482
  name: string;
21483
21483
  namespace?: string;
21484
- partial?: {
21485
- content?: ({
21484
+ result: {
21485
+ content: ({
21486
21486
  type: "text";
21487
21487
  text: string;
21488
21488
  textSignature?: string;
@@ -21492,8 +21492,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21492
21492
  mimeType: string;
21493
21493
  })[];
21494
21494
  details?: any;
21495
+ isError: false;
21495
21496
  };
21496
- status: "running";
21497
+ status: "completed";
21497
21498
  thoughtSignature?: string;
21498
21499
  time: {
21499
21500
  start: number;
@@ -21517,9 +21518,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21517
21518
  mimeType: string;
21518
21519
  })[];
21519
21520
  details?: any;
21520
- isError: false;
21521
+ isError: true;
21521
21522
  };
21522
- status: "completed";
21523
+ status: "error";
21523
21524
  thoughtSignature?: string;
21524
21525
  time: {
21525
21526
  start: number;
@@ -21545,7 +21546,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21545
21546
  details?: any;
21546
21547
  isError: true;
21547
21548
  };
21548
- status: "error";
21549
+ status: "skipped";
21549
21550
  thoughtSignature?: string;
21550
21551
  time: {
21551
21552
  start: number;
@@ -21571,21 +21572,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21571
21572
  details?: any;
21572
21573
  isError: true;
21573
21574
  };
21574
- status: "skipped";
21575
+ status: "aborted";
21575
21576
  thoughtSignature?: string;
21576
21577
  time: {
21577
21578
  start: number;
21578
21579
  end: number;
21579
21580
  };
21580
21581
  type: "toolCall";
21582
+ } | {
21583
+ type: "thinking";
21584
+ thinking: string;
21585
+ thinkingSignature?: string;
21586
+ redacted?: boolean;
21581
21587
  } | {
21582
21588
  addedToolNames?: string[];
21583
21589
  arguments: Record<string, any>;
21584
21590
  callID: string;
21585
21591
  name: string;
21586
21592
  namespace?: string;
21587
- result: {
21588
- content: ({
21593
+ partial?: {
21594
+ content?: ({
21589
21595
  type: "text";
21590
21596
  text: string;
21591
21597
  textSignature?: string;
@@ -21595,9 +21601,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21595
21601
  mimeType: string;
21596
21602
  })[];
21597
21603
  details?: any;
21598
- isError: true;
21599
21604
  };
21600
- status: "aborted";
21605
+ status: "running";
21601
21606
  thoughtSignature?: string;
21602
21607
  time: {
21603
21608
  start: number;
@@ -21772,19 +21777,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21772
21777
  type: "image";
21773
21778
  data: string;
21774
21779
  mimeType: string;
21775
- } | {
21776
- type: "thinking";
21777
- thinking: string;
21778
- thinkingSignature?: string;
21779
- redacted?: boolean;
21780
21780
  } | {
21781
21781
  addedToolNames?: string[];
21782
21782
  arguments: Record<string, any>;
21783
21783
  callID: string;
21784
21784
  name: string;
21785
21785
  namespace?: string;
21786
- partial?: {
21787
- content?: ({
21786
+ result: {
21787
+ content: ({
21788
21788
  type: "text";
21789
21789
  text: string;
21790
21790
  textSignature?: string;
@@ -21794,8 +21794,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21794
21794
  mimeType: string;
21795
21795
  })[];
21796
21796
  details?: any;
21797
+ isError: false;
21797
21798
  };
21798
- status: "running";
21799
+ status: "completed";
21799
21800
  thoughtSignature?: string;
21800
21801
  time: {
21801
21802
  start: number;
@@ -21819,9 +21820,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21819
21820
  mimeType: string;
21820
21821
  })[];
21821
21822
  details?: any;
21822
- isError: false;
21823
+ isError: true;
21823
21824
  };
21824
- status: "completed";
21825
+ status: "error";
21825
21826
  thoughtSignature?: string;
21826
21827
  time: {
21827
21828
  start: number;
@@ -21847,7 +21848,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21847
21848
  details?: any;
21848
21849
  isError: true;
21849
21850
  };
21850
- status: "error";
21851
+ status: "skipped";
21851
21852
  thoughtSignature?: string;
21852
21853
  time: {
21853
21854
  start: number;
@@ -21873,21 +21874,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21873
21874
  details?: any;
21874
21875
  isError: true;
21875
21876
  };
21876
- status: "skipped";
21877
+ status: "aborted";
21877
21878
  thoughtSignature?: string;
21878
21879
  time: {
21879
21880
  start: number;
21880
21881
  end: number;
21881
21882
  };
21882
21883
  type: "toolCall";
21884
+ } | {
21885
+ type: "thinking";
21886
+ thinking: string;
21887
+ thinkingSignature?: string;
21888
+ redacted?: boolean;
21883
21889
  } | {
21884
21890
  addedToolNames?: string[];
21885
21891
  arguments: Record<string, any>;
21886
21892
  callID: string;
21887
21893
  name: string;
21888
21894
  namespace?: string;
21889
- result: {
21890
- content: ({
21895
+ partial?: {
21896
+ content?: ({
21891
21897
  type: "text";
21892
21898
  text: string;
21893
21899
  textSignature?: string;
@@ -21897,9 +21903,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21897
21903
  mimeType: string;
21898
21904
  })[];
21899
21905
  details?: any;
21900
- isError: true;
21901
21906
  };
21902
- status: "aborted";
21907
+ status: "running";
21903
21908
  thoughtSignature?: string;
21904
21909
  time: {
21905
21910
  start: number;
@@ -22102,19 +22107,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22102
22107
  type: "image";
22103
22108
  data: string;
22104
22109
  mimeType: string;
22105
- } | {
22106
- type: "thinking";
22107
- thinking: string;
22108
- thinkingSignature?: string;
22109
- redacted?: boolean;
22110
22110
  } | {
22111
22111
  addedToolNames?: string[];
22112
22112
  arguments: Record<string, any>;
22113
22113
  callID: string;
22114
22114
  name: string;
22115
22115
  namespace?: string;
22116
- partial?: {
22117
- content?: ({
22116
+ result: {
22117
+ content: ({
22118
22118
  type: "text";
22119
22119
  text: string;
22120
22120
  textSignature?: string;
@@ -22124,8 +22124,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22124
22124
  mimeType: string;
22125
22125
  })[];
22126
22126
  details?: any;
22127
+ isError: false;
22127
22128
  };
22128
- status: "running";
22129
+ status: "completed";
22129
22130
  thoughtSignature?: string;
22130
22131
  time: {
22131
22132
  start: number;
@@ -22149,9 +22150,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22149
22150
  mimeType: string;
22150
22151
  })[];
22151
22152
  details?: any;
22152
- isError: false;
22153
+ isError: true;
22153
22154
  };
22154
- status: "completed";
22155
+ status: "error";
22155
22156
  thoughtSignature?: string;
22156
22157
  time: {
22157
22158
  start: number;
@@ -22177,7 +22178,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22177
22178
  details?: any;
22178
22179
  isError: true;
22179
22180
  };
22180
- status: "error";
22181
+ status: "skipped";
22181
22182
  thoughtSignature?: string;
22182
22183
  time: {
22183
22184
  start: number;
@@ -22203,21 +22204,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22203
22204
  details?: any;
22204
22205
  isError: true;
22205
22206
  };
22206
- status: "skipped";
22207
+ status: "aborted";
22207
22208
  thoughtSignature?: string;
22208
22209
  time: {
22209
22210
  start: number;
22210
22211
  end: number;
22211
22212
  };
22212
22213
  type: "toolCall";
22214
+ } | {
22215
+ type: "thinking";
22216
+ thinking: string;
22217
+ thinkingSignature?: string;
22218
+ redacted?: boolean;
22213
22219
  } | {
22214
22220
  addedToolNames?: string[];
22215
22221
  arguments: Record<string, any>;
22216
22222
  callID: string;
22217
22223
  name: string;
22218
22224
  namespace?: string;
22219
- result: {
22220
- content: ({
22225
+ partial?: {
22226
+ content?: ({
22221
22227
  type: "text";
22222
22228
  text: string;
22223
22229
  textSignature?: string;
@@ -22227,9 +22233,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22227
22233
  mimeType: string;
22228
22234
  })[];
22229
22235
  details?: any;
22230
- isError: true;
22231
22236
  };
22232
- status: "aborted";
22237
+ status: "running";
22233
22238
  thoughtSignature?: string;
22234
22239
  time: {
22235
22240
  start: number;
@@ -22404,19 +22409,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22404
22409
  type: "image";
22405
22410
  data: string;
22406
22411
  mimeType: string;
22407
- } | {
22408
- type: "thinking";
22409
- thinking: string;
22410
- thinkingSignature?: string;
22411
- redacted?: boolean;
22412
22412
  } | {
22413
22413
  addedToolNames?: string[];
22414
22414
  arguments: Record<string, any>;
22415
22415
  callID: string;
22416
22416
  name: string;
22417
22417
  namespace?: string;
22418
- partial?: {
22419
- content?: ({
22418
+ result: {
22419
+ content: ({
22420
22420
  type: "text";
22421
22421
  text: string;
22422
22422
  textSignature?: string;
@@ -22426,8 +22426,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22426
22426
  mimeType: string;
22427
22427
  })[];
22428
22428
  details?: any;
22429
+ isError: false;
22429
22430
  };
22430
- status: "running";
22431
+ status: "completed";
22431
22432
  thoughtSignature?: string;
22432
22433
  time: {
22433
22434
  start: number;
@@ -22451,9 +22452,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22451
22452
  mimeType: string;
22452
22453
  })[];
22453
22454
  details?: any;
22454
- isError: false;
22455
+ isError: true;
22455
22456
  };
22456
- status: "completed";
22457
+ status: "error";
22457
22458
  thoughtSignature?: string;
22458
22459
  time: {
22459
22460
  start: number;
@@ -22479,7 +22480,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22479
22480
  details?: any;
22480
22481
  isError: true;
22481
22482
  };
22482
- status: "error";
22483
+ status: "skipped";
22483
22484
  thoughtSignature?: string;
22484
22485
  time: {
22485
22486
  start: number;
@@ -22505,21 +22506,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22505
22506
  details?: any;
22506
22507
  isError: true;
22507
22508
  };
22508
- status: "skipped";
22509
+ status: "aborted";
22509
22510
  thoughtSignature?: string;
22510
22511
  time: {
22511
22512
  start: number;
22512
22513
  end: number;
22513
22514
  };
22514
22515
  type: "toolCall";
22516
+ } | {
22517
+ type: "thinking";
22518
+ thinking: string;
22519
+ thinkingSignature?: string;
22520
+ redacted?: boolean;
22515
22521
  } | {
22516
22522
  addedToolNames?: string[];
22517
22523
  arguments: Record<string, any>;
22518
22524
  callID: string;
22519
22525
  name: string;
22520
22526
  namespace?: string;
22521
- result: {
22522
- content: ({
22527
+ partial?: {
22528
+ content?: ({
22523
22529
  type: "text";
22524
22530
  text: string;
22525
22531
  textSignature?: string;
@@ -22529,9 +22535,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22529
22535
  mimeType: string;
22530
22536
  })[];
22531
22537
  details?: any;
22532
- isError: true;
22533
22538
  };
22534
- status: "aborted";
22539
+ status: "running";
22535
22540
  thoughtSignature?: string;
22536
22541
  time: {
22537
22542
  start: number;
@@ -22725,19 +22730,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22725
22730
  type: "image";
22726
22731
  data: string;
22727
22732
  mimeType: string;
22728
- } | {
22729
- type: "thinking";
22730
- thinking: string;
22731
- thinkingSignature?: string;
22732
- redacted?: boolean;
22733
22733
  } | {
22734
22734
  addedToolNames?: string[];
22735
22735
  arguments: Record<string, any>;
22736
22736
  callID: string;
22737
22737
  name: string;
22738
22738
  namespace?: string;
22739
- partial?: {
22740
- content?: ({
22739
+ result: {
22740
+ content: ({
22741
22741
  type: "text";
22742
22742
  text: string;
22743
22743
  textSignature?: string;
@@ -22747,8 +22747,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22747
22747
  mimeType: string;
22748
22748
  })[];
22749
22749
  details?: any;
22750
+ isError: false;
22750
22751
  };
22751
- status: "running";
22752
+ status: "completed";
22752
22753
  thoughtSignature?: string;
22753
22754
  time: {
22754
22755
  start: number;
@@ -22772,9 +22773,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22772
22773
  mimeType: string;
22773
22774
  })[];
22774
22775
  details?: any;
22775
- isError: false;
22776
+ isError: true;
22776
22777
  };
22777
- status: "completed";
22778
+ status: "error";
22778
22779
  thoughtSignature?: string;
22779
22780
  time: {
22780
22781
  start: number;
@@ -22800,7 +22801,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22800
22801
  details?: any;
22801
22802
  isError: true;
22802
22803
  };
22803
- status: "error";
22804
+ status: "skipped";
22804
22805
  thoughtSignature?: string;
22805
22806
  time: {
22806
22807
  start: number;
@@ -22826,21 +22827,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22826
22827
  details?: any;
22827
22828
  isError: true;
22828
22829
  };
22829
- status: "skipped";
22830
+ status: "aborted";
22830
22831
  thoughtSignature?: string;
22831
22832
  time: {
22832
22833
  start: number;
22833
22834
  end: number;
22834
22835
  };
22835
22836
  type: "toolCall";
22837
+ } | {
22838
+ type: "thinking";
22839
+ thinking: string;
22840
+ thinkingSignature?: string;
22841
+ redacted?: boolean;
22836
22842
  } | {
22837
22843
  addedToolNames?: string[];
22838
22844
  arguments: Record<string, any>;
22839
22845
  callID: string;
22840
22846
  name: string;
22841
22847
  namespace?: string;
22842
- result: {
22843
- content: ({
22848
+ partial?: {
22849
+ content?: ({
22844
22850
  type: "text";
22845
22851
  text: string;
22846
22852
  textSignature?: string;
@@ -22850,9 +22856,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22850
22856
  mimeType: string;
22851
22857
  })[];
22852
22858
  details?: any;
22853
- isError: true;
22854
22859
  };
22855
- status: "aborted";
22860
+ status: "running";
22856
22861
  thoughtSignature?: string;
22857
22862
  time: {
22858
22863
  start: number;
@@ -23027,19 +23032,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23027
23032
  type: "image";
23028
23033
  data: string;
23029
23034
  mimeType: string;
23030
- } | {
23031
- type: "thinking";
23032
- thinking: string;
23033
- thinkingSignature?: string;
23034
- redacted?: boolean;
23035
23035
  } | {
23036
23036
  addedToolNames?: string[];
23037
23037
  arguments: Record<string, any>;
23038
23038
  callID: string;
23039
23039
  name: string;
23040
23040
  namespace?: string;
23041
- partial?: {
23042
- content?: ({
23041
+ result: {
23042
+ content: ({
23043
23043
  type: "text";
23044
23044
  text: string;
23045
23045
  textSignature?: string;
@@ -23049,8 +23049,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23049
23049
  mimeType: string;
23050
23050
  })[];
23051
23051
  details?: any;
23052
+ isError: false;
23052
23053
  };
23053
- status: "running";
23054
+ status: "completed";
23054
23055
  thoughtSignature?: string;
23055
23056
  time: {
23056
23057
  start: number;
@@ -23074,9 +23075,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23074
23075
  mimeType: string;
23075
23076
  })[];
23076
23077
  details?: any;
23077
- isError: false;
23078
+ isError: true;
23078
23079
  };
23079
- status: "completed";
23080
+ status: "error";
23080
23081
  thoughtSignature?: string;
23081
23082
  time: {
23082
23083
  start: number;
@@ -23102,7 +23103,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23102
23103
  details?: any;
23103
23104
  isError: true;
23104
23105
  };
23105
- status: "error";
23106
+ status: "skipped";
23106
23107
  thoughtSignature?: string;
23107
23108
  time: {
23108
23109
  start: number;
@@ -23128,21 +23129,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23128
23129
  details?: any;
23129
23130
  isError: true;
23130
23131
  };
23131
- status: "skipped";
23132
+ status: "aborted";
23132
23133
  thoughtSignature?: string;
23133
23134
  time: {
23134
23135
  start: number;
23135
23136
  end: number;
23136
23137
  };
23137
23138
  type: "toolCall";
23139
+ } | {
23140
+ type: "thinking";
23141
+ thinking: string;
23142
+ thinkingSignature?: string;
23143
+ redacted?: boolean;
23138
23144
  } | {
23139
23145
  addedToolNames?: string[];
23140
23146
  arguments: Record<string, any>;
23141
23147
  callID: string;
23142
23148
  name: string;
23143
23149
  namespace?: string;
23144
- result: {
23145
- content: ({
23150
+ partial?: {
23151
+ content?: ({
23146
23152
  type: "text";
23147
23153
  text: string;
23148
23154
  textSignature?: string;
@@ -23152,9 +23158,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23152
23158
  mimeType: string;
23153
23159
  })[];
23154
23160
  details?: any;
23155
- isError: true;
23156
23161
  };
23157
- status: "aborted";
23162
+ status: "running";
23158
23163
  thoughtSignature?: string;
23159
23164
  time: {
23160
23165
  start: number;
@@ -23357,19 +23362,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23357
23362
  type: "image";
23358
23363
  data: string;
23359
23364
  mimeType: string;
23360
- } | {
23361
- type: "thinking";
23362
- thinking: string;
23363
- thinkingSignature?: string;
23364
- redacted?: boolean;
23365
23365
  } | {
23366
23366
  addedToolNames?: string[];
23367
23367
  arguments: Record<string, any>;
23368
23368
  callID: string;
23369
23369
  name: string;
23370
23370
  namespace?: string;
23371
- partial?: {
23372
- content?: ({
23371
+ result: {
23372
+ content: ({
23373
23373
  type: "text";
23374
23374
  text: string;
23375
23375
  textSignature?: string;
@@ -23379,8 +23379,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23379
23379
  mimeType: string;
23380
23380
  })[];
23381
23381
  details?: any;
23382
+ isError: false;
23382
23383
  };
23383
- status: "running";
23384
+ status: "completed";
23384
23385
  thoughtSignature?: string;
23385
23386
  time: {
23386
23387
  start: number;
@@ -23404,9 +23405,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23404
23405
  mimeType: string;
23405
23406
  })[];
23406
23407
  details?: any;
23407
- isError: false;
23408
+ isError: true;
23408
23409
  };
23409
- status: "completed";
23410
+ status: "error";
23410
23411
  thoughtSignature?: string;
23411
23412
  time: {
23412
23413
  start: number;
@@ -23432,7 +23433,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23432
23433
  details?: any;
23433
23434
  isError: true;
23434
23435
  };
23435
- status: "error";
23436
+ status: "skipped";
23436
23437
  thoughtSignature?: string;
23437
23438
  time: {
23438
23439
  start: number;
@@ -23458,21 +23459,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23458
23459
  details?: any;
23459
23460
  isError: true;
23460
23461
  };
23461
- status: "skipped";
23462
+ status: "aborted";
23462
23463
  thoughtSignature?: string;
23463
23464
  time: {
23464
23465
  start: number;
23465
23466
  end: number;
23466
23467
  };
23467
23468
  type: "toolCall";
23469
+ } | {
23470
+ type: "thinking";
23471
+ thinking: string;
23472
+ thinkingSignature?: string;
23473
+ redacted?: boolean;
23468
23474
  } | {
23469
23475
  addedToolNames?: string[];
23470
23476
  arguments: Record<string, any>;
23471
23477
  callID: string;
23472
23478
  name: string;
23473
23479
  namespace?: string;
23474
- result: {
23475
- content: ({
23480
+ partial?: {
23481
+ content?: ({
23476
23482
  type: "text";
23477
23483
  text: string;
23478
23484
  textSignature?: string;
@@ -23482,9 +23488,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23482
23488
  mimeType: string;
23483
23489
  })[];
23484
23490
  details?: any;
23485
- isError: true;
23486
23491
  };
23487
- status: "aborted";
23492
+ status: "running";
23488
23493
  thoughtSignature?: string;
23489
23494
  time: {
23490
23495
  start: number;
@@ -23659,19 +23664,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23659
23664
  type: "image";
23660
23665
  data: string;
23661
23666
  mimeType: string;
23662
- } | {
23663
- type: "thinking";
23664
- thinking: string;
23665
- thinkingSignature?: string;
23666
- redacted?: boolean;
23667
23667
  } | {
23668
23668
  addedToolNames?: string[];
23669
23669
  arguments: Record<string, any>;
23670
23670
  callID: string;
23671
23671
  name: string;
23672
23672
  namespace?: string;
23673
- partial?: {
23674
- content?: ({
23673
+ result: {
23674
+ content: ({
23675
23675
  type: "text";
23676
23676
  text: string;
23677
23677
  textSignature?: string;
@@ -23681,8 +23681,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23681
23681
  mimeType: string;
23682
23682
  })[];
23683
23683
  details?: any;
23684
+ isError: false;
23684
23685
  };
23685
- status: "running";
23686
+ status: "completed";
23686
23687
  thoughtSignature?: string;
23687
23688
  time: {
23688
23689
  start: number;
@@ -23706,9 +23707,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23706
23707
  mimeType: string;
23707
23708
  })[];
23708
23709
  details?: any;
23709
- isError: false;
23710
+ isError: true;
23710
23711
  };
23711
- status: "completed";
23712
+ status: "error";
23712
23713
  thoughtSignature?: string;
23713
23714
  time: {
23714
23715
  start: number;
@@ -23734,7 +23735,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23734
23735
  details?: any;
23735
23736
  isError: true;
23736
23737
  };
23737
- status: "error";
23738
+ status: "skipped";
23738
23739
  thoughtSignature?: string;
23739
23740
  time: {
23740
23741
  start: number;
@@ -23760,21 +23761,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23760
23761
  details?: any;
23761
23762
  isError: true;
23762
23763
  };
23763
- status: "skipped";
23764
+ status: "aborted";
23764
23765
  thoughtSignature?: string;
23765
23766
  time: {
23766
23767
  start: number;
23767
23768
  end: number;
23768
23769
  };
23769
23770
  type: "toolCall";
23771
+ } | {
23772
+ type: "thinking";
23773
+ thinking: string;
23774
+ thinkingSignature?: string;
23775
+ redacted?: boolean;
23770
23776
  } | {
23771
23777
  addedToolNames?: string[];
23772
23778
  arguments: Record<string, any>;
23773
23779
  callID: string;
23774
23780
  name: string;
23775
23781
  namespace?: string;
23776
- result: {
23777
- content: ({
23782
+ partial?: {
23783
+ content?: ({
23778
23784
  type: "text";
23779
23785
  text: string;
23780
23786
  textSignature?: string;
@@ -23784,9 +23790,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23784
23790
  mimeType: string;
23785
23791
  })[];
23786
23792
  details?: any;
23787
- isError: true;
23788
23793
  };
23789
- status: "aborted";
23794
+ status: "running";
23790
23795
  thoughtSignature?: string;
23791
23796
  time: {
23792
23797
  start: number;
@@ -23980,19 +23985,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23980
23985
  type: "image";
23981
23986
  data: string;
23982
23987
  mimeType: string;
23983
- } | {
23984
- type: "thinking";
23985
- thinking: string;
23986
- thinkingSignature?: string;
23987
- redacted?: boolean;
23988
23988
  } | {
23989
23989
  addedToolNames?: string[];
23990
23990
  arguments: Record<string, any>;
23991
23991
  callID: string;
23992
23992
  name: string;
23993
23993
  namespace?: string;
23994
- partial?: {
23995
- content?: ({
23994
+ result: {
23995
+ content: ({
23996
23996
  type: "text";
23997
23997
  text: string;
23998
23998
  textSignature?: string;
@@ -24002,8 +24002,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24002
24002
  mimeType: string;
24003
24003
  })[];
24004
24004
  details?: any;
24005
+ isError: false;
24005
24006
  };
24006
- status: "running";
24007
+ status: "completed";
24007
24008
  thoughtSignature?: string;
24008
24009
  time: {
24009
24010
  start: number;
@@ -24027,9 +24028,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24027
24028
  mimeType: string;
24028
24029
  })[];
24029
24030
  details?: any;
24030
- isError: false;
24031
+ isError: true;
24031
24032
  };
24032
- status: "completed";
24033
+ status: "error";
24033
24034
  thoughtSignature?: string;
24034
24035
  time: {
24035
24036
  start: number;
@@ -24055,7 +24056,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24055
24056
  details?: any;
24056
24057
  isError: true;
24057
24058
  };
24058
- status: "error";
24059
+ status: "skipped";
24059
24060
  thoughtSignature?: string;
24060
24061
  time: {
24061
24062
  start: number;
@@ -24081,21 +24082,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24081
24082
  details?: any;
24082
24083
  isError: true;
24083
24084
  };
24084
- status: "skipped";
24085
+ status: "aborted";
24085
24086
  thoughtSignature?: string;
24086
24087
  time: {
24087
24088
  start: number;
24088
24089
  end: number;
24089
24090
  };
24090
24091
  type: "toolCall";
24092
+ } | {
24093
+ type: "thinking";
24094
+ thinking: string;
24095
+ thinkingSignature?: string;
24096
+ redacted?: boolean;
24091
24097
  } | {
24092
24098
  addedToolNames?: string[];
24093
24099
  arguments: Record<string, any>;
24094
24100
  callID: string;
24095
24101
  name: string;
24096
24102
  namespace?: string;
24097
- result: {
24098
- content: ({
24103
+ partial?: {
24104
+ content?: ({
24099
24105
  type: "text";
24100
24106
  text: string;
24101
24107
  textSignature?: string;
@@ -24105,9 +24111,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24105
24111
  mimeType: string;
24106
24112
  })[];
24107
24113
  details?: any;
24108
- isError: true;
24109
24114
  };
24110
- status: "aborted";
24115
+ status: "running";
24111
24116
  thoughtSignature?: string;
24112
24117
  time: {
24113
24118
  start: number;
@@ -24282,19 +24287,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24282
24287
  type: "image";
24283
24288
  data: string;
24284
24289
  mimeType: string;
24285
- } | {
24286
- type: "thinking";
24287
- thinking: string;
24288
- thinkingSignature?: string;
24289
- redacted?: boolean;
24290
24290
  } | {
24291
24291
  addedToolNames?: string[];
24292
24292
  arguments: Record<string, any>;
24293
24293
  callID: string;
24294
24294
  name: string;
24295
24295
  namespace?: string;
24296
- partial?: {
24297
- content?: ({
24296
+ result: {
24297
+ content: ({
24298
24298
  type: "text";
24299
24299
  text: string;
24300
24300
  textSignature?: string;
@@ -24304,8 +24304,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24304
24304
  mimeType: string;
24305
24305
  })[];
24306
24306
  details?: any;
24307
+ isError: false;
24307
24308
  };
24308
- status: "running";
24309
+ status: "completed";
24309
24310
  thoughtSignature?: string;
24310
24311
  time: {
24311
24312
  start: number;
@@ -24329,9 +24330,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24329
24330
  mimeType: string;
24330
24331
  })[];
24331
24332
  details?: any;
24332
- isError: false;
24333
+ isError: true;
24333
24334
  };
24334
- status: "completed";
24335
+ status: "error";
24335
24336
  thoughtSignature?: string;
24336
24337
  time: {
24337
24338
  start: number;
@@ -24357,7 +24358,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24357
24358
  details?: any;
24358
24359
  isError: true;
24359
24360
  };
24360
- status: "error";
24361
+ status: "skipped";
24361
24362
  thoughtSignature?: string;
24362
24363
  time: {
24363
24364
  start: number;
@@ -24383,21 +24384,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24383
24384
  details?: any;
24384
24385
  isError: true;
24385
24386
  };
24386
- status: "skipped";
24387
+ status: "aborted";
24387
24388
  thoughtSignature?: string;
24388
24389
  time: {
24389
24390
  start: number;
24390
24391
  end: number;
24391
24392
  };
24392
24393
  type: "toolCall";
24394
+ } | {
24395
+ type: "thinking";
24396
+ thinking: string;
24397
+ thinkingSignature?: string;
24398
+ redacted?: boolean;
24393
24399
  } | {
24394
24400
  addedToolNames?: string[];
24395
24401
  arguments: Record<string, any>;
24396
24402
  callID: string;
24397
24403
  name: string;
24398
24404
  namespace?: string;
24399
- result: {
24400
- content: ({
24405
+ partial?: {
24406
+ content?: ({
24401
24407
  type: "text";
24402
24408
  text: string;
24403
24409
  textSignature?: string;
@@ -24407,9 +24413,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24407
24413
  mimeType: string;
24408
24414
  })[];
24409
24415
  details?: any;
24410
- isError: true;
24411
24416
  };
24412
- status: "aborted";
24417
+ status: "running";
24413
24418
  thoughtSignature?: string;
24414
24419
  time: {
24415
24420
  start: number;