@codeworksh/harness 0.3.0-canary.30.1.gf08d05b0 → 0.3.0-canary.32.1.g414f2b97

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 +861 -820
  2. package/effect.mjs +27 -1
  3. package/effect.mjs.map +1 -1
  4. package/package.json +3 -3
package/effect.d.mts CHANGED
@@ -1156,6 +1156,8 @@ interface Interface$16 {
1156
1156
  readonly get: (sessionId: ID$1) => Effect.Effect<Option.Option<SessionRow>>;
1157
1157
  /** The space a session attaches to — its env and absolute location. None when the session is unknown. */
1158
1158
  readonly space: (sessionId: ID$1) => Effect.Effect<Option.Option<schema_d_exports$7.SpaceSchema.Info>>;
1159
+ /** The project a session belongs to, through its space. None when the session is unknown. */
1160
+ readonly project: (sessionId: ID$1) => Effect.Effect<Option.Option<schema_d_exports$9.ProjectSchema.Info>>;
1159
1161
  /** Sessions newest first, across the whole database when no scope is given. */
1160
1162
  readonly list: (input?: ListInput$1) => Effect.Effect<SessionRow[]>;
1161
1163
  readonly entry: (entryId: string) => Effect.Effect<Option.Option<HydratedEntry>>;
@@ -2715,21 +2717,6 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2715
2717
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2716
2718
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2717
2719
  declare const encodeMessage: (message: {
2718
- messageId: string;
2719
- role: "user";
2720
- time: {
2721
- created: number;
2722
- };
2723
- parts: ({
2724
- type: "text";
2725
- text: string;
2726
- textSignature?: string;
2727
- } | {
2728
- type: "image";
2729
- data: string;
2730
- mimeType: string;
2731
- })[];
2732
- } | {
2733
2720
  role: "assistant";
2734
2721
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2735
2722
  provider: {
@@ -2879,14 +2866,19 @@ declare const encodeMessage: (message: {
2879
2866
  type: "image";
2880
2867
  data: string;
2881
2868
  mimeType: string;
2869
+ } | {
2870
+ type: "thinking";
2871
+ thinking: string;
2872
+ thinkingSignature?: string;
2873
+ redacted?: boolean;
2882
2874
  } | {
2883
2875
  addedToolNames?: string[];
2884
2876
  arguments: Record<string, any>;
2885
2877
  callID: string;
2886
2878
  name: string;
2887
2879
  namespace?: string;
2888
- result: {
2889
- content: ({
2880
+ partial?: {
2881
+ content?: ({
2890
2882
  type: "text";
2891
2883
  text: string;
2892
2884
  textSignature?: string;
@@ -2896,9 +2888,8 @@ declare const encodeMessage: (message: {
2896
2888
  mimeType: string;
2897
2889
  })[];
2898
2890
  details?: any;
2899
- isError: false;
2900
2891
  };
2901
- status: "completed";
2892
+ status: "running";
2902
2893
  thoughtSignature?: string;
2903
2894
  time: {
2904
2895
  start: number;
@@ -2922,9 +2913,9 @@ declare const encodeMessage: (message: {
2922
2913
  mimeType: string;
2923
2914
  })[];
2924
2915
  details?: any;
2925
- isError: true;
2916
+ isError: false;
2926
2917
  };
2927
- status: "error";
2918
+ status: "completed";
2928
2919
  thoughtSignature?: string;
2929
2920
  time: {
2930
2921
  start: number;
@@ -2950,7 +2941,7 @@ declare const encodeMessage: (message: {
2950
2941
  details?: any;
2951
2942
  isError: true;
2952
2943
  };
2953
- status: "skipped";
2944
+ status: "error";
2954
2945
  thoughtSignature?: string;
2955
2946
  time: {
2956
2947
  start: number;
@@ -2976,26 +2967,21 @@ declare const encodeMessage: (message: {
2976
2967
  details?: any;
2977
2968
  isError: true;
2978
2969
  };
2979
- status: "aborted";
2970
+ status: "skipped";
2980
2971
  thoughtSignature?: string;
2981
2972
  time: {
2982
2973
  start: number;
2983
2974
  end: number;
2984
2975
  };
2985
2976
  type: "toolCall";
2986
- } | {
2987
- type: "thinking";
2988
- thinking: string;
2989
- thinkingSignature?: string;
2990
- redacted?: boolean;
2991
2977
  } | {
2992
2978
  addedToolNames?: string[];
2993
2979
  arguments: Record<string, any>;
2994
2980
  callID: string;
2995
2981
  name: string;
2996
2982
  namespace?: string;
2997
- partial?: {
2998
- content?: ({
2983
+ result: {
2984
+ content: ({
2999
2985
  type: "text";
3000
2986
  text: string;
3001
2987
  textSignature?: string;
@@ -3005,8 +2991,9 @@ declare const encodeMessage: (message: {
3005
2991
  mimeType: string;
3006
2992
  })[];
3007
2993
  details?: any;
2994
+ isError: true;
3008
2995
  };
3009
- status: "running";
2996
+ status: "aborted";
3010
2997
  thoughtSignature?: string;
3011
2998
  time: {
3012
2999
  start: number;
@@ -3031,8 +3018,7 @@ declare const encodeMessage: (message: {
3031
3018
  responseId?: string;
3032
3019
  responseModel?: string;
3033
3020
  messageId: string;
3034
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3035
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3021
+ } | {
3036
3022
  messageId: string;
3037
3023
  role: "user";
3038
3024
  time: {
@@ -3047,8 +3033,8 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3047
3033
  data: string;
3048
3034
  mimeType: string;
3049
3035
  })[];
3050
- }, ContextDecodeError, never>;
3051
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3036
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3037
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3052
3038
  messageId: string;
3053
3039
  role: "user";
3054
3040
  time: {
@@ -3063,7 +3049,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3063
3049
  data: string;
3064
3050
  mimeType: string;
3065
3051
  })[];
3066
- } | {
3052
+ }, ContextDecodeError, never>;
3053
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3067
3054
  role: "assistant";
3068
3055
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3069
3056
  provider: {
@@ -3213,14 +3200,19 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3213
3200
  type: "image";
3214
3201
  data: string;
3215
3202
  mimeType: string;
3203
+ } | {
3204
+ type: "thinking";
3205
+ thinking: string;
3206
+ thinkingSignature?: string;
3207
+ redacted?: boolean;
3216
3208
  } | {
3217
3209
  addedToolNames?: string[];
3218
3210
  arguments: Record<string, any>;
3219
3211
  callID: string;
3220
3212
  name: string;
3221
3213
  namespace?: string;
3222
- result: {
3223
- content: ({
3214
+ partial?: {
3215
+ content?: ({
3224
3216
  type: "text";
3225
3217
  text: string;
3226
3218
  textSignature?: string;
@@ -3230,9 +3222,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3230
3222
  mimeType: string;
3231
3223
  })[];
3232
3224
  details?: any;
3233
- isError: false;
3234
3225
  };
3235
- status: "completed";
3226
+ status: "running";
3236
3227
  thoughtSignature?: string;
3237
3228
  time: {
3238
3229
  start: number;
@@ -3256,9 +3247,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3256
3247
  mimeType: string;
3257
3248
  })[];
3258
3249
  details?: any;
3259
- isError: true;
3250
+ isError: false;
3260
3251
  };
3261
- status: "error";
3252
+ status: "completed";
3262
3253
  thoughtSignature?: string;
3263
3254
  time: {
3264
3255
  start: number;
@@ -3284,7 +3275,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3284
3275
  details?: any;
3285
3276
  isError: true;
3286
3277
  };
3287
- status: "skipped";
3278
+ status: "error";
3288
3279
  thoughtSignature?: string;
3289
3280
  time: {
3290
3281
  start: number;
@@ -3310,26 +3301,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3310
3301
  details?: any;
3311
3302
  isError: true;
3312
3303
  };
3313
- status: "aborted";
3304
+ status: "skipped";
3314
3305
  thoughtSignature?: string;
3315
3306
  time: {
3316
3307
  start: number;
3317
3308
  end: number;
3318
3309
  };
3319
3310
  type: "toolCall";
3320
- } | {
3321
- type: "thinking";
3322
- thinking: string;
3323
- thinkingSignature?: string;
3324
- redacted?: boolean;
3325
3311
  } | {
3326
3312
  addedToolNames?: string[];
3327
3313
  arguments: Record<string, any>;
3328
3314
  callID: string;
3329
3315
  name: string;
3330
3316
  namespace?: string;
3331
- partial?: {
3332
- content?: ({
3317
+ result: {
3318
+ content: ({
3333
3319
  type: "text";
3334
3320
  text: string;
3335
3321
  textSignature?: string;
@@ -3339,8 +3325,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3339
3325
  mimeType: string;
3340
3326
  })[];
3341
3327
  details?: any;
3328
+ isError: true;
3342
3329
  };
3343
- status: "running";
3330
+ status: "aborted";
3344
3331
  thoughtSignature?: string;
3345
3332
  time: {
3346
3333
  start: number;
@@ -3365,6 +3352,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3365
3352
  responseId?: string;
3366
3353
  responseModel?: string;
3367
3354
  messageId: string;
3355
+ } | {
3356
+ messageId: string;
3357
+ role: "user";
3358
+ time: {
3359
+ created: number;
3360
+ };
3361
+ parts: ({
3362
+ type: "text";
3363
+ text: string;
3364
+ textSignature?: string;
3365
+ } | {
3366
+ type: "image";
3367
+ data: string;
3368
+ mimeType: string;
3369
+ })[];
3368
3370
  }, ContextDecodeError, never>;
3369
3371
  declare namespace context_d_exports {
3370
3372
  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 };
@@ -4029,6 +4031,18 @@ interface Info$1 {
4029
4031
  */
4030
4032
  readonly hasHostLink: boolean;
4031
4033
  readonly sandbox?: Info$2;
4034
+ /** Absent only when the session's space or project row is missing. */
4035
+ readonly project?: {
4036
+ readonly id: schema_d_exports$9.ProjectSchema.ID;
4037
+ readonly name: string;
4038
+ };
4039
+ /** Last activity, epoch milliseconds: every appended entry moves it. */
4040
+ readonly updatedAt: number;
4041
+ /** The model chosen for this session over settings; absent when settings decide. */
4042
+ readonly model?: {
4043
+ readonly provider: string;
4044
+ readonly id: string;
4045
+ };
4032
4046
  }
4033
4047
  interface Handle {
4034
4048
  readonly id: ID$1;
@@ -4054,6 +4068,15 @@ declare const create$1: (input?: CreateInput | undefined) => Effect.Effect<{
4054
4068
  hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
4055
4069
  hasHostLink: boolean;
4056
4070
  sandbox?: instance_d_exports.SandboxInstance.Info;
4071
+ project?: {
4072
+ id: string & import("effect/Brand").Brand<"Project.ID">;
4073
+ name: string;
4074
+ };
4075
+ updatedAt: number;
4076
+ model?: {
4077
+ readonly provider: string;
4078
+ readonly id: string;
4079
+ };
4057
4080
  }, SessionNotFoundError, never>;
4058
4081
  prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
4059
4082
  run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4082,6 +4105,15 @@ declare const link: (input: {
4082
4105
  hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
4083
4106
  hasHostLink: boolean;
4084
4107
  sandbox?: instance_d_exports.SandboxInstance.Info;
4108
+ project?: {
4109
+ id: string & import("effect/Brand").Brand<"Project.ID">;
4110
+ name: string;
4111
+ };
4112
+ updatedAt: number;
4113
+ model?: {
4114
+ readonly provider: string;
4115
+ readonly id: string;
4116
+ };
4085
4117
  }, SessionNotFoundError, never>;
4086
4118
  prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
4087
4119
  run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4108,6 +4140,15 @@ declare const relink: (input: RelinkInput) => Effect.Effect<{
4108
4140
  hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
4109
4141
  hasHostLink: boolean;
4110
4142
  sandbox?: instance_d_exports.SandboxInstance.Info;
4143
+ project?: {
4144
+ id: string & import("effect/Brand").Brand<"Project.ID">;
4145
+ name: string;
4146
+ };
4147
+ updatedAt: number;
4148
+ model?: {
4149
+ readonly provider: string;
4150
+ readonly id: string;
4151
+ };
4111
4152
  }, SessionNotFoundError, never>;
4112
4153
  prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
4113
4154
  run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
@@ -4807,14 +4848,19 @@ declare const LLMStarted: Schema.Struct<{
4807
4848
  type: "image";
4808
4849
  data: string;
4809
4850
  mimeType: string;
4851
+ } | {
4852
+ type: "thinking";
4853
+ thinking: string;
4854
+ thinkingSignature?: string;
4855
+ redacted?: boolean;
4810
4856
  } | {
4811
4857
  addedToolNames?: string[];
4812
4858
  arguments: Record<string, any>;
4813
4859
  callID: string;
4814
4860
  name: string;
4815
4861
  namespace?: string;
4816
- result: {
4817
- content: ({
4862
+ partial?: {
4863
+ content?: ({
4818
4864
  type: "text";
4819
4865
  text: string;
4820
4866
  textSignature?: string;
@@ -4824,9 +4870,8 @@ declare const LLMStarted: Schema.Struct<{
4824
4870
  mimeType: string;
4825
4871
  })[];
4826
4872
  details?: any;
4827
- isError: false;
4828
4873
  };
4829
- status: "completed";
4874
+ status: "running";
4830
4875
  thoughtSignature?: string;
4831
4876
  time: {
4832
4877
  start: number;
@@ -4850,9 +4895,9 @@ declare const LLMStarted: Schema.Struct<{
4850
4895
  mimeType: string;
4851
4896
  })[];
4852
4897
  details?: any;
4853
- isError: true;
4898
+ isError: false;
4854
4899
  };
4855
- status: "error";
4900
+ status: "completed";
4856
4901
  thoughtSignature?: string;
4857
4902
  time: {
4858
4903
  start: number;
@@ -4878,7 +4923,7 @@ declare const LLMStarted: Schema.Struct<{
4878
4923
  details?: any;
4879
4924
  isError: true;
4880
4925
  };
4881
- status: "skipped";
4926
+ status: "error";
4882
4927
  thoughtSignature?: string;
4883
4928
  time: {
4884
4929
  start: number;
@@ -4904,26 +4949,21 @@ declare const LLMStarted: Schema.Struct<{
4904
4949
  details?: any;
4905
4950
  isError: true;
4906
4951
  };
4907
- status: "aborted";
4952
+ status: "skipped";
4908
4953
  thoughtSignature?: string;
4909
4954
  time: {
4910
4955
  start: number;
4911
4956
  end: number;
4912
4957
  };
4913
4958
  type: "toolCall";
4914
- } | {
4915
- type: "thinking";
4916
- thinking: string;
4917
- thinkingSignature?: string;
4918
- redacted?: boolean;
4919
4959
  } | {
4920
4960
  addedToolNames?: string[];
4921
4961
  arguments: Record<string, any>;
4922
4962
  callID: string;
4923
4963
  name: string;
4924
4964
  namespace?: string;
4925
- partial?: {
4926
- content?: ({
4965
+ result: {
4966
+ content: ({
4927
4967
  type: "text";
4928
4968
  text: string;
4929
4969
  textSignature?: string;
@@ -4933,8 +4973,9 @@ declare const LLMStarted: Schema.Struct<{
4933
4973
  mimeType: string;
4934
4974
  })[];
4935
4975
  details?: any;
4976
+ isError: true;
4936
4977
  };
4937
- status: "running";
4978
+ status: "aborted";
4938
4979
  thoughtSignature?: string;
4939
4980
  time: {
4940
4981
  start: number;
@@ -5109,14 +5150,19 @@ declare const LLMStarted: Schema.Struct<{
5109
5150
  type: "image";
5110
5151
  data: string;
5111
5152
  mimeType: string;
5153
+ } | {
5154
+ type: "thinking";
5155
+ thinking: string;
5156
+ thinkingSignature?: string;
5157
+ redacted?: boolean;
5112
5158
  } | {
5113
5159
  addedToolNames?: string[];
5114
5160
  arguments: Record<string, any>;
5115
5161
  callID: string;
5116
5162
  name: string;
5117
5163
  namespace?: string;
5118
- result: {
5119
- content: ({
5164
+ partial?: {
5165
+ content?: ({
5120
5166
  type: "text";
5121
5167
  text: string;
5122
5168
  textSignature?: string;
@@ -5126,9 +5172,8 @@ declare const LLMStarted: Schema.Struct<{
5126
5172
  mimeType: string;
5127
5173
  })[];
5128
5174
  details?: any;
5129
- isError: false;
5130
5175
  };
5131
- status: "completed";
5176
+ status: "running";
5132
5177
  thoughtSignature?: string;
5133
5178
  time: {
5134
5179
  start: number;
@@ -5152,9 +5197,9 @@ declare const LLMStarted: Schema.Struct<{
5152
5197
  mimeType: string;
5153
5198
  })[];
5154
5199
  details?: any;
5155
- isError: true;
5200
+ isError: false;
5156
5201
  };
5157
- status: "error";
5202
+ status: "completed";
5158
5203
  thoughtSignature?: string;
5159
5204
  time: {
5160
5205
  start: number;
@@ -5180,7 +5225,7 @@ declare const LLMStarted: Schema.Struct<{
5180
5225
  details?: any;
5181
5226
  isError: true;
5182
5227
  };
5183
- status: "skipped";
5228
+ status: "error";
5184
5229
  thoughtSignature?: string;
5185
5230
  time: {
5186
5231
  start: number;
@@ -5206,26 +5251,21 @@ declare const LLMStarted: Schema.Struct<{
5206
5251
  details?: any;
5207
5252
  isError: true;
5208
5253
  };
5209
- status: "aborted";
5254
+ status: "skipped";
5210
5255
  thoughtSignature?: string;
5211
5256
  time: {
5212
5257
  start: number;
5213
5258
  end: number;
5214
5259
  };
5215
5260
  type: "toolCall";
5216
- } | {
5217
- type: "thinking";
5218
- thinking: string;
5219
- thinkingSignature?: string;
5220
- redacted?: boolean;
5221
5261
  } | {
5222
5262
  addedToolNames?: string[];
5223
5263
  arguments: Record<string, any>;
5224
5264
  callID: string;
5225
5265
  name: string;
5226
5266
  namespace?: string;
5227
- partial?: {
5228
- content?: ({
5267
+ result: {
5268
+ content: ({
5229
5269
  type: "text";
5230
5270
  text: string;
5231
5271
  textSignature?: string;
@@ -5235,8 +5275,9 @@ declare const LLMStarted: Schema.Struct<{
5235
5275
  mimeType: string;
5236
5276
  })[];
5237
5277
  details?: any;
5278
+ isError: true;
5238
5279
  };
5239
- status: "running";
5280
+ status: "aborted";
5240
5281
  thoughtSignature?: string;
5241
5282
  time: {
5242
5283
  start: number;
@@ -5429,14 +5470,19 @@ declare const LLMStarted: Schema.Struct<{
5429
5470
  type: "image";
5430
5471
  data: string;
5431
5472
  mimeType: string;
5473
+ } | {
5474
+ type: "thinking";
5475
+ thinking: string;
5476
+ thinkingSignature?: string;
5477
+ redacted?: boolean;
5432
5478
  } | {
5433
5479
  addedToolNames?: string[];
5434
5480
  arguments: Record<string, any>;
5435
5481
  callID: string;
5436
5482
  name: string;
5437
5483
  namespace?: string;
5438
- result: {
5439
- content: ({
5484
+ partial?: {
5485
+ content?: ({
5440
5486
  type: "text";
5441
5487
  text: string;
5442
5488
  textSignature?: string;
@@ -5446,9 +5492,8 @@ declare const LLMStarted: Schema.Struct<{
5446
5492
  mimeType: string;
5447
5493
  })[];
5448
5494
  details?: any;
5449
- isError: false;
5450
5495
  };
5451
- status: "completed";
5496
+ status: "running";
5452
5497
  thoughtSignature?: string;
5453
5498
  time: {
5454
5499
  start: number;
@@ -5472,9 +5517,9 @@ declare const LLMStarted: Schema.Struct<{
5472
5517
  mimeType: string;
5473
5518
  })[];
5474
5519
  details?: any;
5475
- isError: true;
5520
+ isError: false;
5476
5521
  };
5477
- status: "error";
5522
+ status: "completed";
5478
5523
  thoughtSignature?: string;
5479
5524
  time: {
5480
5525
  start: number;
@@ -5500,7 +5545,7 @@ declare const LLMStarted: Schema.Struct<{
5500
5545
  details?: any;
5501
5546
  isError: true;
5502
5547
  };
5503
- status: "skipped";
5548
+ status: "error";
5504
5549
  thoughtSignature?: string;
5505
5550
  time: {
5506
5551
  start: number;
@@ -5526,26 +5571,21 @@ declare const LLMStarted: Schema.Struct<{
5526
5571
  details?: any;
5527
5572
  isError: true;
5528
5573
  };
5529
- status: "aborted";
5574
+ status: "skipped";
5530
5575
  thoughtSignature?: string;
5531
5576
  time: {
5532
5577
  start: number;
5533
5578
  end: number;
5534
5579
  };
5535
5580
  type: "toolCall";
5536
- } | {
5537
- type: "thinking";
5538
- thinking: string;
5539
- thinkingSignature?: string;
5540
- redacted?: boolean;
5541
5581
  } | {
5542
5582
  addedToolNames?: string[];
5543
5583
  arguments: Record<string, any>;
5544
5584
  callID: string;
5545
5585
  name: string;
5546
5586
  namespace?: string;
5547
- partial?: {
5548
- content?: ({
5587
+ result: {
5588
+ content: ({
5549
5589
  type: "text";
5550
5590
  text: string;
5551
5591
  textSignature?: string;
@@ -5555,8 +5595,9 @@ declare const LLMStarted: Schema.Struct<{
5555
5595
  mimeType: string;
5556
5596
  })[];
5557
5597
  details?: any;
5598
+ isError: true;
5558
5599
  };
5559
- status: "running";
5600
+ status: "aborted";
5560
5601
  thoughtSignature?: string;
5561
5602
  time: {
5562
5603
  start: number;
@@ -5731,14 +5772,19 @@ declare const LLMStarted: Schema.Struct<{
5731
5772
  type: "image";
5732
5773
  data: string;
5733
5774
  mimeType: string;
5775
+ } | {
5776
+ type: "thinking";
5777
+ thinking: string;
5778
+ thinkingSignature?: string;
5779
+ redacted?: boolean;
5734
5780
  } | {
5735
5781
  addedToolNames?: string[];
5736
5782
  arguments: Record<string, any>;
5737
5783
  callID: string;
5738
5784
  name: string;
5739
5785
  namespace?: string;
5740
- result: {
5741
- content: ({
5786
+ partial?: {
5787
+ content?: ({
5742
5788
  type: "text";
5743
5789
  text: string;
5744
5790
  textSignature?: string;
@@ -5748,9 +5794,8 @@ declare const LLMStarted: Schema.Struct<{
5748
5794
  mimeType: string;
5749
5795
  })[];
5750
5796
  details?: any;
5751
- isError: false;
5752
5797
  };
5753
- status: "completed";
5798
+ status: "running";
5754
5799
  thoughtSignature?: string;
5755
5800
  time: {
5756
5801
  start: number;
@@ -5774,9 +5819,9 @@ declare const LLMStarted: Schema.Struct<{
5774
5819
  mimeType: string;
5775
5820
  })[];
5776
5821
  details?: any;
5777
- isError: true;
5822
+ isError: false;
5778
5823
  };
5779
- status: "error";
5824
+ status: "completed";
5780
5825
  thoughtSignature?: string;
5781
5826
  time: {
5782
5827
  start: number;
@@ -5802,7 +5847,7 @@ declare const LLMStarted: Schema.Struct<{
5802
5847
  details?: any;
5803
5848
  isError: true;
5804
5849
  };
5805
- status: "skipped";
5850
+ status: "error";
5806
5851
  thoughtSignature?: string;
5807
5852
  time: {
5808
5853
  start: number;
@@ -5828,26 +5873,21 @@ declare const LLMStarted: Schema.Struct<{
5828
5873
  details?: any;
5829
5874
  isError: true;
5830
5875
  };
5831
- status: "aborted";
5876
+ status: "skipped";
5832
5877
  thoughtSignature?: string;
5833
5878
  time: {
5834
5879
  start: number;
5835
5880
  end: number;
5836
5881
  };
5837
5882
  type: "toolCall";
5838
- } | {
5839
- type: "thinking";
5840
- thinking: string;
5841
- thinkingSignature?: string;
5842
- redacted?: boolean;
5843
5883
  } | {
5844
5884
  addedToolNames?: string[];
5845
5885
  arguments: Record<string, any>;
5846
5886
  callID: string;
5847
5887
  name: string;
5848
5888
  namespace?: string;
5849
- partial?: {
5850
- content?: ({
5889
+ result: {
5890
+ content: ({
5851
5891
  type: "text";
5852
5892
  text: string;
5853
5893
  textSignature?: string;
@@ -5857,8 +5897,9 @@ declare const LLMStarted: Schema.Struct<{
5857
5897
  mimeType: string;
5858
5898
  })[];
5859
5899
  details?: any;
5900
+ isError: true;
5860
5901
  };
5861
- status: "running";
5902
+ status: "aborted";
5862
5903
  thoughtSignature?: string;
5863
5904
  time: {
5864
5905
  start: number;
@@ -6354,14 +6395,19 @@ declare const LLMEnded: Schema.Struct<{
6354
6395
  type: "image";
6355
6396
  data: string;
6356
6397
  mimeType: string;
6398
+ } | {
6399
+ type: "thinking";
6400
+ thinking: string;
6401
+ thinkingSignature?: string;
6402
+ redacted?: boolean;
6357
6403
  } | {
6358
6404
  addedToolNames?: string[];
6359
6405
  arguments: Record<string, any>;
6360
6406
  callID: string;
6361
6407
  name: string;
6362
6408
  namespace?: string;
6363
- result: {
6364
- content: ({
6409
+ partial?: {
6410
+ content?: ({
6365
6411
  type: "text";
6366
6412
  text: string;
6367
6413
  textSignature?: string;
@@ -6371,9 +6417,8 @@ declare const LLMEnded: Schema.Struct<{
6371
6417
  mimeType: string;
6372
6418
  })[];
6373
6419
  details?: any;
6374
- isError: false;
6375
6420
  };
6376
- status: "completed";
6421
+ status: "running";
6377
6422
  thoughtSignature?: string;
6378
6423
  time: {
6379
6424
  start: number;
@@ -6397,9 +6442,9 @@ declare const LLMEnded: Schema.Struct<{
6397
6442
  mimeType: string;
6398
6443
  })[];
6399
6444
  details?: any;
6400
- isError: true;
6445
+ isError: false;
6401
6446
  };
6402
- status: "error";
6447
+ status: "completed";
6403
6448
  thoughtSignature?: string;
6404
6449
  time: {
6405
6450
  start: number;
@@ -6425,7 +6470,7 @@ declare const LLMEnded: Schema.Struct<{
6425
6470
  details?: any;
6426
6471
  isError: true;
6427
6472
  };
6428
- status: "skipped";
6473
+ status: "error";
6429
6474
  thoughtSignature?: string;
6430
6475
  time: {
6431
6476
  start: number;
@@ -6451,26 +6496,21 @@ declare const LLMEnded: Schema.Struct<{
6451
6496
  details?: any;
6452
6497
  isError: true;
6453
6498
  };
6454
- status: "aborted";
6499
+ status: "skipped";
6455
6500
  thoughtSignature?: string;
6456
6501
  time: {
6457
6502
  start: number;
6458
6503
  end: number;
6459
6504
  };
6460
6505
  type: "toolCall";
6461
- } | {
6462
- type: "thinking";
6463
- thinking: string;
6464
- thinkingSignature?: string;
6465
- redacted?: boolean;
6466
6506
  } | {
6467
6507
  addedToolNames?: string[];
6468
6508
  arguments: Record<string, any>;
6469
6509
  callID: string;
6470
6510
  name: string;
6471
6511
  namespace?: string;
6472
- partial?: {
6473
- content?: ({
6512
+ result: {
6513
+ content: ({
6474
6514
  type: "text";
6475
6515
  text: string;
6476
6516
  textSignature?: string;
@@ -6480,8 +6520,9 @@ declare const LLMEnded: Schema.Struct<{
6480
6520
  mimeType: string;
6481
6521
  })[];
6482
6522
  details?: any;
6523
+ isError: true;
6483
6524
  };
6484
- status: "running";
6525
+ status: "aborted";
6485
6526
  thoughtSignature?: string;
6486
6527
  time: {
6487
6528
  start: number;
@@ -6656,14 +6697,19 @@ declare const LLMEnded: Schema.Struct<{
6656
6697
  type: "image";
6657
6698
  data: string;
6658
6699
  mimeType: string;
6700
+ } | {
6701
+ type: "thinking";
6702
+ thinking: string;
6703
+ thinkingSignature?: string;
6704
+ redacted?: boolean;
6659
6705
  } | {
6660
6706
  addedToolNames?: string[];
6661
6707
  arguments: Record<string, any>;
6662
6708
  callID: string;
6663
6709
  name: string;
6664
6710
  namespace?: string;
6665
- result: {
6666
- content: ({
6711
+ partial?: {
6712
+ content?: ({
6667
6713
  type: "text";
6668
6714
  text: string;
6669
6715
  textSignature?: string;
@@ -6673,9 +6719,8 @@ declare const LLMEnded: Schema.Struct<{
6673
6719
  mimeType: string;
6674
6720
  })[];
6675
6721
  details?: any;
6676
- isError: false;
6677
6722
  };
6678
- status: "completed";
6723
+ status: "running";
6679
6724
  thoughtSignature?: string;
6680
6725
  time: {
6681
6726
  start: number;
@@ -6699,9 +6744,9 @@ declare const LLMEnded: Schema.Struct<{
6699
6744
  mimeType: string;
6700
6745
  })[];
6701
6746
  details?: any;
6702
- isError: true;
6747
+ isError: false;
6703
6748
  };
6704
- status: "error";
6749
+ status: "completed";
6705
6750
  thoughtSignature?: string;
6706
6751
  time: {
6707
6752
  start: number;
@@ -6727,7 +6772,7 @@ declare const LLMEnded: Schema.Struct<{
6727
6772
  details?: any;
6728
6773
  isError: true;
6729
6774
  };
6730
- status: "skipped";
6775
+ status: "error";
6731
6776
  thoughtSignature?: string;
6732
6777
  time: {
6733
6778
  start: number;
@@ -6753,26 +6798,21 @@ declare const LLMEnded: Schema.Struct<{
6753
6798
  details?: any;
6754
6799
  isError: true;
6755
6800
  };
6756
- status: "aborted";
6801
+ status: "skipped";
6757
6802
  thoughtSignature?: string;
6758
6803
  time: {
6759
6804
  start: number;
6760
6805
  end: number;
6761
6806
  };
6762
6807
  type: "toolCall";
6763
- } | {
6764
- type: "thinking";
6765
- thinking: string;
6766
- thinkingSignature?: string;
6767
- redacted?: boolean;
6768
6808
  } | {
6769
6809
  addedToolNames?: string[];
6770
6810
  arguments: Record<string, any>;
6771
6811
  callID: string;
6772
6812
  name: string;
6773
6813
  namespace?: string;
6774
- partial?: {
6775
- content?: ({
6814
+ result: {
6815
+ content: ({
6776
6816
  type: "text";
6777
6817
  text: string;
6778
6818
  textSignature?: string;
@@ -6782,8 +6822,9 @@ declare const LLMEnded: Schema.Struct<{
6782
6822
  mimeType: string;
6783
6823
  })[];
6784
6824
  details?: any;
6825
+ isError: true;
6785
6826
  };
6786
- status: "running";
6827
+ status: "aborted";
6787
6828
  thoughtSignature?: string;
6788
6829
  time: {
6789
6830
  start: number;
@@ -6977,14 +7018,19 @@ declare const LLMEnded: Schema.Struct<{
6977
7018
  type: "image";
6978
7019
  data: string;
6979
7020
  mimeType: string;
7021
+ } | {
7022
+ type: "thinking";
7023
+ thinking: string;
7024
+ thinkingSignature?: string;
7025
+ redacted?: boolean;
6980
7026
  } | {
6981
7027
  addedToolNames?: string[];
6982
7028
  arguments: Record<string, any>;
6983
7029
  callID: string;
6984
7030
  name: string;
6985
7031
  namespace?: string;
6986
- result: {
6987
- content: ({
7032
+ partial?: {
7033
+ content?: ({
6988
7034
  type: "text";
6989
7035
  text: string;
6990
7036
  textSignature?: string;
@@ -6994,9 +7040,8 @@ declare const LLMEnded: Schema.Struct<{
6994
7040
  mimeType: string;
6995
7041
  })[];
6996
7042
  details?: any;
6997
- isError: false;
6998
7043
  };
6999
- status: "completed";
7044
+ status: "running";
7000
7045
  thoughtSignature?: string;
7001
7046
  time: {
7002
7047
  start: number;
@@ -7020,9 +7065,9 @@ declare const LLMEnded: Schema.Struct<{
7020
7065
  mimeType: string;
7021
7066
  })[];
7022
7067
  details?: any;
7023
- isError: true;
7068
+ isError: false;
7024
7069
  };
7025
- status: "error";
7070
+ status: "completed";
7026
7071
  thoughtSignature?: string;
7027
7072
  time: {
7028
7073
  start: number;
@@ -7048,7 +7093,7 @@ declare const LLMEnded: Schema.Struct<{
7048
7093
  details?: any;
7049
7094
  isError: true;
7050
7095
  };
7051
- status: "skipped";
7096
+ status: "error";
7052
7097
  thoughtSignature?: string;
7053
7098
  time: {
7054
7099
  start: number;
@@ -7074,26 +7119,21 @@ declare const LLMEnded: Schema.Struct<{
7074
7119
  details?: any;
7075
7120
  isError: true;
7076
7121
  };
7077
- status: "aborted";
7122
+ status: "skipped";
7078
7123
  thoughtSignature?: string;
7079
7124
  time: {
7080
7125
  start: number;
7081
7126
  end: number;
7082
7127
  };
7083
7128
  type: "toolCall";
7084
- } | {
7085
- type: "thinking";
7086
- thinking: string;
7087
- thinkingSignature?: string;
7088
- redacted?: boolean;
7089
7129
  } | {
7090
7130
  addedToolNames?: string[];
7091
7131
  arguments: Record<string, any>;
7092
7132
  callID: string;
7093
7133
  name: string;
7094
7134
  namespace?: string;
7095
- partial?: {
7096
- content?: ({
7135
+ result: {
7136
+ content: ({
7097
7137
  type: "text";
7098
7138
  text: string;
7099
7139
  textSignature?: string;
@@ -7103,8 +7143,9 @@ declare const LLMEnded: Schema.Struct<{
7103
7143
  mimeType: string;
7104
7144
  })[];
7105
7145
  details?: any;
7146
+ isError: true;
7106
7147
  };
7107
- status: "running";
7148
+ status: "aborted";
7108
7149
  thoughtSignature?: string;
7109
7150
  time: {
7110
7151
  start: number;
@@ -7279,14 +7320,19 @@ declare const LLMEnded: Schema.Struct<{
7279
7320
  type: "image";
7280
7321
  data: string;
7281
7322
  mimeType: string;
7323
+ } | {
7324
+ type: "thinking";
7325
+ thinking: string;
7326
+ thinkingSignature?: string;
7327
+ redacted?: boolean;
7282
7328
  } | {
7283
7329
  addedToolNames?: string[];
7284
7330
  arguments: Record<string, any>;
7285
7331
  callID: string;
7286
7332
  name: string;
7287
7333
  namespace?: string;
7288
- result: {
7289
- content: ({
7334
+ partial?: {
7335
+ content?: ({
7290
7336
  type: "text";
7291
7337
  text: string;
7292
7338
  textSignature?: string;
@@ -7296,9 +7342,8 @@ declare const LLMEnded: Schema.Struct<{
7296
7342
  mimeType: string;
7297
7343
  })[];
7298
7344
  details?: any;
7299
- isError: false;
7300
7345
  };
7301
- status: "completed";
7346
+ status: "running";
7302
7347
  thoughtSignature?: string;
7303
7348
  time: {
7304
7349
  start: number;
@@ -7322,9 +7367,9 @@ declare const LLMEnded: Schema.Struct<{
7322
7367
  mimeType: string;
7323
7368
  })[];
7324
7369
  details?: any;
7325
- isError: true;
7370
+ isError: false;
7326
7371
  };
7327
- status: "error";
7372
+ status: "completed";
7328
7373
  thoughtSignature?: string;
7329
7374
  time: {
7330
7375
  start: number;
@@ -7350,7 +7395,7 @@ declare const LLMEnded: Schema.Struct<{
7350
7395
  details?: any;
7351
7396
  isError: true;
7352
7397
  };
7353
- status: "skipped";
7398
+ status: "error";
7354
7399
  thoughtSignature?: string;
7355
7400
  time: {
7356
7401
  start: number;
@@ -7376,26 +7421,21 @@ declare const LLMEnded: Schema.Struct<{
7376
7421
  details?: any;
7377
7422
  isError: true;
7378
7423
  };
7379
- status: "aborted";
7424
+ status: "skipped";
7380
7425
  thoughtSignature?: string;
7381
7426
  time: {
7382
7427
  start: number;
7383
7428
  end: number;
7384
7429
  };
7385
7430
  type: "toolCall";
7386
- } | {
7387
- type: "thinking";
7388
- thinking: string;
7389
- thinkingSignature?: string;
7390
- redacted?: boolean;
7391
7431
  } | {
7392
7432
  addedToolNames?: string[];
7393
7433
  arguments: Record<string, any>;
7394
7434
  callID: string;
7395
7435
  name: string;
7396
7436
  namespace?: string;
7397
- partial?: {
7398
- content?: ({
7437
+ result: {
7438
+ content: ({
7399
7439
  type: "text";
7400
7440
  text: string;
7401
7441
  textSignature?: string;
@@ -7405,8 +7445,9 @@ declare const LLMEnded: Schema.Struct<{
7405
7445
  mimeType: string;
7406
7446
  })[];
7407
7447
  details?: any;
7448
+ isError: true;
7408
7449
  };
7409
- status: "running";
7450
+ status: "aborted";
7410
7451
  thoughtSignature?: string;
7411
7452
  time: {
7412
7453
  start: number;
@@ -7612,14 +7653,19 @@ declare const LLMFailed: Schema.Struct<{
7612
7653
  type: "image";
7613
7654
  data: string;
7614
7655
  mimeType: string;
7656
+ } | {
7657
+ type: "thinking";
7658
+ thinking: string;
7659
+ thinkingSignature?: string;
7660
+ redacted?: boolean;
7615
7661
  } | {
7616
7662
  addedToolNames?: string[];
7617
7663
  arguments: Record<string, any>;
7618
7664
  callID: string;
7619
7665
  name: string;
7620
7666
  namespace?: string;
7621
- result: {
7622
- content: ({
7667
+ partial?: {
7668
+ content?: ({
7623
7669
  type: "text";
7624
7670
  text: string;
7625
7671
  textSignature?: string;
@@ -7629,9 +7675,8 @@ declare const LLMFailed: Schema.Struct<{
7629
7675
  mimeType: string;
7630
7676
  })[];
7631
7677
  details?: any;
7632
- isError: false;
7633
7678
  };
7634
- status: "completed";
7679
+ status: "running";
7635
7680
  thoughtSignature?: string;
7636
7681
  time: {
7637
7682
  start: number;
@@ -7655,9 +7700,9 @@ declare const LLMFailed: Schema.Struct<{
7655
7700
  mimeType: string;
7656
7701
  })[];
7657
7702
  details?: any;
7658
- isError: true;
7703
+ isError: false;
7659
7704
  };
7660
- status: "error";
7705
+ status: "completed";
7661
7706
  thoughtSignature?: string;
7662
7707
  time: {
7663
7708
  start: number;
@@ -7683,7 +7728,7 @@ declare const LLMFailed: Schema.Struct<{
7683
7728
  details?: any;
7684
7729
  isError: true;
7685
7730
  };
7686
- status: "skipped";
7731
+ status: "error";
7687
7732
  thoughtSignature?: string;
7688
7733
  time: {
7689
7734
  start: number;
@@ -7709,26 +7754,21 @@ declare const LLMFailed: Schema.Struct<{
7709
7754
  details?: any;
7710
7755
  isError: true;
7711
7756
  };
7712
- status: "aborted";
7757
+ status: "skipped";
7713
7758
  thoughtSignature?: string;
7714
7759
  time: {
7715
7760
  start: number;
7716
7761
  end: number;
7717
7762
  };
7718
7763
  type: "toolCall";
7719
- } | {
7720
- type: "thinking";
7721
- thinking: string;
7722
- thinkingSignature?: string;
7723
- redacted?: boolean;
7724
7764
  } | {
7725
7765
  addedToolNames?: string[];
7726
7766
  arguments: Record<string, any>;
7727
7767
  callID: string;
7728
7768
  name: string;
7729
7769
  namespace?: string;
7730
- partial?: {
7731
- content?: ({
7770
+ result: {
7771
+ content: ({
7732
7772
  type: "text";
7733
7773
  text: string;
7734
7774
  textSignature?: string;
@@ -7738,8 +7778,9 @@ declare const LLMFailed: Schema.Struct<{
7738
7778
  mimeType: string;
7739
7779
  })[];
7740
7780
  details?: any;
7781
+ isError: true;
7741
7782
  };
7742
- status: "running";
7783
+ status: "aborted";
7743
7784
  thoughtSignature?: string;
7744
7785
  time: {
7745
7786
  start: number;
@@ -7914,14 +7955,19 @@ declare const LLMFailed: Schema.Struct<{
7914
7955
  type: "image";
7915
7956
  data: string;
7916
7957
  mimeType: string;
7958
+ } | {
7959
+ type: "thinking";
7960
+ thinking: string;
7961
+ thinkingSignature?: string;
7962
+ redacted?: boolean;
7917
7963
  } | {
7918
7964
  addedToolNames?: string[];
7919
7965
  arguments: Record<string, any>;
7920
7966
  callID: string;
7921
7967
  name: string;
7922
7968
  namespace?: string;
7923
- result: {
7924
- content: ({
7969
+ partial?: {
7970
+ content?: ({
7925
7971
  type: "text";
7926
7972
  text: string;
7927
7973
  textSignature?: string;
@@ -7931,9 +7977,8 @@ declare const LLMFailed: Schema.Struct<{
7931
7977
  mimeType: string;
7932
7978
  })[];
7933
7979
  details?: any;
7934
- isError: false;
7935
7980
  };
7936
- status: "completed";
7981
+ status: "running";
7937
7982
  thoughtSignature?: string;
7938
7983
  time: {
7939
7984
  start: number;
@@ -7957,9 +8002,9 @@ declare const LLMFailed: Schema.Struct<{
7957
8002
  mimeType: string;
7958
8003
  })[];
7959
8004
  details?: any;
7960
- isError: true;
8005
+ isError: false;
7961
8006
  };
7962
- status: "error";
8007
+ status: "completed";
7963
8008
  thoughtSignature?: string;
7964
8009
  time: {
7965
8010
  start: number;
@@ -7985,7 +8030,7 @@ declare const LLMFailed: Schema.Struct<{
7985
8030
  details?: any;
7986
8031
  isError: true;
7987
8032
  };
7988
- status: "skipped";
8033
+ status: "error";
7989
8034
  thoughtSignature?: string;
7990
8035
  time: {
7991
8036
  start: number;
@@ -8011,26 +8056,21 @@ declare const LLMFailed: Schema.Struct<{
8011
8056
  details?: any;
8012
8057
  isError: true;
8013
8058
  };
8014
- status: "aborted";
8059
+ status: "skipped";
8015
8060
  thoughtSignature?: string;
8016
8061
  time: {
8017
8062
  start: number;
8018
8063
  end: number;
8019
8064
  };
8020
8065
  type: "toolCall";
8021
- } | {
8022
- type: "thinking";
8023
- thinking: string;
8024
- thinkingSignature?: string;
8025
- redacted?: boolean;
8026
8066
  } | {
8027
8067
  addedToolNames?: string[];
8028
8068
  arguments: Record<string, any>;
8029
8069
  callID: string;
8030
8070
  name: string;
8031
8071
  namespace?: string;
8032
- partial?: {
8033
- content?: ({
8072
+ result: {
8073
+ content: ({
8034
8074
  type: "text";
8035
8075
  text: string;
8036
8076
  textSignature?: string;
@@ -8040,8 +8080,9 @@ declare const LLMFailed: Schema.Struct<{
8040
8080
  mimeType: string;
8041
8081
  })[];
8042
8082
  details?: any;
8083
+ isError: true;
8043
8084
  };
8044
- status: "running";
8085
+ status: "aborted";
8045
8086
  thoughtSignature?: string;
8046
8087
  time: {
8047
8088
  start: number;
@@ -8235,14 +8276,19 @@ declare const LLMFailed: Schema.Struct<{
8235
8276
  type: "image";
8236
8277
  data: string;
8237
8278
  mimeType: string;
8279
+ } | {
8280
+ type: "thinking";
8281
+ thinking: string;
8282
+ thinkingSignature?: string;
8283
+ redacted?: boolean;
8238
8284
  } | {
8239
8285
  addedToolNames?: string[];
8240
8286
  arguments: Record<string, any>;
8241
8287
  callID: string;
8242
8288
  name: string;
8243
8289
  namespace?: string;
8244
- result: {
8245
- content: ({
8290
+ partial?: {
8291
+ content?: ({
8246
8292
  type: "text";
8247
8293
  text: string;
8248
8294
  textSignature?: string;
@@ -8252,9 +8298,8 @@ declare const LLMFailed: Schema.Struct<{
8252
8298
  mimeType: string;
8253
8299
  })[];
8254
8300
  details?: any;
8255
- isError: false;
8256
8301
  };
8257
- status: "completed";
8302
+ status: "running";
8258
8303
  thoughtSignature?: string;
8259
8304
  time: {
8260
8305
  start: number;
@@ -8278,9 +8323,9 @@ declare const LLMFailed: Schema.Struct<{
8278
8323
  mimeType: string;
8279
8324
  })[];
8280
8325
  details?: any;
8281
- isError: true;
8326
+ isError: false;
8282
8327
  };
8283
- status: "error";
8328
+ status: "completed";
8284
8329
  thoughtSignature?: string;
8285
8330
  time: {
8286
8331
  start: number;
@@ -8306,7 +8351,7 @@ declare const LLMFailed: Schema.Struct<{
8306
8351
  details?: any;
8307
8352
  isError: true;
8308
8353
  };
8309
- status: "skipped";
8354
+ status: "error";
8310
8355
  thoughtSignature?: string;
8311
8356
  time: {
8312
8357
  start: number;
@@ -8332,26 +8377,21 @@ declare const LLMFailed: Schema.Struct<{
8332
8377
  details?: any;
8333
8378
  isError: true;
8334
8379
  };
8335
- status: "aborted";
8380
+ status: "skipped";
8336
8381
  thoughtSignature?: string;
8337
8382
  time: {
8338
8383
  start: number;
8339
8384
  end: number;
8340
8385
  };
8341
8386
  type: "toolCall";
8342
- } | {
8343
- type: "thinking";
8344
- thinking: string;
8345
- thinkingSignature?: string;
8346
- redacted?: boolean;
8347
8387
  } | {
8348
8388
  addedToolNames?: string[];
8349
8389
  arguments: Record<string, any>;
8350
8390
  callID: string;
8351
8391
  name: string;
8352
8392
  namespace?: string;
8353
- partial?: {
8354
- content?: ({
8393
+ result: {
8394
+ content: ({
8355
8395
  type: "text";
8356
8396
  text: string;
8357
8397
  textSignature?: string;
@@ -8361,8 +8401,9 @@ declare const LLMFailed: Schema.Struct<{
8361
8401
  mimeType: string;
8362
8402
  })[];
8363
8403
  details?: any;
8404
+ isError: true;
8364
8405
  };
8365
- status: "running";
8406
+ status: "aborted";
8366
8407
  thoughtSignature?: string;
8367
8408
  time: {
8368
8409
  start: number;
@@ -8537,14 +8578,19 @@ declare const LLMFailed: Schema.Struct<{
8537
8578
  type: "image";
8538
8579
  data: string;
8539
8580
  mimeType: string;
8581
+ } | {
8582
+ type: "thinking";
8583
+ thinking: string;
8584
+ thinkingSignature?: string;
8585
+ redacted?: boolean;
8540
8586
  } | {
8541
8587
  addedToolNames?: string[];
8542
8588
  arguments: Record<string, any>;
8543
8589
  callID: string;
8544
8590
  name: string;
8545
8591
  namespace?: string;
8546
- result: {
8547
- content: ({
8592
+ partial?: {
8593
+ content?: ({
8548
8594
  type: "text";
8549
8595
  text: string;
8550
8596
  textSignature?: string;
@@ -8554,9 +8600,8 @@ declare const LLMFailed: Schema.Struct<{
8554
8600
  mimeType: string;
8555
8601
  })[];
8556
8602
  details?: any;
8557
- isError: false;
8558
8603
  };
8559
- status: "completed";
8604
+ status: "running";
8560
8605
  thoughtSignature?: string;
8561
8606
  time: {
8562
8607
  start: number;
@@ -8580,9 +8625,9 @@ declare const LLMFailed: Schema.Struct<{
8580
8625
  mimeType: string;
8581
8626
  })[];
8582
8627
  details?: any;
8583
- isError: true;
8628
+ isError: false;
8584
8629
  };
8585
- status: "error";
8630
+ status: "completed";
8586
8631
  thoughtSignature?: string;
8587
8632
  time: {
8588
8633
  start: number;
@@ -8608,7 +8653,7 @@ declare const LLMFailed: Schema.Struct<{
8608
8653
  details?: any;
8609
8654
  isError: true;
8610
8655
  };
8611
- status: "skipped";
8656
+ status: "error";
8612
8657
  thoughtSignature?: string;
8613
8658
  time: {
8614
8659
  start: number;
@@ -8634,26 +8679,21 @@ declare const LLMFailed: Schema.Struct<{
8634
8679
  details?: any;
8635
8680
  isError: true;
8636
8681
  };
8637
- status: "aborted";
8682
+ status: "skipped";
8638
8683
  thoughtSignature?: string;
8639
8684
  time: {
8640
8685
  start: number;
8641
8686
  end: number;
8642
8687
  };
8643
8688
  type: "toolCall";
8644
- } | {
8645
- type: "thinking";
8646
- thinking: string;
8647
- thinkingSignature?: string;
8648
- redacted?: boolean;
8649
8689
  } | {
8650
8690
  addedToolNames?: string[];
8651
8691
  arguments: Record<string, any>;
8652
8692
  callID: string;
8653
8693
  name: string;
8654
8694
  namespace?: string;
8655
- partial?: {
8656
- content?: ({
8695
+ result: {
8696
+ content: ({
8657
8697
  type: "text";
8658
8698
  text: string;
8659
8699
  textSignature?: string;
@@ -8663,8 +8703,9 @@ declare const LLMFailed: Schema.Struct<{
8663
8703
  mimeType: string;
8664
8704
  })[];
8665
8705
  details?: any;
8706
+ isError: true;
8666
8707
  };
8667
- status: "running";
8708
+ status: "aborted";
8668
8709
  thoughtSignature?: string;
8669
8710
  time: {
8670
8711
  start: number;
@@ -10412,14 +10453,19 @@ declare const Definitions: readonly [Schema.Struct<{
10412
10453
  type: "image";
10413
10454
  data: string;
10414
10455
  mimeType: string;
10456
+ } | {
10457
+ type: "thinking";
10458
+ thinking: string;
10459
+ thinkingSignature?: string;
10460
+ redacted?: boolean;
10415
10461
  } | {
10416
10462
  addedToolNames?: string[];
10417
10463
  arguments: Record<string, any>;
10418
10464
  callID: string;
10419
10465
  name: string;
10420
10466
  namespace?: string;
10421
- result: {
10422
- content: ({
10467
+ partial?: {
10468
+ content?: ({
10423
10469
  type: "text";
10424
10470
  text: string;
10425
10471
  textSignature?: string;
@@ -10429,9 +10475,8 @@ declare const Definitions: readonly [Schema.Struct<{
10429
10475
  mimeType: string;
10430
10476
  })[];
10431
10477
  details?: any;
10432
- isError: false;
10433
10478
  };
10434
- status: "completed";
10479
+ status: "running";
10435
10480
  thoughtSignature?: string;
10436
10481
  time: {
10437
10482
  start: number;
@@ -10455,9 +10500,9 @@ declare const Definitions: readonly [Schema.Struct<{
10455
10500
  mimeType: string;
10456
10501
  })[];
10457
10502
  details?: any;
10458
- isError: true;
10503
+ isError: false;
10459
10504
  };
10460
- status: "error";
10505
+ status: "completed";
10461
10506
  thoughtSignature?: string;
10462
10507
  time: {
10463
10508
  start: number;
@@ -10483,7 +10528,7 @@ declare const Definitions: readonly [Schema.Struct<{
10483
10528
  details?: any;
10484
10529
  isError: true;
10485
10530
  };
10486
- status: "skipped";
10531
+ status: "error";
10487
10532
  thoughtSignature?: string;
10488
10533
  time: {
10489
10534
  start: number;
@@ -10509,26 +10554,21 @@ declare const Definitions: readonly [Schema.Struct<{
10509
10554
  details?: any;
10510
10555
  isError: true;
10511
10556
  };
10512
- status: "aborted";
10557
+ status: "skipped";
10513
10558
  thoughtSignature?: string;
10514
10559
  time: {
10515
10560
  start: number;
10516
10561
  end: number;
10517
10562
  };
10518
10563
  type: "toolCall";
10519
- } | {
10520
- type: "thinking";
10521
- thinking: string;
10522
- thinkingSignature?: string;
10523
- redacted?: boolean;
10524
10564
  } | {
10525
10565
  addedToolNames?: string[];
10526
10566
  arguments: Record<string, any>;
10527
10567
  callID: string;
10528
10568
  name: string;
10529
10569
  namespace?: string;
10530
- partial?: {
10531
- content?: ({
10570
+ result: {
10571
+ content: ({
10532
10572
  type: "text";
10533
10573
  text: string;
10534
10574
  textSignature?: string;
@@ -10538,8 +10578,9 @@ declare const Definitions: readonly [Schema.Struct<{
10538
10578
  mimeType: string;
10539
10579
  })[];
10540
10580
  details?: any;
10581
+ isError: true;
10541
10582
  };
10542
- status: "running";
10583
+ status: "aborted";
10543
10584
  thoughtSignature?: string;
10544
10585
  time: {
10545
10586
  start: number;
@@ -10714,14 +10755,19 @@ declare const Definitions: readonly [Schema.Struct<{
10714
10755
  type: "image";
10715
10756
  data: string;
10716
10757
  mimeType: string;
10758
+ } | {
10759
+ type: "thinking";
10760
+ thinking: string;
10761
+ thinkingSignature?: string;
10762
+ redacted?: boolean;
10717
10763
  } | {
10718
10764
  addedToolNames?: string[];
10719
10765
  arguments: Record<string, any>;
10720
10766
  callID: string;
10721
10767
  name: string;
10722
10768
  namespace?: string;
10723
- result: {
10724
- content: ({
10769
+ partial?: {
10770
+ content?: ({
10725
10771
  type: "text";
10726
10772
  text: string;
10727
10773
  textSignature?: string;
@@ -10731,9 +10777,8 @@ declare const Definitions: readonly [Schema.Struct<{
10731
10777
  mimeType: string;
10732
10778
  })[];
10733
10779
  details?: any;
10734
- isError: false;
10735
10780
  };
10736
- status: "completed";
10781
+ status: "running";
10737
10782
  thoughtSignature?: string;
10738
10783
  time: {
10739
10784
  start: number;
@@ -10757,9 +10802,9 @@ declare const Definitions: readonly [Schema.Struct<{
10757
10802
  mimeType: string;
10758
10803
  })[];
10759
10804
  details?: any;
10760
- isError: true;
10805
+ isError: false;
10761
10806
  };
10762
- status: "error";
10807
+ status: "completed";
10763
10808
  thoughtSignature?: string;
10764
10809
  time: {
10765
10810
  start: number;
@@ -10785,7 +10830,7 @@ declare const Definitions: readonly [Schema.Struct<{
10785
10830
  details?: any;
10786
10831
  isError: true;
10787
10832
  };
10788
- status: "skipped";
10833
+ status: "error";
10789
10834
  thoughtSignature?: string;
10790
10835
  time: {
10791
10836
  start: number;
@@ -10811,26 +10856,21 @@ declare const Definitions: readonly [Schema.Struct<{
10811
10856
  details?: any;
10812
10857
  isError: true;
10813
10858
  };
10814
- status: "aborted";
10859
+ status: "skipped";
10815
10860
  thoughtSignature?: string;
10816
10861
  time: {
10817
10862
  start: number;
10818
10863
  end: number;
10819
10864
  };
10820
10865
  type: "toolCall";
10821
- } | {
10822
- type: "thinking";
10823
- thinking: string;
10824
- thinkingSignature?: string;
10825
- redacted?: boolean;
10826
10866
  } | {
10827
10867
  addedToolNames?: string[];
10828
10868
  arguments: Record<string, any>;
10829
10869
  callID: string;
10830
10870
  name: string;
10831
10871
  namespace?: string;
10832
- partial?: {
10833
- content?: ({
10872
+ result: {
10873
+ content: ({
10834
10874
  type: "text";
10835
10875
  text: string;
10836
10876
  textSignature?: string;
@@ -10840,8 +10880,9 @@ declare const Definitions: readonly [Schema.Struct<{
10840
10880
  mimeType: string;
10841
10881
  })[];
10842
10882
  details?: any;
10883
+ isError: true;
10843
10884
  };
10844
- status: "running";
10885
+ status: "aborted";
10845
10886
  thoughtSignature?: string;
10846
10887
  time: {
10847
10888
  start: number;
@@ -11034,14 +11075,19 @@ declare const Definitions: readonly [Schema.Struct<{
11034
11075
  type: "image";
11035
11076
  data: string;
11036
11077
  mimeType: string;
11078
+ } | {
11079
+ type: "thinking";
11080
+ thinking: string;
11081
+ thinkingSignature?: string;
11082
+ redacted?: boolean;
11037
11083
  } | {
11038
11084
  addedToolNames?: string[];
11039
11085
  arguments: Record<string, any>;
11040
11086
  callID: string;
11041
11087
  name: string;
11042
11088
  namespace?: string;
11043
- result: {
11044
- content: ({
11089
+ partial?: {
11090
+ content?: ({
11045
11091
  type: "text";
11046
11092
  text: string;
11047
11093
  textSignature?: string;
@@ -11051,9 +11097,8 @@ declare const Definitions: readonly [Schema.Struct<{
11051
11097
  mimeType: string;
11052
11098
  })[];
11053
11099
  details?: any;
11054
- isError: false;
11055
11100
  };
11056
- status: "completed";
11101
+ status: "running";
11057
11102
  thoughtSignature?: string;
11058
11103
  time: {
11059
11104
  start: number;
@@ -11077,9 +11122,9 @@ declare const Definitions: readonly [Schema.Struct<{
11077
11122
  mimeType: string;
11078
11123
  })[];
11079
11124
  details?: any;
11080
- isError: true;
11125
+ isError: false;
11081
11126
  };
11082
- status: "error";
11127
+ status: "completed";
11083
11128
  thoughtSignature?: string;
11084
11129
  time: {
11085
11130
  start: number;
@@ -11105,7 +11150,7 @@ declare const Definitions: readonly [Schema.Struct<{
11105
11150
  details?: any;
11106
11151
  isError: true;
11107
11152
  };
11108
- status: "skipped";
11153
+ status: "error";
11109
11154
  thoughtSignature?: string;
11110
11155
  time: {
11111
11156
  start: number;
@@ -11131,26 +11176,21 @@ declare const Definitions: readonly [Schema.Struct<{
11131
11176
  details?: any;
11132
11177
  isError: true;
11133
11178
  };
11134
- status: "aborted";
11179
+ status: "skipped";
11135
11180
  thoughtSignature?: string;
11136
11181
  time: {
11137
11182
  start: number;
11138
11183
  end: number;
11139
11184
  };
11140
11185
  type: "toolCall";
11141
- } | {
11142
- type: "thinking";
11143
- thinking: string;
11144
- thinkingSignature?: string;
11145
- redacted?: boolean;
11146
11186
  } | {
11147
11187
  addedToolNames?: string[];
11148
11188
  arguments: Record<string, any>;
11149
11189
  callID: string;
11150
11190
  name: string;
11151
11191
  namespace?: string;
11152
- partial?: {
11153
- content?: ({
11192
+ result: {
11193
+ content: ({
11154
11194
  type: "text";
11155
11195
  text: string;
11156
11196
  textSignature?: string;
@@ -11160,8 +11200,9 @@ declare const Definitions: readonly [Schema.Struct<{
11160
11200
  mimeType: string;
11161
11201
  })[];
11162
11202
  details?: any;
11203
+ isError: true;
11163
11204
  };
11164
- status: "running";
11205
+ status: "aborted";
11165
11206
  thoughtSignature?: string;
11166
11207
  time: {
11167
11208
  start: number;
@@ -11336,14 +11377,19 @@ declare const Definitions: readonly [Schema.Struct<{
11336
11377
  type: "image";
11337
11378
  data: string;
11338
11379
  mimeType: string;
11380
+ } | {
11381
+ type: "thinking";
11382
+ thinking: string;
11383
+ thinkingSignature?: string;
11384
+ redacted?: boolean;
11339
11385
  } | {
11340
11386
  addedToolNames?: string[];
11341
11387
  arguments: Record<string, any>;
11342
11388
  callID: string;
11343
11389
  name: string;
11344
11390
  namespace?: string;
11345
- result: {
11346
- content: ({
11391
+ partial?: {
11392
+ content?: ({
11347
11393
  type: "text";
11348
11394
  text: string;
11349
11395
  textSignature?: string;
@@ -11353,9 +11399,8 @@ declare const Definitions: readonly [Schema.Struct<{
11353
11399
  mimeType: string;
11354
11400
  })[];
11355
11401
  details?: any;
11356
- isError: false;
11357
11402
  };
11358
- status: "completed";
11403
+ status: "running";
11359
11404
  thoughtSignature?: string;
11360
11405
  time: {
11361
11406
  start: number;
@@ -11379,9 +11424,9 @@ declare const Definitions: readonly [Schema.Struct<{
11379
11424
  mimeType: string;
11380
11425
  })[];
11381
11426
  details?: any;
11382
- isError: true;
11427
+ isError: false;
11383
11428
  };
11384
- status: "error";
11429
+ status: "completed";
11385
11430
  thoughtSignature?: string;
11386
11431
  time: {
11387
11432
  start: number;
@@ -11407,7 +11452,7 @@ declare const Definitions: readonly [Schema.Struct<{
11407
11452
  details?: any;
11408
11453
  isError: true;
11409
11454
  };
11410
- status: "skipped";
11455
+ status: "error";
11411
11456
  thoughtSignature?: string;
11412
11457
  time: {
11413
11458
  start: number;
@@ -11433,26 +11478,21 @@ declare const Definitions: readonly [Schema.Struct<{
11433
11478
  details?: any;
11434
11479
  isError: true;
11435
11480
  };
11436
- status: "aborted";
11481
+ status: "skipped";
11437
11482
  thoughtSignature?: string;
11438
11483
  time: {
11439
11484
  start: number;
11440
11485
  end: number;
11441
11486
  };
11442
11487
  type: "toolCall";
11443
- } | {
11444
- type: "thinking";
11445
- thinking: string;
11446
- thinkingSignature?: string;
11447
- redacted?: boolean;
11448
11488
  } | {
11449
11489
  addedToolNames?: string[];
11450
11490
  arguments: Record<string, any>;
11451
11491
  callID: string;
11452
11492
  name: string;
11453
11493
  namespace?: string;
11454
- partial?: {
11455
- content?: ({
11494
+ result: {
11495
+ content: ({
11456
11496
  type: "text";
11457
11497
  text: string;
11458
11498
  textSignature?: string;
@@ -11462,8 +11502,9 @@ declare const Definitions: readonly [Schema.Struct<{
11462
11502
  mimeType: string;
11463
11503
  })[];
11464
11504
  details?: any;
11505
+ isError: true;
11465
11506
  };
11466
- status: "running";
11507
+ status: "aborted";
11467
11508
  thoughtSignature?: string;
11468
11509
  time: {
11469
11510
  start: number;
@@ -11944,14 +11985,19 @@ declare const Definitions: readonly [Schema.Struct<{
11944
11985
  type: "image";
11945
11986
  data: string;
11946
11987
  mimeType: string;
11988
+ } | {
11989
+ type: "thinking";
11990
+ thinking: string;
11991
+ thinkingSignature?: string;
11992
+ redacted?: boolean;
11947
11993
  } | {
11948
11994
  addedToolNames?: string[];
11949
11995
  arguments: Record<string, any>;
11950
11996
  callID: string;
11951
11997
  name: string;
11952
11998
  namespace?: string;
11953
- result: {
11954
- content: ({
11999
+ partial?: {
12000
+ content?: ({
11955
12001
  type: "text";
11956
12002
  text: string;
11957
12003
  textSignature?: string;
@@ -11961,9 +12007,8 @@ declare const Definitions: readonly [Schema.Struct<{
11961
12007
  mimeType: string;
11962
12008
  })[];
11963
12009
  details?: any;
11964
- isError: false;
11965
12010
  };
11966
- status: "completed";
12011
+ status: "running";
11967
12012
  thoughtSignature?: string;
11968
12013
  time: {
11969
12014
  start: number;
@@ -11987,9 +12032,9 @@ declare const Definitions: readonly [Schema.Struct<{
11987
12032
  mimeType: string;
11988
12033
  })[];
11989
12034
  details?: any;
11990
- isError: true;
12035
+ isError: false;
11991
12036
  };
11992
- status: "error";
12037
+ status: "completed";
11993
12038
  thoughtSignature?: string;
11994
12039
  time: {
11995
12040
  start: number;
@@ -12015,7 +12060,7 @@ declare const Definitions: readonly [Schema.Struct<{
12015
12060
  details?: any;
12016
12061
  isError: true;
12017
12062
  };
12018
- status: "skipped";
12063
+ status: "error";
12019
12064
  thoughtSignature?: string;
12020
12065
  time: {
12021
12066
  start: number;
@@ -12041,26 +12086,21 @@ declare const Definitions: readonly [Schema.Struct<{
12041
12086
  details?: any;
12042
12087
  isError: true;
12043
12088
  };
12044
- status: "aborted";
12089
+ status: "skipped";
12045
12090
  thoughtSignature?: string;
12046
12091
  time: {
12047
12092
  start: number;
12048
12093
  end: number;
12049
12094
  };
12050
12095
  type: "toolCall";
12051
- } | {
12052
- type: "thinking";
12053
- thinking: string;
12054
- thinkingSignature?: string;
12055
- redacted?: boolean;
12056
12096
  } | {
12057
12097
  addedToolNames?: string[];
12058
12098
  arguments: Record<string, any>;
12059
12099
  callID: string;
12060
12100
  name: string;
12061
12101
  namespace?: string;
12062
- partial?: {
12063
- content?: ({
12102
+ result: {
12103
+ content: ({
12064
12104
  type: "text";
12065
12105
  text: string;
12066
12106
  textSignature?: string;
@@ -12070,8 +12110,9 @@ declare const Definitions: readonly [Schema.Struct<{
12070
12110
  mimeType: string;
12071
12111
  })[];
12072
12112
  details?: any;
12113
+ isError: true;
12073
12114
  };
12074
- status: "running";
12115
+ status: "aborted";
12075
12116
  thoughtSignature?: string;
12076
12117
  time: {
12077
12118
  start: number;
@@ -12246,14 +12287,19 @@ declare const Definitions: readonly [Schema.Struct<{
12246
12287
  type: "image";
12247
12288
  data: string;
12248
12289
  mimeType: string;
12290
+ } | {
12291
+ type: "thinking";
12292
+ thinking: string;
12293
+ thinkingSignature?: string;
12294
+ redacted?: boolean;
12249
12295
  } | {
12250
12296
  addedToolNames?: string[];
12251
12297
  arguments: Record<string, any>;
12252
12298
  callID: string;
12253
12299
  name: string;
12254
12300
  namespace?: string;
12255
- result: {
12256
- content: ({
12301
+ partial?: {
12302
+ content?: ({
12257
12303
  type: "text";
12258
12304
  text: string;
12259
12305
  textSignature?: string;
@@ -12263,9 +12309,8 @@ declare const Definitions: readonly [Schema.Struct<{
12263
12309
  mimeType: string;
12264
12310
  })[];
12265
12311
  details?: any;
12266
- isError: false;
12267
12312
  };
12268
- status: "completed";
12313
+ status: "running";
12269
12314
  thoughtSignature?: string;
12270
12315
  time: {
12271
12316
  start: number;
@@ -12289,9 +12334,9 @@ declare const Definitions: readonly [Schema.Struct<{
12289
12334
  mimeType: string;
12290
12335
  })[];
12291
12336
  details?: any;
12292
- isError: true;
12337
+ isError: false;
12293
12338
  };
12294
- status: "error";
12339
+ status: "completed";
12295
12340
  thoughtSignature?: string;
12296
12341
  time: {
12297
12342
  start: number;
@@ -12317,7 +12362,7 @@ declare const Definitions: readonly [Schema.Struct<{
12317
12362
  details?: any;
12318
12363
  isError: true;
12319
12364
  };
12320
- status: "skipped";
12365
+ status: "error";
12321
12366
  thoughtSignature?: string;
12322
12367
  time: {
12323
12368
  start: number;
@@ -12343,26 +12388,21 @@ declare const Definitions: readonly [Schema.Struct<{
12343
12388
  details?: any;
12344
12389
  isError: true;
12345
12390
  };
12346
- status: "aborted";
12391
+ status: "skipped";
12347
12392
  thoughtSignature?: string;
12348
12393
  time: {
12349
12394
  start: number;
12350
12395
  end: number;
12351
12396
  };
12352
12397
  type: "toolCall";
12353
- } | {
12354
- type: "thinking";
12355
- thinking: string;
12356
- thinkingSignature?: string;
12357
- redacted?: boolean;
12358
12398
  } | {
12359
12399
  addedToolNames?: string[];
12360
12400
  arguments: Record<string, any>;
12361
12401
  callID: string;
12362
12402
  name: string;
12363
12403
  namespace?: string;
12364
- partial?: {
12365
- content?: ({
12404
+ result: {
12405
+ content: ({
12366
12406
  type: "text";
12367
12407
  text: string;
12368
12408
  textSignature?: string;
@@ -12372,8 +12412,9 @@ declare const Definitions: readonly [Schema.Struct<{
12372
12412
  mimeType: string;
12373
12413
  })[];
12374
12414
  details?: any;
12415
+ isError: true;
12375
12416
  };
12376
- status: "running";
12417
+ status: "aborted";
12377
12418
  thoughtSignature?: string;
12378
12419
  time: {
12379
12420
  start: number;
@@ -12567,14 +12608,19 @@ declare const Definitions: readonly [Schema.Struct<{
12567
12608
  type: "image";
12568
12609
  data: string;
12569
12610
  mimeType: string;
12611
+ } | {
12612
+ type: "thinking";
12613
+ thinking: string;
12614
+ thinkingSignature?: string;
12615
+ redacted?: boolean;
12570
12616
  } | {
12571
12617
  addedToolNames?: string[];
12572
12618
  arguments: Record<string, any>;
12573
12619
  callID: string;
12574
12620
  name: string;
12575
12621
  namespace?: string;
12576
- result: {
12577
- content: ({
12622
+ partial?: {
12623
+ content?: ({
12578
12624
  type: "text";
12579
12625
  text: string;
12580
12626
  textSignature?: string;
@@ -12584,9 +12630,8 @@ declare const Definitions: readonly [Schema.Struct<{
12584
12630
  mimeType: string;
12585
12631
  })[];
12586
12632
  details?: any;
12587
- isError: false;
12588
12633
  };
12589
- status: "completed";
12634
+ status: "running";
12590
12635
  thoughtSignature?: string;
12591
12636
  time: {
12592
12637
  start: number;
@@ -12610,9 +12655,9 @@ declare const Definitions: readonly [Schema.Struct<{
12610
12655
  mimeType: string;
12611
12656
  })[];
12612
12657
  details?: any;
12613
- isError: true;
12658
+ isError: false;
12614
12659
  };
12615
- status: "error";
12660
+ status: "completed";
12616
12661
  thoughtSignature?: string;
12617
12662
  time: {
12618
12663
  start: number;
@@ -12638,7 +12683,7 @@ declare const Definitions: readonly [Schema.Struct<{
12638
12683
  details?: any;
12639
12684
  isError: true;
12640
12685
  };
12641
- status: "skipped";
12686
+ status: "error";
12642
12687
  thoughtSignature?: string;
12643
12688
  time: {
12644
12689
  start: number;
@@ -12664,26 +12709,21 @@ declare const Definitions: readonly [Schema.Struct<{
12664
12709
  details?: any;
12665
12710
  isError: true;
12666
12711
  };
12667
- status: "aborted";
12712
+ status: "skipped";
12668
12713
  thoughtSignature?: string;
12669
12714
  time: {
12670
12715
  start: number;
12671
12716
  end: number;
12672
12717
  };
12673
12718
  type: "toolCall";
12674
- } | {
12675
- type: "thinking";
12676
- thinking: string;
12677
- thinkingSignature?: string;
12678
- redacted?: boolean;
12679
12719
  } | {
12680
12720
  addedToolNames?: string[];
12681
12721
  arguments: Record<string, any>;
12682
12722
  callID: string;
12683
12723
  name: string;
12684
12724
  namespace?: string;
12685
- partial?: {
12686
- content?: ({
12725
+ result: {
12726
+ content: ({
12687
12727
  type: "text";
12688
12728
  text: string;
12689
12729
  textSignature?: string;
@@ -12693,8 +12733,9 @@ declare const Definitions: readonly [Schema.Struct<{
12693
12733
  mimeType: string;
12694
12734
  })[];
12695
12735
  details?: any;
12736
+ isError: true;
12696
12737
  };
12697
- status: "running";
12738
+ status: "aborted";
12698
12739
  thoughtSignature?: string;
12699
12740
  time: {
12700
12741
  start: number;
@@ -12869,14 +12910,19 @@ declare const Definitions: readonly [Schema.Struct<{
12869
12910
  type: "image";
12870
12911
  data: string;
12871
12912
  mimeType: string;
12913
+ } | {
12914
+ type: "thinking";
12915
+ thinking: string;
12916
+ thinkingSignature?: string;
12917
+ redacted?: boolean;
12872
12918
  } | {
12873
12919
  addedToolNames?: string[];
12874
12920
  arguments: Record<string, any>;
12875
12921
  callID: string;
12876
12922
  name: string;
12877
12923
  namespace?: string;
12878
- result: {
12879
- content: ({
12924
+ partial?: {
12925
+ content?: ({
12880
12926
  type: "text";
12881
12927
  text: string;
12882
12928
  textSignature?: string;
@@ -12886,9 +12932,8 @@ declare const Definitions: readonly [Schema.Struct<{
12886
12932
  mimeType: string;
12887
12933
  })[];
12888
12934
  details?: any;
12889
- isError: false;
12890
12935
  };
12891
- status: "completed";
12936
+ status: "running";
12892
12937
  thoughtSignature?: string;
12893
12938
  time: {
12894
12939
  start: number;
@@ -12912,9 +12957,9 @@ declare const Definitions: readonly [Schema.Struct<{
12912
12957
  mimeType: string;
12913
12958
  })[];
12914
12959
  details?: any;
12915
- isError: true;
12960
+ isError: false;
12916
12961
  };
12917
- status: "error";
12962
+ status: "completed";
12918
12963
  thoughtSignature?: string;
12919
12964
  time: {
12920
12965
  start: number;
@@ -12940,7 +12985,7 @@ declare const Definitions: readonly [Schema.Struct<{
12940
12985
  details?: any;
12941
12986
  isError: true;
12942
12987
  };
12943
- status: "skipped";
12988
+ status: "error";
12944
12989
  thoughtSignature?: string;
12945
12990
  time: {
12946
12991
  start: number;
@@ -12966,26 +13011,21 @@ declare const Definitions: readonly [Schema.Struct<{
12966
13011
  details?: any;
12967
13012
  isError: true;
12968
13013
  };
12969
- status: "aborted";
13014
+ status: "skipped";
12970
13015
  thoughtSignature?: string;
12971
13016
  time: {
12972
13017
  start: number;
12973
13018
  end: number;
12974
13019
  };
12975
13020
  type: "toolCall";
12976
- } | {
12977
- type: "thinking";
12978
- thinking: string;
12979
- thinkingSignature?: string;
12980
- redacted?: boolean;
12981
13021
  } | {
12982
13022
  addedToolNames?: string[];
12983
13023
  arguments: Record<string, any>;
12984
13024
  callID: string;
12985
13025
  name: string;
12986
13026
  namespace?: string;
12987
- partial?: {
12988
- content?: ({
13027
+ result: {
13028
+ content: ({
12989
13029
  type: "text";
12990
13030
  text: string;
12991
13031
  textSignature?: string;
@@ -12995,8 +13035,9 @@ declare const Definitions: readonly [Schema.Struct<{
12995
13035
  mimeType: string;
12996
13036
  })[];
12997
13037
  details?: any;
13038
+ isError: true;
12998
13039
  };
12999
- status: "running";
13040
+ status: "aborted";
13000
13041
  thoughtSignature?: string;
13001
13042
  time: {
13002
13043
  start: number;
@@ -13199,14 +13240,19 @@ declare const Definitions: readonly [Schema.Struct<{
13199
13240
  type: "image";
13200
13241
  data: string;
13201
13242
  mimeType: string;
13243
+ } | {
13244
+ type: "thinking";
13245
+ thinking: string;
13246
+ thinkingSignature?: string;
13247
+ redacted?: boolean;
13202
13248
  } | {
13203
13249
  addedToolNames?: string[];
13204
13250
  arguments: Record<string, any>;
13205
13251
  callID: string;
13206
13252
  name: string;
13207
13253
  namespace?: string;
13208
- result: {
13209
- content: ({
13254
+ partial?: {
13255
+ content?: ({
13210
13256
  type: "text";
13211
13257
  text: string;
13212
13258
  textSignature?: string;
@@ -13216,9 +13262,8 @@ declare const Definitions: readonly [Schema.Struct<{
13216
13262
  mimeType: string;
13217
13263
  })[];
13218
13264
  details?: any;
13219
- isError: false;
13220
13265
  };
13221
- status: "completed";
13266
+ status: "running";
13222
13267
  thoughtSignature?: string;
13223
13268
  time: {
13224
13269
  start: number;
@@ -13242,9 +13287,9 @@ declare const Definitions: readonly [Schema.Struct<{
13242
13287
  mimeType: string;
13243
13288
  })[];
13244
13289
  details?: any;
13245
- isError: true;
13290
+ isError: false;
13246
13291
  };
13247
- status: "error";
13292
+ status: "completed";
13248
13293
  thoughtSignature?: string;
13249
13294
  time: {
13250
13295
  start: number;
@@ -13270,7 +13315,7 @@ declare const Definitions: readonly [Schema.Struct<{
13270
13315
  details?: any;
13271
13316
  isError: true;
13272
13317
  };
13273
- status: "skipped";
13318
+ status: "error";
13274
13319
  thoughtSignature?: string;
13275
13320
  time: {
13276
13321
  start: number;
@@ -13296,26 +13341,21 @@ declare const Definitions: readonly [Schema.Struct<{
13296
13341
  details?: any;
13297
13342
  isError: true;
13298
13343
  };
13299
- status: "aborted";
13344
+ status: "skipped";
13300
13345
  thoughtSignature?: string;
13301
13346
  time: {
13302
13347
  start: number;
13303
13348
  end: number;
13304
13349
  };
13305
13350
  type: "toolCall";
13306
- } | {
13307
- type: "thinking";
13308
- thinking: string;
13309
- thinkingSignature?: string;
13310
- redacted?: boolean;
13311
13351
  } | {
13312
13352
  addedToolNames?: string[];
13313
13353
  arguments: Record<string, any>;
13314
13354
  callID: string;
13315
13355
  name: string;
13316
13356
  namespace?: string;
13317
- partial?: {
13318
- content?: ({
13357
+ result: {
13358
+ content: ({
13319
13359
  type: "text";
13320
13360
  text: string;
13321
13361
  textSignature?: string;
@@ -13325,8 +13365,9 @@ declare const Definitions: readonly [Schema.Struct<{
13325
13365
  mimeType: string;
13326
13366
  })[];
13327
13367
  details?: any;
13368
+ isError: true;
13328
13369
  };
13329
- status: "running";
13370
+ status: "aborted";
13330
13371
  thoughtSignature?: string;
13331
13372
  time: {
13332
13373
  start: number;
@@ -13501,14 +13542,19 @@ declare const Definitions: readonly [Schema.Struct<{
13501
13542
  type: "image";
13502
13543
  data: string;
13503
13544
  mimeType: string;
13545
+ } | {
13546
+ type: "thinking";
13547
+ thinking: string;
13548
+ thinkingSignature?: string;
13549
+ redacted?: boolean;
13504
13550
  } | {
13505
13551
  addedToolNames?: string[];
13506
13552
  arguments: Record<string, any>;
13507
13553
  callID: string;
13508
13554
  name: string;
13509
13555
  namespace?: string;
13510
- result: {
13511
- content: ({
13556
+ partial?: {
13557
+ content?: ({
13512
13558
  type: "text";
13513
13559
  text: string;
13514
13560
  textSignature?: string;
@@ -13518,9 +13564,8 @@ declare const Definitions: readonly [Schema.Struct<{
13518
13564
  mimeType: string;
13519
13565
  })[];
13520
13566
  details?: any;
13521
- isError: false;
13522
13567
  };
13523
- status: "completed";
13568
+ status: "running";
13524
13569
  thoughtSignature?: string;
13525
13570
  time: {
13526
13571
  start: number;
@@ -13544,9 +13589,9 @@ declare const Definitions: readonly [Schema.Struct<{
13544
13589
  mimeType: string;
13545
13590
  })[];
13546
13591
  details?: any;
13547
- isError: true;
13592
+ isError: false;
13548
13593
  };
13549
- status: "error";
13594
+ status: "completed";
13550
13595
  thoughtSignature?: string;
13551
13596
  time: {
13552
13597
  start: number;
@@ -13572,7 +13617,7 @@ declare const Definitions: readonly [Schema.Struct<{
13572
13617
  details?: any;
13573
13618
  isError: true;
13574
13619
  };
13575
- status: "skipped";
13620
+ status: "error";
13576
13621
  thoughtSignature?: string;
13577
13622
  time: {
13578
13623
  start: number;
@@ -13598,26 +13643,21 @@ declare const Definitions: readonly [Schema.Struct<{
13598
13643
  details?: any;
13599
13644
  isError: true;
13600
13645
  };
13601
- status: "aborted";
13646
+ status: "skipped";
13602
13647
  thoughtSignature?: string;
13603
13648
  time: {
13604
13649
  start: number;
13605
13650
  end: number;
13606
13651
  };
13607
13652
  type: "toolCall";
13608
- } | {
13609
- type: "thinking";
13610
- thinking: string;
13611
- thinkingSignature?: string;
13612
- redacted?: boolean;
13613
13653
  } | {
13614
13654
  addedToolNames?: string[];
13615
13655
  arguments: Record<string, any>;
13616
13656
  callID: string;
13617
13657
  name: string;
13618
13658
  namespace?: string;
13619
- partial?: {
13620
- content?: ({
13659
+ result: {
13660
+ content: ({
13621
13661
  type: "text";
13622
13662
  text: string;
13623
13663
  textSignature?: string;
@@ -13627,8 +13667,9 @@ declare const Definitions: readonly [Schema.Struct<{
13627
13667
  mimeType: string;
13628
13668
  })[];
13629
13669
  details?: any;
13670
+ isError: true;
13630
13671
  };
13631
- status: "running";
13672
+ status: "aborted";
13632
13673
  thoughtSignature?: string;
13633
13674
  time: {
13634
13675
  start: number;
@@ -13822,14 +13863,19 @@ declare const Definitions: readonly [Schema.Struct<{
13822
13863
  type: "image";
13823
13864
  data: string;
13824
13865
  mimeType: string;
13866
+ } | {
13867
+ type: "thinking";
13868
+ thinking: string;
13869
+ thinkingSignature?: string;
13870
+ redacted?: boolean;
13825
13871
  } | {
13826
13872
  addedToolNames?: string[];
13827
13873
  arguments: Record<string, any>;
13828
13874
  callID: string;
13829
13875
  name: string;
13830
13876
  namespace?: string;
13831
- result: {
13832
- content: ({
13877
+ partial?: {
13878
+ content?: ({
13833
13879
  type: "text";
13834
13880
  text: string;
13835
13881
  textSignature?: string;
@@ -13839,9 +13885,8 @@ declare const Definitions: readonly [Schema.Struct<{
13839
13885
  mimeType: string;
13840
13886
  })[];
13841
13887
  details?: any;
13842
- isError: false;
13843
13888
  };
13844
- status: "completed";
13889
+ status: "running";
13845
13890
  thoughtSignature?: string;
13846
13891
  time: {
13847
13892
  start: number;
@@ -13865,9 +13910,9 @@ declare const Definitions: readonly [Schema.Struct<{
13865
13910
  mimeType: string;
13866
13911
  })[];
13867
13912
  details?: any;
13868
- isError: true;
13913
+ isError: false;
13869
13914
  };
13870
- status: "error";
13915
+ status: "completed";
13871
13916
  thoughtSignature?: string;
13872
13917
  time: {
13873
13918
  start: number;
@@ -13893,7 +13938,7 @@ declare const Definitions: readonly [Schema.Struct<{
13893
13938
  details?: any;
13894
13939
  isError: true;
13895
13940
  };
13896
- status: "skipped";
13941
+ status: "error";
13897
13942
  thoughtSignature?: string;
13898
13943
  time: {
13899
13944
  start: number;
@@ -13919,26 +13964,21 @@ declare const Definitions: readonly [Schema.Struct<{
13919
13964
  details?: any;
13920
13965
  isError: true;
13921
13966
  };
13922
- status: "aborted";
13967
+ status: "skipped";
13923
13968
  thoughtSignature?: string;
13924
13969
  time: {
13925
13970
  start: number;
13926
13971
  end: number;
13927
13972
  };
13928
13973
  type: "toolCall";
13929
- } | {
13930
- type: "thinking";
13931
- thinking: string;
13932
- thinkingSignature?: string;
13933
- redacted?: boolean;
13934
13974
  } | {
13935
13975
  addedToolNames?: string[];
13936
13976
  arguments: Record<string, any>;
13937
13977
  callID: string;
13938
13978
  name: string;
13939
13979
  namespace?: string;
13940
- partial?: {
13941
- content?: ({
13980
+ result: {
13981
+ content: ({
13942
13982
  type: "text";
13943
13983
  text: string;
13944
13984
  textSignature?: string;
@@ -13948,8 +13988,9 @@ declare const Definitions: readonly [Schema.Struct<{
13948
13988
  mimeType: string;
13949
13989
  })[];
13950
13990
  details?: any;
13991
+ isError: true;
13951
13992
  };
13952
- status: "running";
13993
+ status: "aborted";
13953
13994
  thoughtSignature?: string;
13954
13995
  time: {
13955
13996
  start: number;
@@ -14124,14 +14165,19 @@ declare const Definitions: readonly [Schema.Struct<{
14124
14165
  type: "image";
14125
14166
  data: string;
14126
14167
  mimeType: string;
14168
+ } | {
14169
+ type: "thinking";
14170
+ thinking: string;
14171
+ thinkingSignature?: string;
14172
+ redacted?: boolean;
14127
14173
  } | {
14128
14174
  addedToolNames?: string[];
14129
14175
  arguments: Record<string, any>;
14130
14176
  callID: string;
14131
14177
  name: string;
14132
14178
  namespace?: string;
14133
- result: {
14134
- content: ({
14179
+ partial?: {
14180
+ content?: ({
14135
14181
  type: "text";
14136
14182
  text: string;
14137
14183
  textSignature?: string;
@@ -14141,9 +14187,8 @@ declare const Definitions: readonly [Schema.Struct<{
14141
14187
  mimeType: string;
14142
14188
  })[];
14143
14189
  details?: any;
14144
- isError: false;
14145
14190
  };
14146
- status: "completed";
14191
+ status: "running";
14147
14192
  thoughtSignature?: string;
14148
14193
  time: {
14149
14194
  start: number;
@@ -14167,9 +14212,9 @@ declare const Definitions: readonly [Schema.Struct<{
14167
14212
  mimeType: string;
14168
14213
  })[];
14169
14214
  details?: any;
14170
- isError: true;
14215
+ isError: false;
14171
14216
  };
14172
- status: "error";
14217
+ status: "completed";
14173
14218
  thoughtSignature?: string;
14174
14219
  time: {
14175
14220
  start: number;
@@ -14195,7 +14240,7 @@ declare const Definitions: readonly [Schema.Struct<{
14195
14240
  details?: any;
14196
14241
  isError: true;
14197
14242
  };
14198
- status: "skipped";
14243
+ status: "error";
14199
14244
  thoughtSignature?: string;
14200
14245
  time: {
14201
14246
  start: number;
@@ -14221,26 +14266,21 @@ declare const Definitions: readonly [Schema.Struct<{
14221
14266
  details?: any;
14222
14267
  isError: true;
14223
14268
  };
14224
- status: "aborted";
14269
+ status: "skipped";
14225
14270
  thoughtSignature?: string;
14226
14271
  time: {
14227
14272
  start: number;
14228
14273
  end: number;
14229
14274
  };
14230
14275
  type: "toolCall";
14231
- } | {
14232
- type: "thinking";
14233
- thinking: string;
14234
- thinkingSignature?: string;
14235
- redacted?: boolean;
14236
14276
  } | {
14237
14277
  addedToolNames?: string[];
14238
14278
  arguments: Record<string, any>;
14239
14279
  callID: string;
14240
14280
  name: string;
14241
14281
  namespace?: string;
14242
- partial?: {
14243
- content?: ({
14282
+ result: {
14283
+ content: ({
14244
14284
  type: "text";
14245
14285
  text: string;
14246
14286
  textSignature?: string;
@@ -14250,8 +14290,9 @@ declare const Definitions: readonly [Schema.Struct<{
14250
14290
  mimeType: string;
14251
14291
  })[];
14252
14292
  details?: any;
14293
+ isError: true;
14253
14294
  };
14254
- status: "running";
14295
+ status: "aborted";
14255
14296
  thoughtSignature?: string;
14256
14297
  time: {
14257
14298
  start: number;
@@ -15760,14 +15801,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15760
15801
  type: "image";
15761
15802
  data: string;
15762
15803
  mimeType: string;
15804
+ } | {
15805
+ type: "thinking";
15806
+ thinking: string;
15807
+ thinkingSignature?: string;
15808
+ redacted?: boolean;
15763
15809
  } | {
15764
15810
  addedToolNames?: string[];
15765
15811
  arguments: Record<string, any>;
15766
15812
  callID: string;
15767
15813
  name: string;
15768
15814
  namespace?: string;
15769
- result: {
15770
- content: ({
15815
+ partial?: {
15816
+ content?: ({
15771
15817
  type: "text";
15772
15818
  text: string;
15773
15819
  textSignature?: string;
@@ -15777,9 +15823,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15777
15823
  mimeType: string;
15778
15824
  })[];
15779
15825
  details?: any;
15780
- isError: false;
15781
15826
  };
15782
- status: "completed";
15827
+ status: "running";
15783
15828
  thoughtSignature?: string;
15784
15829
  time: {
15785
15830
  start: number;
@@ -15803,9 +15848,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15803
15848
  mimeType: string;
15804
15849
  })[];
15805
15850
  details?: any;
15806
- isError: true;
15851
+ isError: false;
15807
15852
  };
15808
- status: "error";
15853
+ status: "completed";
15809
15854
  thoughtSignature?: string;
15810
15855
  time: {
15811
15856
  start: number;
@@ -15831,7 +15876,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15831
15876
  details?: any;
15832
15877
  isError: true;
15833
15878
  };
15834
- status: "skipped";
15879
+ status: "error";
15835
15880
  thoughtSignature?: string;
15836
15881
  time: {
15837
15882
  start: number;
@@ -15857,26 +15902,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15857
15902
  details?: any;
15858
15903
  isError: true;
15859
15904
  };
15860
- status: "aborted";
15905
+ status: "skipped";
15861
15906
  thoughtSignature?: string;
15862
15907
  time: {
15863
15908
  start: number;
15864
15909
  end: number;
15865
15910
  };
15866
15911
  type: "toolCall";
15867
- } | {
15868
- type: "thinking";
15869
- thinking: string;
15870
- thinkingSignature?: string;
15871
- redacted?: boolean;
15872
15912
  } | {
15873
15913
  addedToolNames?: string[];
15874
15914
  arguments: Record<string, any>;
15875
15915
  callID: string;
15876
15916
  name: string;
15877
15917
  namespace?: string;
15878
- partial?: {
15879
- content?: ({
15918
+ result: {
15919
+ content: ({
15880
15920
  type: "text";
15881
15921
  text: string;
15882
15922
  textSignature?: string;
@@ -15886,8 +15926,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15886
15926
  mimeType: string;
15887
15927
  })[];
15888
15928
  details?: any;
15929
+ isError: true;
15889
15930
  };
15890
- status: "running";
15931
+ status: "aborted";
15891
15932
  thoughtSignature?: string;
15892
15933
  time: {
15893
15934
  start: number;
@@ -16062,14 +16103,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16062
16103
  type: "image";
16063
16104
  data: string;
16064
16105
  mimeType: string;
16106
+ } | {
16107
+ type: "thinking";
16108
+ thinking: string;
16109
+ thinkingSignature?: string;
16110
+ redacted?: boolean;
16065
16111
  } | {
16066
16112
  addedToolNames?: string[];
16067
16113
  arguments: Record<string, any>;
16068
16114
  callID: string;
16069
16115
  name: string;
16070
16116
  namespace?: string;
16071
- result: {
16072
- content: ({
16117
+ partial?: {
16118
+ content?: ({
16073
16119
  type: "text";
16074
16120
  text: string;
16075
16121
  textSignature?: string;
@@ -16079,9 +16125,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16079
16125
  mimeType: string;
16080
16126
  })[];
16081
16127
  details?: any;
16082
- isError: false;
16083
16128
  };
16084
- status: "completed";
16129
+ status: "running";
16085
16130
  thoughtSignature?: string;
16086
16131
  time: {
16087
16132
  start: number;
@@ -16105,9 +16150,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16105
16150
  mimeType: string;
16106
16151
  })[];
16107
16152
  details?: any;
16108
- isError: true;
16153
+ isError: false;
16109
16154
  };
16110
- status: "error";
16155
+ status: "completed";
16111
16156
  thoughtSignature?: string;
16112
16157
  time: {
16113
16158
  start: number;
@@ -16133,7 +16178,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16133
16178
  details?: any;
16134
16179
  isError: true;
16135
16180
  };
16136
- status: "skipped";
16181
+ status: "error";
16137
16182
  thoughtSignature?: string;
16138
16183
  time: {
16139
16184
  start: number;
@@ -16159,26 +16204,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16159
16204
  details?: any;
16160
16205
  isError: true;
16161
16206
  };
16162
- status: "aborted";
16207
+ status: "skipped";
16163
16208
  thoughtSignature?: string;
16164
16209
  time: {
16165
16210
  start: number;
16166
16211
  end: number;
16167
16212
  };
16168
16213
  type: "toolCall";
16169
- } | {
16170
- type: "thinking";
16171
- thinking: string;
16172
- thinkingSignature?: string;
16173
- redacted?: boolean;
16174
16214
  } | {
16175
16215
  addedToolNames?: string[];
16176
16216
  arguments: Record<string, any>;
16177
16217
  callID: string;
16178
16218
  name: string;
16179
16219
  namespace?: string;
16180
- partial?: {
16181
- content?: ({
16220
+ result: {
16221
+ content: ({
16182
16222
  type: "text";
16183
16223
  text: string;
16184
16224
  textSignature?: string;
@@ -16188,8 +16228,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16188
16228
  mimeType: string;
16189
16229
  })[];
16190
16230
  details?: any;
16231
+ isError: true;
16191
16232
  };
16192
- status: "running";
16233
+ status: "aborted";
16193
16234
  thoughtSignature?: string;
16194
16235
  time: {
16195
16236
  start: number;
@@ -16382,14 +16423,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16382
16423
  type: "image";
16383
16424
  data: string;
16384
16425
  mimeType: string;
16426
+ } | {
16427
+ type: "thinking";
16428
+ thinking: string;
16429
+ thinkingSignature?: string;
16430
+ redacted?: boolean;
16385
16431
  } | {
16386
16432
  addedToolNames?: string[];
16387
16433
  arguments: Record<string, any>;
16388
16434
  callID: string;
16389
16435
  name: string;
16390
16436
  namespace?: string;
16391
- result: {
16392
- content: ({
16437
+ partial?: {
16438
+ content?: ({
16393
16439
  type: "text";
16394
16440
  text: string;
16395
16441
  textSignature?: string;
@@ -16399,9 +16445,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16399
16445
  mimeType: string;
16400
16446
  })[];
16401
16447
  details?: any;
16402
- isError: false;
16403
16448
  };
16404
- status: "completed";
16449
+ status: "running";
16405
16450
  thoughtSignature?: string;
16406
16451
  time: {
16407
16452
  start: number;
@@ -16425,9 +16470,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16425
16470
  mimeType: string;
16426
16471
  })[];
16427
16472
  details?: any;
16428
- isError: true;
16473
+ isError: false;
16429
16474
  };
16430
- status: "error";
16475
+ status: "completed";
16431
16476
  thoughtSignature?: string;
16432
16477
  time: {
16433
16478
  start: number;
@@ -16453,7 +16498,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16453
16498
  details?: any;
16454
16499
  isError: true;
16455
16500
  };
16456
- status: "skipped";
16501
+ status: "error";
16457
16502
  thoughtSignature?: string;
16458
16503
  time: {
16459
16504
  start: number;
@@ -16479,26 +16524,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16479
16524
  details?: any;
16480
16525
  isError: true;
16481
16526
  };
16482
- status: "aborted";
16527
+ status: "skipped";
16483
16528
  thoughtSignature?: string;
16484
16529
  time: {
16485
16530
  start: number;
16486
16531
  end: number;
16487
16532
  };
16488
16533
  type: "toolCall";
16489
- } | {
16490
- type: "thinking";
16491
- thinking: string;
16492
- thinkingSignature?: string;
16493
- redacted?: boolean;
16494
16534
  } | {
16495
16535
  addedToolNames?: string[];
16496
16536
  arguments: Record<string, any>;
16497
16537
  callID: string;
16498
16538
  name: string;
16499
16539
  namespace?: string;
16500
- partial?: {
16501
- content?: ({
16540
+ result: {
16541
+ content: ({
16502
16542
  type: "text";
16503
16543
  text: string;
16504
16544
  textSignature?: string;
@@ -16508,8 +16548,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16508
16548
  mimeType: string;
16509
16549
  })[];
16510
16550
  details?: any;
16551
+ isError: true;
16511
16552
  };
16512
- status: "running";
16553
+ status: "aborted";
16513
16554
  thoughtSignature?: string;
16514
16555
  time: {
16515
16556
  start: number;
@@ -16684,14 +16725,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16684
16725
  type: "image";
16685
16726
  data: string;
16686
16727
  mimeType: string;
16728
+ } | {
16729
+ type: "thinking";
16730
+ thinking: string;
16731
+ thinkingSignature?: string;
16732
+ redacted?: boolean;
16687
16733
  } | {
16688
16734
  addedToolNames?: string[];
16689
16735
  arguments: Record<string, any>;
16690
16736
  callID: string;
16691
16737
  name: string;
16692
16738
  namespace?: string;
16693
- result: {
16694
- content: ({
16739
+ partial?: {
16740
+ content?: ({
16695
16741
  type: "text";
16696
16742
  text: string;
16697
16743
  textSignature?: string;
@@ -16701,9 +16747,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16701
16747
  mimeType: string;
16702
16748
  })[];
16703
16749
  details?: any;
16704
- isError: false;
16705
16750
  };
16706
- status: "completed";
16751
+ status: "running";
16707
16752
  thoughtSignature?: string;
16708
16753
  time: {
16709
16754
  start: number;
@@ -16727,9 +16772,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16727
16772
  mimeType: string;
16728
16773
  })[];
16729
16774
  details?: any;
16730
- isError: true;
16775
+ isError: false;
16731
16776
  };
16732
- status: "error";
16777
+ status: "completed";
16733
16778
  thoughtSignature?: string;
16734
16779
  time: {
16735
16780
  start: number;
@@ -16755,7 +16800,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16755
16800
  details?: any;
16756
16801
  isError: true;
16757
16802
  };
16758
- status: "skipped";
16803
+ status: "error";
16759
16804
  thoughtSignature?: string;
16760
16805
  time: {
16761
16806
  start: number;
@@ -16781,26 +16826,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16781
16826
  details?: any;
16782
16827
  isError: true;
16783
16828
  };
16784
- status: "aborted";
16829
+ status: "skipped";
16785
16830
  thoughtSignature?: string;
16786
16831
  time: {
16787
16832
  start: number;
16788
16833
  end: number;
16789
16834
  };
16790
16835
  type: "toolCall";
16791
- } | {
16792
- type: "thinking";
16793
- thinking: string;
16794
- thinkingSignature?: string;
16795
- redacted?: boolean;
16796
16836
  } | {
16797
16837
  addedToolNames?: string[];
16798
16838
  arguments: Record<string, any>;
16799
16839
  callID: string;
16800
16840
  name: string;
16801
16841
  namespace?: string;
16802
- partial?: {
16803
- content?: ({
16842
+ result: {
16843
+ content: ({
16804
16844
  type: "text";
16805
16845
  text: string;
16806
16846
  textSignature?: string;
@@ -16810,8 +16850,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16810
16850
  mimeType: string;
16811
16851
  })[];
16812
16852
  details?: any;
16853
+ isError: true;
16813
16854
  };
16814
- status: "running";
16855
+ status: "aborted";
16815
16856
  thoughtSignature?: string;
16816
16857
  time: {
16817
16858
  start: number;
@@ -17292,14 +17333,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17292
17333
  type: "image";
17293
17334
  data: string;
17294
17335
  mimeType: string;
17336
+ } | {
17337
+ type: "thinking";
17338
+ thinking: string;
17339
+ thinkingSignature?: string;
17340
+ redacted?: boolean;
17295
17341
  } | {
17296
17342
  addedToolNames?: string[];
17297
17343
  arguments: Record<string, any>;
17298
17344
  callID: string;
17299
17345
  name: string;
17300
17346
  namespace?: string;
17301
- result: {
17302
- content: ({
17347
+ partial?: {
17348
+ content?: ({
17303
17349
  type: "text";
17304
17350
  text: string;
17305
17351
  textSignature?: string;
@@ -17309,9 +17355,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17309
17355
  mimeType: string;
17310
17356
  })[];
17311
17357
  details?: any;
17312
- isError: false;
17313
17358
  };
17314
- status: "completed";
17359
+ status: "running";
17315
17360
  thoughtSignature?: string;
17316
17361
  time: {
17317
17362
  start: number;
@@ -17335,9 +17380,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17335
17380
  mimeType: string;
17336
17381
  })[];
17337
17382
  details?: any;
17338
- isError: true;
17383
+ isError: false;
17339
17384
  };
17340
- status: "error";
17385
+ status: "completed";
17341
17386
  thoughtSignature?: string;
17342
17387
  time: {
17343
17388
  start: number;
@@ -17363,7 +17408,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17363
17408
  details?: any;
17364
17409
  isError: true;
17365
17410
  };
17366
- status: "skipped";
17411
+ status: "error";
17367
17412
  thoughtSignature?: string;
17368
17413
  time: {
17369
17414
  start: number;
@@ -17389,26 +17434,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17389
17434
  details?: any;
17390
17435
  isError: true;
17391
17436
  };
17392
- status: "aborted";
17437
+ status: "skipped";
17393
17438
  thoughtSignature?: string;
17394
17439
  time: {
17395
17440
  start: number;
17396
17441
  end: number;
17397
17442
  };
17398
17443
  type: "toolCall";
17399
- } | {
17400
- type: "thinking";
17401
- thinking: string;
17402
- thinkingSignature?: string;
17403
- redacted?: boolean;
17404
17444
  } | {
17405
17445
  addedToolNames?: string[];
17406
17446
  arguments: Record<string, any>;
17407
17447
  callID: string;
17408
17448
  name: string;
17409
17449
  namespace?: string;
17410
- partial?: {
17411
- content?: ({
17450
+ result: {
17451
+ content: ({
17412
17452
  type: "text";
17413
17453
  text: string;
17414
17454
  textSignature?: string;
@@ -17418,8 +17458,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17418
17458
  mimeType: string;
17419
17459
  })[];
17420
17460
  details?: any;
17461
+ isError: true;
17421
17462
  };
17422
- status: "running";
17463
+ status: "aborted";
17423
17464
  thoughtSignature?: string;
17424
17465
  time: {
17425
17466
  start: number;
@@ -17594,14 +17635,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17594
17635
  type: "image";
17595
17636
  data: string;
17596
17637
  mimeType: string;
17638
+ } | {
17639
+ type: "thinking";
17640
+ thinking: string;
17641
+ thinkingSignature?: string;
17642
+ redacted?: boolean;
17597
17643
  } | {
17598
17644
  addedToolNames?: string[];
17599
17645
  arguments: Record<string, any>;
17600
17646
  callID: string;
17601
17647
  name: string;
17602
17648
  namespace?: string;
17603
- result: {
17604
- content: ({
17649
+ partial?: {
17650
+ content?: ({
17605
17651
  type: "text";
17606
17652
  text: string;
17607
17653
  textSignature?: string;
@@ -17611,9 +17657,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17611
17657
  mimeType: string;
17612
17658
  })[];
17613
17659
  details?: any;
17614
- isError: false;
17615
17660
  };
17616
- status: "completed";
17661
+ status: "running";
17617
17662
  thoughtSignature?: string;
17618
17663
  time: {
17619
17664
  start: number;
@@ -17637,9 +17682,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17637
17682
  mimeType: string;
17638
17683
  })[];
17639
17684
  details?: any;
17640
- isError: true;
17685
+ isError: false;
17641
17686
  };
17642
- status: "error";
17687
+ status: "completed";
17643
17688
  thoughtSignature?: string;
17644
17689
  time: {
17645
17690
  start: number;
@@ -17665,7 +17710,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17665
17710
  details?: any;
17666
17711
  isError: true;
17667
17712
  };
17668
- status: "skipped";
17713
+ status: "error";
17669
17714
  thoughtSignature?: string;
17670
17715
  time: {
17671
17716
  start: number;
@@ -17691,26 +17736,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17691
17736
  details?: any;
17692
17737
  isError: true;
17693
17738
  };
17694
- status: "aborted";
17739
+ status: "skipped";
17695
17740
  thoughtSignature?: string;
17696
17741
  time: {
17697
17742
  start: number;
17698
17743
  end: number;
17699
17744
  };
17700
17745
  type: "toolCall";
17701
- } | {
17702
- type: "thinking";
17703
- thinking: string;
17704
- thinkingSignature?: string;
17705
- redacted?: boolean;
17706
17746
  } | {
17707
17747
  addedToolNames?: string[];
17708
17748
  arguments: Record<string, any>;
17709
17749
  callID: string;
17710
17750
  name: string;
17711
17751
  namespace?: string;
17712
- partial?: {
17713
- content?: ({
17752
+ result: {
17753
+ content: ({
17714
17754
  type: "text";
17715
17755
  text: string;
17716
17756
  textSignature?: string;
@@ -17720,8 +17760,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17720
17760
  mimeType: string;
17721
17761
  })[];
17722
17762
  details?: any;
17763
+ isError: true;
17723
17764
  };
17724
- status: "running";
17765
+ status: "aborted";
17725
17766
  thoughtSignature?: string;
17726
17767
  time: {
17727
17768
  start: number;
@@ -17915,14 +17956,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17915
17956
  type: "image";
17916
17957
  data: string;
17917
17958
  mimeType: string;
17959
+ } | {
17960
+ type: "thinking";
17961
+ thinking: string;
17962
+ thinkingSignature?: string;
17963
+ redacted?: boolean;
17918
17964
  } | {
17919
17965
  addedToolNames?: string[];
17920
17966
  arguments: Record<string, any>;
17921
17967
  callID: string;
17922
17968
  name: string;
17923
17969
  namespace?: string;
17924
- result: {
17925
- content: ({
17970
+ partial?: {
17971
+ content?: ({
17926
17972
  type: "text";
17927
17973
  text: string;
17928
17974
  textSignature?: string;
@@ -17932,9 +17978,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17932
17978
  mimeType: string;
17933
17979
  })[];
17934
17980
  details?: any;
17935
- isError: false;
17936
17981
  };
17937
- status: "completed";
17982
+ status: "running";
17938
17983
  thoughtSignature?: string;
17939
17984
  time: {
17940
17985
  start: number;
@@ -17958,9 +18003,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17958
18003
  mimeType: string;
17959
18004
  })[];
17960
18005
  details?: any;
17961
- isError: true;
18006
+ isError: false;
17962
18007
  };
17963
- status: "error";
18008
+ status: "completed";
17964
18009
  thoughtSignature?: string;
17965
18010
  time: {
17966
18011
  start: number;
@@ -17986,7 +18031,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17986
18031
  details?: any;
17987
18032
  isError: true;
17988
18033
  };
17989
- status: "skipped";
18034
+ status: "error";
17990
18035
  thoughtSignature?: string;
17991
18036
  time: {
17992
18037
  start: number;
@@ -18012,26 +18057,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18012
18057
  details?: any;
18013
18058
  isError: true;
18014
18059
  };
18015
- status: "aborted";
18060
+ status: "skipped";
18016
18061
  thoughtSignature?: string;
18017
18062
  time: {
18018
18063
  start: number;
18019
18064
  end: number;
18020
18065
  };
18021
18066
  type: "toolCall";
18022
- } | {
18023
- type: "thinking";
18024
- thinking: string;
18025
- thinkingSignature?: string;
18026
- redacted?: boolean;
18027
18067
  } | {
18028
18068
  addedToolNames?: string[];
18029
18069
  arguments: Record<string, any>;
18030
18070
  callID: string;
18031
18071
  name: string;
18032
18072
  namespace?: string;
18033
- partial?: {
18034
- content?: ({
18073
+ result: {
18074
+ content: ({
18035
18075
  type: "text";
18036
18076
  text: string;
18037
18077
  textSignature?: string;
@@ -18041,8 +18081,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18041
18081
  mimeType: string;
18042
18082
  })[];
18043
18083
  details?: any;
18084
+ isError: true;
18044
18085
  };
18045
- status: "running";
18086
+ status: "aborted";
18046
18087
  thoughtSignature?: string;
18047
18088
  time: {
18048
18089
  start: number;
@@ -18217,14 +18258,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18217
18258
  type: "image";
18218
18259
  data: string;
18219
18260
  mimeType: string;
18261
+ } | {
18262
+ type: "thinking";
18263
+ thinking: string;
18264
+ thinkingSignature?: string;
18265
+ redacted?: boolean;
18220
18266
  } | {
18221
18267
  addedToolNames?: string[];
18222
18268
  arguments: Record<string, any>;
18223
18269
  callID: string;
18224
18270
  name: string;
18225
18271
  namespace?: string;
18226
- result: {
18227
- content: ({
18272
+ partial?: {
18273
+ content?: ({
18228
18274
  type: "text";
18229
18275
  text: string;
18230
18276
  textSignature?: string;
@@ -18234,9 +18280,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18234
18280
  mimeType: string;
18235
18281
  })[];
18236
18282
  details?: any;
18237
- isError: false;
18238
18283
  };
18239
- status: "completed";
18284
+ status: "running";
18240
18285
  thoughtSignature?: string;
18241
18286
  time: {
18242
18287
  start: number;
@@ -18260,9 +18305,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18260
18305
  mimeType: string;
18261
18306
  })[];
18262
18307
  details?: any;
18263
- isError: true;
18308
+ isError: false;
18264
18309
  };
18265
- status: "error";
18310
+ status: "completed";
18266
18311
  thoughtSignature?: string;
18267
18312
  time: {
18268
18313
  start: number;
@@ -18288,7 +18333,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18288
18333
  details?: any;
18289
18334
  isError: true;
18290
18335
  };
18291
- status: "skipped";
18336
+ status: "error";
18292
18337
  thoughtSignature?: string;
18293
18338
  time: {
18294
18339
  start: number;
@@ -18314,26 +18359,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18314
18359
  details?: any;
18315
18360
  isError: true;
18316
18361
  };
18317
- status: "aborted";
18362
+ status: "skipped";
18318
18363
  thoughtSignature?: string;
18319
18364
  time: {
18320
18365
  start: number;
18321
18366
  end: number;
18322
18367
  };
18323
18368
  type: "toolCall";
18324
- } | {
18325
- type: "thinking";
18326
- thinking: string;
18327
- thinkingSignature?: string;
18328
- redacted?: boolean;
18329
18369
  } | {
18330
18370
  addedToolNames?: string[];
18331
18371
  arguments: Record<string, any>;
18332
18372
  callID: string;
18333
18373
  name: string;
18334
18374
  namespace?: string;
18335
- partial?: {
18336
- content?: ({
18375
+ result: {
18376
+ content: ({
18337
18377
  type: "text";
18338
18378
  text: string;
18339
18379
  textSignature?: string;
@@ -18343,8 +18383,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18343
18383
  mimeType: string;
18344
18384
  })[];
18345
18385
  details?: any;
18386
+ isError: true;
18346
18387
  };
18347
- status: "running";
18388
+ status: "aborted";
18348
18389
  thoughtSignature?: string;
18349
18390
  time: {
18350
18391
  start: number;
@@ -18547,14 +18588,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18547
18588
  type: "image";
18548
18589
  data: string;
18549
18590
  mimeType: string;
18591
+ } | {
18592
+ type: "thinking";
18593
+ thinking: string;
18594
+ thinkingSignature?: string;
18595
+ redacted?: boolean;
18550
18596
  } | {
18551
18597
  addedToolNames?: string[];
18552
18598
  arguments: Record<string, any>;
18553
18599
  callID: string;
18554
18600
  name: string;
18555
18601
  namespace?: string;
18556
- result: {
18557
- content: ({
18602
+ partial?: {
18603
+ content?: ({
18558
18604
  type: "text";
18559
18605
  text: string;
18560
18606
  textSignature?: string;
@@ -18564,9 +18610,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18564
18610
  mimeType: string;
18565
18611
  })[];
18566
18612
  details?: any;
18567
- isError: false;
18568
18613
  };
18569
- status: "completed";
18614
+ status: "running";
18570
18615
  thoughtSignature?: string;
18571
18616
  time: {
18572
18617
  start: number;
@@ -18590,9 +18635,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18590
18635
  mimeType: string;
18591
18636
  })[];
18592
18637
  details?: any;
18593
- isError: true;
18638
+ isError: false;
18594
18639
  };
18595
- status: "error";
18640
+ status: "completed";
18596
18641
  thoughtSignature?: string;
18597
18642
  time: {
18598
18643
  start: number;
@@ -18618,7 +18663,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18618
18663
  details?: any;
18619
18664
  isError: true;
18620
18665
  };
18621
- status: "skipped";
18666
+ status: "error";
18622
18667
  thoughtSignature?: string;
18623
18668
  time: {
18624
18669
  start: number;
@@ -18644,26 +18689,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18644
18689
  details?: any;
18645
18690
  isError: true;
18646
18691
  };
18647
- status: "aborted";
18692
+ status: "skipped";
18648
18693
  thoughtSignature?: string;
18649
18694
  time: {
18650
18695
  start: number;
18651
18696
  end: number;
18652
18697
  };
18653
18698
  type: "toolCall";
18654
- } | {
18655
- type: "thinking";
18656
- thinking: string;
18657
- thinkingSignature?: string;
18658
- redacted?: boolean;
18659
18699
  } | {
18660
18700
  addedToolNames?: string[];
18661
18701
  arguments: Record<string, any>;
18662
18702
  callID: string;
18663
18703
  name: string;
18664
18704
  namespace?: string;
18665
- partial?: {
18666
- content?: ({
18705
+ result: {
18706
+ content: ({
18667
18707
  type: "text";
18668
18708
  text: string;
18669
18709
  textSignature?: string;
@@ -18673,8 +18713,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18673
18713
  mimeType: string;
18674
18714
  })[];
18675
18715
  details?: any;
18716
+ isError: true;
18676
18717
  };
18677
- status: "running";
18718
+ status: "aborted";
18678
18719
  thoughtSignature?: string;
18679
18720
  time: {
18680
18721
  start: number;
@@ -18849,14 +18890,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18849
18890
  type: "image";
18850
18891
  data: string;
18851
18892
  mimeType: string;
18893
+ } | {
18894
+ type: "thinking";
18895
+ thinking: string;
18896
+ thinkingSignature?: string;
18897
+ redacted?: boolean;
18852
18898
  } | {
18853
18899
  addedToolNames?: string[];
18854
18900
  arguments: Record<string, any>;
18855
18901
  callID: string;
18856
18902
  name: string;
18857
18903
  namespace?: string;
18858
- result: {
18859
- content: ({
18904
+ partial?: {
18905
+ content?: ({
18860
18906
  type: "text";
18861
18907
  text: string;
18862
18908
  textSignature?: string;
@@ -18866,9 +18912,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18866
18912
  mimeType: string;
18867
18913
  })[];
18868
18914
  details?: any;
18869
- isError: false;
18870
18915
  };
18871
- status: "completed";
18916
+ status: "running";
18872
18917
  thoughtSignature?: string;
18873
18918
  time: {
18874
18919
  start: number;
@@ -18892,9 +18937,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18892
18937
  mimeType: string;
18893
18938
  })[];
18894
18939
  details?: any;
18895
- isError: true;
18940
+ isError: false;
18896
18941
  };
18897
- status: "error";
18942
+ status: "completed";
18898
18943
  thoughtSignature?: string;
18899
18944
  time: {
18900
18945
  start: number;
@@ -18920,7 +18965,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18920
18965
  details?: any;
18921
18966
  isError: true;
18922
18967
  };
18923
- status: "skipped";
18968
+ status: "error";
18924
18969
  thoughtSignature?: string;
18925
18970
  time: {
18926
18971
  start: number;
@@ -18946,26 +18991,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18946
18991
  details?: any;
18947
18992
  isError: true;
18948
18993
  };
18949
- status: "aborted";
18994
+ status: "skipped";
18950
18995
  thoughtSignature?: string;
18951
18996
  time: {
18952
18997
  start: number;
18953
18998
  end: number;
18954
18999
  };
18955
19000
  type: "toolCall";
18956
- } | {
18957
- type: "thinking";
18958
- thinking: string;
18959
- thinkingSignature?: string;
18960
- redacted?: boolean;
18961
19001
  } | {
18962
19002
  addedToolNames?: string[];
18963
19003
  arguments: Record<string, any>;
18964
19004
  callID: string;
18965
19005
  name: string;
18966
19006
  namespace?: string;
18967
- partial?: {
18968
- content?: ({
19007
+ result: {
19008
+ content: ({
18969
19009
  type: "text";
18970
19010
  text: string;
18971
19011
  textSignature?: string;
@@ -18975,8 +19015,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18975
19015
  mimeType: string;
18976
19016
  })[];
18977
19017
  details?: any;
19018
+ isError: true;
18978
19019
  };
18979
- status: "running";
19020
+ status: "aborted";
18980
19021
  thoughtSignature?: string;
18981
19022
  time: {
18982
19023
  start: number;
@@ -19170,14 +19211,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19170
19211
  type: "image";
19171
19212
  data: string;
19172
19213
  mimeType: string;
19214
+ } | {
19215
+ type: "thinking";
19216
+ thinking: string;
19217
+ thinkingSignature?: string;
19218
+ redacted?: boolean;
19173
19219
  } | {
19174
19220
  addedToolNames?: string[];
19175
19221
  arguments: Record<string, any>;
19176
19222
  callID: string;
19177
19223
  name: string;
19178
19224
  namespace?: string;
19179
- result: {
19180
- content: ({
19225
+ partial?: {
19226
+ content?: ({
19181
19227
  type: "text";
19182
19228
  text: string;
19183
19229
  textSignature?: string;
@@ -19187,9 +19233,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19187
19233
  mimeType: string;
19188
19234
  })[];
19189
19235
  details?: any;
19190
- isError: false;
19191
19236
  };
19192
- status: "completed";
19237
+ status: "running";
19193
19238
  thoughtSignature?: string;
19194
19239
  time: {
19195
19240
  start: number;
@@ -19213,9 +19258,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19213
19258
  mimeType: string;
19214
19259
  })[];
19215
19260
  details?: any;
19216
- isError: true;
19261
+ isError: false;
19217
19262
  };
19218
- status: "error";
19263
+ status: "completed";
19219
19264
  thoughtSignature?: string;
19220
19265
  time: {
19221
19266
  start: number;
@@ -19241,7 +19286,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19241
19286
  details?: any;
19242
19287
  isError: true;
19243
19288
  };
19244
- status: "skipped";
19289
+ status: "error";
19245
19290
  thoughtSignature?: string;
19246
19291
  time: {
19247
19292
  start: number;
@@ -19267,26 +19312,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19267
19312
  details?: any;
19268
19313
  isError: true;
19269
19314
  };
19270
- status: "aborted";
19315
+ status: "skipped";
19271
19316
  thoughtSignature?: string;
19272
19317
  time: {
19273
19318
  start: number;
19274
19319
  end: number;
19275
19320
  };
19276
19321
  type: "toolCall";
19277
- } | {
19278
- type: "thinking";
19279
- thinking: string;
19280
- thinkingSignature?: string;
19281
- redacted?: boolean;
19282
19322
  } | {
19283
19323
  addedToolNames?: string[];
19284
19324
  arguments: Record<string, any>;
19285
19325
  callID: string;
19286
19326
  name: string;
19287
19327
  namespace?: string;
19288
- partial?: {
19289
- content?: ({
19328
+ result: {
19329
+ content: ({
19290
19330
  type: "text";
19291
19331
  text: string;
19292
19332
  textSignature?: string;
@@ -19296,8 +19336,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19296
19336
  mimeType: string;
19297
19337
  })[];
19298
19338
  details?: any;
19339
+ isError: true;
19299
19340
  };
19300
- status: "running";
19341
+ status: "aborted";
19301
19342
  thoughtSignature?: string;
19302
19343
  time: {
19303
19344
  start: number;
@@ -19472,14 +19513,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19472
19513
  type: "image";
19473
19514
  data: string;
19474
19515
  mimeType: string;
19516
+ } | {
19517
+ type: "thinking";
19518
+ thinking: string;
19519
+ thinkingSignature?: string;
19520
+ redacted?: boolean;
19475
19521
  } | {
19476
19522
  addedToolNames?: string[];
19477
19523
  arguments: Record<string, any>;
19478
19524
  callID: string;
19479
19525
  name: string;
19480
19526
  namespace?: string;
19481
- result: {
19482
- content: ({
19527
+ partial?: {
19528
+ content?: ({
19483
19529
  type: "text";
19484
19530
  text: string;
19485
19531
  textSignature?: string;
@@ -19489,9 +19535,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19489
19535
  mimeType: string;
19490
19536
  })[];
19491
19537
  details?: any;
19492
- isError: false;
19493
19538
  };
19494
- status: "completed";
19539
+ status: "running";
19495
19540
  thoughtSignature?: string;
19496
19541
  time: {
19497
19542
  start: number;
@@ -19515,9 +19560,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19515
19560
  mimeType: string;
19516
19561
  })[];
19517
19562
  details?: any;
19518
- isError: true;
19563
+ isError: false;
19519
19564
  };
19520
- status: "error";
19565
+ status: "completed";
19521
19566
  thoughtSignature?: string;
19522
19567
  time: {
19523
19568
  start: number;
@@ -19543,7 +19588,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19543
19588
  details?: any;
19544
19589
  isError: true;
19545
19590
  };
19546
- status: "skipped";
19591
+ status: "error";
19547
19592
  thoughtSignature?: string;
19548
19593
  time: {
19549
19594
  start: number;
@@ -19569,26 +19614,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19569
19614
  details?: any;
19570
19615
  isError: true;
19571
19616
  };
19572
- status: "aborted";
19617
+ status: "skipped";
19573
19618
  thoughtSignature?: string;
19574
19619
  time: {
19575
19620
  start: number;
19576
19621
  end: number;
19577
19622
  };
19578
19623
  type: "toolCall";
19579
- } | {
19580
- type: "thinking";
19581
- thinking: string;
19582
- thinkingSignature?: string;
19583
- redacted?: boolean;
19584
19624
  } | {
19585
19625
  addedToolNames?: string[];
19586
19626
  arguments: Record<string, any>;
19587
19627
  callID: string;
19588
19628
  name: string;
19589
19629
  namespace?: string;
19590
- partial?: {
19591
- content?: ({
19630
+ result: {
19631
+ content: ({
19592
19632
  type: "text";
19593
19633
  text: string;
19594
19634
  textSignature?: string;
@@ -19598,8 +19638,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19598
19638
  mimeType: string;
19599
19639
  })[];
19600
19640
  details?: any;
19641
+ isError: true;
19601
19642
  };
19602
- status: "running";
19643
+ status: "aborted";
19603
19644
  thoughtSignature?: string;
19604
19645
  time: {
19605
19646
  start: number;
@@ -20787,14 +20828,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20787
20828
  type: "image";
20788
20829
  data: string;
20789
20830
  mimeType: string;
20831
+ } | {
20832
+ type: "thinking";
20833
+ thinking: string;
20834
+ thinkingSignature?: string;
20835
+ redacted?: boolean;
20790
20836
  } | {
20791
20837
  addedToolNames?: string[];
20792
20838
  arguments: Record<string, any>;
20793
20839
  callID: string;
20794
20840
  name: string;
20795
20841
  namespace?: string;
20796
- result: {
20797
- content: ({
20842
+ partial?: {
20843
+ content?: ({
20798
20844
  type: "text";
20799
20845
  text: string;
20800
20846
  textSignature?: string;
@@ -20804,9 +20850,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20804
20850
  mimeType: string;
20805
20851
  })[];
20806
20852
  details?: any;
20807
- isError: false;
20808
20853
  };
20809
- status: "completed";
20854
+ status: "running";
20810
20855
  thoughtSignature?: string;
20811
20856
  time: {
20812
20857
  start: number;
@@ -20830,9 +20875,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20830
20875
  mimeType: string;
20831
20876
  })[];
20832
20877
  details?: any;
20833
- isError: true;
20878
+ isError: false;
20834
20879
  };
20835
- status: "error";
20880
+ status: "completed";
20836
20881
  thoughtSignature?: string;
20837
20882
  time: {
20838
20883
  start: number;
@@ -20858,7 +20903,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20858
20903
  details?: any;
20859
20904
  isError: true;
20860
20905
  };
20861
- status: "skipped";
20906
+ status: "error";
20862
20907
  thoughtSignature?: string;
20863
20908
  time: {
20864
20909
  start: number;
@@ -20884,26 +20929,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20884
20929
  details?: any;
20885
20930
  isError: true;
20886
20931
  };
20887
- status: "aborted";
20932
+ status: "skipped";
20888
20933
  thoughtSignature?: string;
20889
20934
  time: {
20890
20935
  start: number;
20891
20936
  end: number;
20892
20937
  };
20893
20938
  type: "toolCall";
20894
- } | {
20895
- type: "thinking";
20896
- thinking: string;
20897
- thinkingSignature?: string;
20898
- redacted?: boolean;
20899
20939
  } | {
20900
20940
  addedToolNames?: string[];
20901
20941
  arguments: Record<string, any>;
20902
20942
  callID: string;
20903
20943
  name: string;
20904
20944
  namespace?: string;
20905
- partial?: {
20906
- content?: ({
20945
+ result: {
20946
+ content: ({
20907
20947
  type: "text";
20908
20948
  text: string;
20909
20949
  textSignature?: string;
@@ -20913,8 +20953,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20913
20953
  mimeType: string;
20914
20954
  })[];
20915
20955
  details?: any;
20956
+ isError: true;
20916
20957
  };
20917
- status: "running";
20958
+ status: "aborted";
20918
20959
  thoughtSignature?: string;
20919
20960
  time: {
20920
20961
  start: number;
@@ -21089,14 +21130,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21089
21130
  type: "image";
21090
21131
  data: string;
21091
21132
  mimeType: string;
21133
+ } | {
21134
+ type: "thinking";
21135
+ thinking: string;
21136
+ thinkingSignature?: string;
21137
+ redacted?: boolean;
21092
21138
  } | {
21093
21139
  addedToolNames?: string[];
21094
21140
  arguments: Record<string, any>;
21095
21141
  callID: string;
21096
21142
  name: string;
21097
21143
  namespace?: string;
21098
- result: {
21099
- content: ({
21144
+ partial?: {
21145
+ content?: ({
21100
21146
  type: "text";
21101
21147
  text: string;
21102
21148
  textSignature?: string;
@@ -21106,9 +21152,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21106
21152
  mimeType: string;
21107
21153
  })[];
21108
21154
  details?: any;
21109
- isError: false;
21110
21155
  };
21111
- status: "completed";
21156
+ status: "running";
21112
21157
  thoughtSignature?: string;
21113
21158
  time: {
21114
21159
  start: number;
@@ -21132,9 +21177,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21132
21177
  mimeType: string;
21133
21178
  })[];
21134
21179
  details?: any;
21135
- isError: true;
21180
+ isError: false;
21136
21181
  };
21137
- status: "error";
21182
+ status: "completed";
21138
21183
  thoughtSignature?: string;
21139
21184
  time: {
21140
21185
  start: number;
@@ -21160,7 +21205,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21160
21205
  details?: any;
21161
21206
  isError: true;
21162
21207
  };
21163
- status: "skipped";
21208
+ status: "error";
21164
21209
  thoughtSignature?: string;
21165
21210
  time: {
21166
21211
  start: number;
@@ -21186,26 +21231,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21186
21231
  details?: any;
21187
21232
  isError: true;
21188
21233
  };
21189
- status: "aborted";
21234
+ status: "skipped";
21190
21235
  thoughtSignature?: string;
21191
21236
  time: {
21192
21237
  start: number;
21193
21238
  end: number;
21194
21239
  };
21195
21240
  type: "toolCall";
21196
- } | {
21197
- type: "thinking";
21198
- thinking: string;
21199
- thinkingSignature?: string;
21200
- redacted?: boolean;
21201
21241
  } | {
21202
21242
  addedToolNames?: string[];
21203
21243
  arguments: Record<string, any>;
21204
21244
  callID: string;
21205
21245
  name: string;
21206
21246
  namespace?: string;
21207
- partial?: {
21208
- content?: ({
21247
+ result: {
21248
+ content: ({
21209
21249
  type: "text";
21210
21250
  text: string;
21211
21251
  textSignature?: string;
@@ -21215,8 +21255,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21215
21255
  mimeType: string;
21216
21256
  })[];
21217
21257
  details?: any;
21258
+ isError: true;
21218
21259
  };
21219
- status: "running";
21260
+ status: "aborted";
21220
21261
  thoughtSignature?: string;
21221
21262
  time: {
21222
21263
  start: number;
@@ -21409,14 +21450,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21409
21450
  type: "image";
21410
21451
  data: string;
21411
21452
  mimeType: string;
21453
+ } | {
21454
+ type: "thinking";
21455
+ thinking: string;
21456
+ thinkingSignature?: string;
21457
+ redacted?: boolean;
21412
21458
  } | {
21413
21459
  addedToolNames?: string[];
21414
21460
  arguments: Record<string, any>;
21415
21461
  callID: string;
21416
21462
  name: string;
21417
21463
  namespace?: string;
21418
- result: {
21419
- content: ({
21464
+ partial?: {
21465
+ content?: ({
21420
21466
  type: "text";
21421
21467
  text: string;
21422
21468
  textSignature?: string;
@@ -21426,9 +21472,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21426
21472
  mimeType: string;
21427
21473
  })[];
21428
21474
  details?: any;
21429
- isError: false;
21430
21475
  };
21431
- status: "completed";
21476
+ status: "running";
21432
21477
  thoughtSignature?: string;
21433
21478
  time: {
21434
21479
  start: number;
@@ -21452,9 +21497,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21452
21497
  mimeType: string;
21453
21498
  })[];
21454
21499
  details?: any;
21455
- isError: true;
21500
+ isError: false;
21456
21501
  };
21457
- status: "error";
21502
+ status: "completed";
21458
21503
  thoughtSignature?: string;
21459
21504
  time: {
21460
21505
  start: number;
@@ -21480,7 +21525,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21480
21525
  details?: any;
21481
21526
  isError: true;
21482
21527
  };
21483
- status: "skipped";
21528
+ status: "error";
21484
21529
  thoughtSignature?: string;
21485
21530
  time: {
21486
21531
  start: number;
@@ -21506,26 +21551,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21506
21551
  details?: any;
21507
21552
  isError: true;
21508
21553
  };
21509
- status: "aborted";
21554
+ status: "skipped";
21510
21555
  thoughtSignature?: string;
21511
21556
  time: {
21512
21557
  start: number;
21513
21558
  end: number;
21514
21559
  };
21515
21560
  type: "toolCall";
21516
- } | {
21517
- type: "thinking";
21518
- thinking: string;
21519
- thinkingSignature?: string;
21520
- redacted?: boolean;
21521
21561
  } | {
21522
21562
  addedToolNames?: string[];
21523
21563
  arguments: Record<string, any>;
21524
21564
  callID: string;
21525
21565
  name: string;
21526
21566
  namespace?: string;
21527
- partial?: {
21528
- content?: ({
21567
+ result: {
21568
+ content: ({
21529
21569
  type: "text";
21530
21570
  text: string;
21531
21571
  textSignature?: string;
@@ -21535,8 +21575,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21535
21575
  mimeType: string;
21536
21576
  })[];
21537
21577
  details?: any;
21578
+ isError: true;
21538
21579
  };
21539
- status: "running";
21580
+ status: "aborted";
21540
21581
  thoughtSignature?: string;
21541
21582
  time: {
21542
21583
  start: number;
@@ -21711,14 +21752,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21711
21752
  type: "image";
21712
21753
  data: string;
21713
21754
  mimeType: string;
21755
+ } | {
21756
+ type: "thinking";
21757
+ thinking: string;
21758
+ thinkingSignature?: string;
21759
+ redacted?: boolean;
21714
21760
  } | {
21715
21761
  addedToolNames?: string[];
21716
21762
  arguments: Record<string, any>;
21717
21763
  callID: string;
21718
21764
  name: string;
21719
21765
  namespace?: string;
21720
- result: {
21721
- content: ({
21766
+ partial?: {
21767
+ content?: ({
21722
21768
  type: "text";
21723
21769
  text: string;
21724
21770
  textSignature?: string;
@@ -21728,9 +21774,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21728
21774
  mimeType: string;
21729
21775
  })[];
21730
21776
  details?: any;
21731
- isError: false;
21732
21777
  };
21733
- status: "completed";
21778
+ status: "running";
21734
21779
  thoughtSignature?: string;
21735
21780
  time: {
21736
21781
  start: number;
@@ -21754,9 +21799,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21754
21799
  mimeType: string;
21755
21800
  })[];
21756
21801
  details?: any;
21757
- isError: true;
21802
+ isError: false;
21758
21803
  };
21759
- status: "error";
21804
+ status: "completed";
21760
21805
  thoughtSignature?: string;
21761
21806
  time: {
21762
21807
  start: number;
@@ -21782,7 +21827,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21782
21827
  details?: any;
21783
21828
  isError: true;
21784
21829
  };
21785
- status: "skipped";
21830
+ status: "error";
21786
21831
  thoughtSignature?: string;
21787
21832
  time: {
21788
21833
  start: number;
@@ -21808,26 +21853,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21808
21853
  details?: any;
21809
21854
  isError: true;
21810
21855
  };
21811
- status: "aborted";
21856
+ status: "skipped";
21812
21857
  thoughtSignature?: string;
21813
21858
  time: {
21814
21859
  start: number;
21815
21860
  end: number;
21816
21861
  };
21817
21862
  type: "toolCall";
21818
- } | {
21819
- type: "thinking";
21820
- thinking: string;
21821
- thinkingSignature?: string;
21822
- redacted?: boolean;
21823
21863
  } | {
21824
21864
  addedToolNames?: string[];
21825
21865
  arguments: Record<string, any>;
21826
21866
  callID: string;
21827
21867
  name: string;
21828
21868
  namespace?: string;
21829
- partial?: {
21830
- content?: ({
21869
+ result: {
21870
+ content: ({
21831
21871
  type: "text";
21832
21872
  text: string;
21833
21873
  textSignature?: string;
@@ -21837,8 +21877,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21837
21877
  mimeType: string;
21838
21878
  })[];
21839
21879
  details?: any;
21880
+ isError: true;
21840
21881
  };
21841
- status: "running";
21882
+ status: "aborted";
21842
21883
  thoughtSignature?: string;
21843
21884
  time: {
21844
21885
  start: number;
@@ -22041,14 +22082,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22041
22082
  type: "image";
22042
22083
  data: string;
22043
22084
  mimeType: string;
22085
+ } | {
22086
+ type: "thinking";
22087
+ thinking: string;
22088
+ thinkingSignature?: string;
22089
+ redacted?: boolean;
22044
22090
  } | {
22045
22091
  addedToolNames?: string[];
22046
22092
  arguments: Record<string, any>;
22047
22093
  callID: string;
22048
22094
  name: string;
22049
22095
  namespace?: string;
22050
- result: {
22051
- content: ({
22096
+ partial?: {
22097
+ content?: ({
22052
22098
  type: "text";
22053
22099
  text: string;
22054
22100
  textSignature?: string;
@@ -22058,9 +22104,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22058
22104
  mimeType: string;
22059
22105
  })[];
22060
22106
  details?: any;
22061
- isError: false;
22062
22107
  };
22063
- status: "completed";
22108
+ status: "running";
22064
22109
  thoughtSignature?: string;
22065
22110
  time: {
22066
22111
  start: number;
@@ -22084,9 +22129,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22084
22129
  mimeType: string;
22085
22130
  })[];
22086
22131
  details?: any;
22087
- isError: true;
22132
+ isError: false;
22088
22133
  };
22089
- status: "error";
22134
+ status: "completed";
22090
22135
  thoughtSignature?: string;
22091
22136
  time: {
22092
22137
  start: number;
@@ -22112,7 +22157,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22112
22157
  details?: any;
22113
22158
  isError: true;
22114
22159
  };
22115
- status: "skipped";
22160
+ status: "error";
22116
22161
  thoughtSignature?: string;
22117
22162
  time: {
22118
22163
  start: number;
@@ -22138,26 +22183,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22138
22183
  details?: any;
22139
22184
  isError: true;
22140
22185
  };
22141
- status: "aborted";
22186
+ status: "skipped";
22142
22187
  thoughtSignature?: string;
22143
22188
  time: {
22144
22189
  start: number;
22145
22190
  end: number;
22146
22191
  };
22147
22192
  type: "toolCall";
22148
- } | {
22149
- type: "thinking";
22150
- thinking: string;
22151
- thinkingSignature?: string;
22152
- redacted?: boolean;
22153
22193
  } | {
22154
22194
  addedToolNames?: string[];
22155
22195
  arguments: Record<string, any>;
22156
22196
  callID: string;
22157
22197
  name: string;
22158
22198
  namespace?: string;
22159
- partial?: {
22160
- content?: ({
22199
+ result: {
22200
+ content: ({
22161
22201
  type: "text";
22162
22202
  text: string;
22163
22203
  textSignature?: string;
@@ -22167,8 +22207,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22167
22207
  mimeType: string;
22168
22208
  })[];
22169
22209
  details?: any;
22210
+ isError: true;
22170
22211
  };
22171
- status: "running";
22212
+ status: "aborted";
22172
22213
  thoughtSignature?: string;
22173
22214
  time: {
22174
22215
  start: number;
@@ -22343,14 +22384,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22343
22384
  type: "image";
22344
22385
  data: string;
22345
22386
  mimeType: string;
22387
+ } | {
22388
+ type: "thinking";
22389
+ thinking: string;
22390
+ thinkingSignature?: string;
22391
+ redacted?: boolean;
22346
22392
  } | {
22347
22393
  addedToolNames?: string[];
22348
22394
  arguments: Record<string, any>;
22349
22395
  callID: string;
22350
22396
  name: string;
22351
22397
  namespace?: string;
22352
- result: {
22353
- content: ({
22398
+ partial?: {
22399
+ content?: ({
22354
22400
  type: "text";
22355
22401
  text: string;
22356
22402
  textSignature?: string;
@@ -22360,9 +22406,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22360
22406
  mimeType: string;
22361
22407
  })[];
22362
22408
  details?: any;
22363
- isError: false;
22364
22409
  };
22365
- status: "completed";
22410
+ status: "running";
22366
22411
  thoughtSignature?: string;
22367
22412
  time: {
22368
22413
  start: number;
@@ -22386,9 +22431,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22386
22431
  mimeType: string;
22387
22432
  })[];
22388
22433
  details?: any;
22389
- isError: true;
22434
+ isError: false;
22390
22435
  };
22391
- status: "error";
22436
+ status: "completed";
22392
22437
  thoughtSignature?: string;
22393
22438
  time: {
22394
22439
  start: number;
@@ -22414,7 +22459,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22414
22459
  details?: any;
22415
22460
  isError: true;
22416
22461
  };
22417
- status: "skipped";
22462
+ status: "error";
22418
22463
  thoughtSignature?: string;
22419
22464
  time: {
22420
22465
  start: number;
@@ -22440,26 +22485,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22440
22485
  details?: any;
22441
22486
  isError: true;
22442
22487
  };
22443
- status: "aborted";
22488
+ status: "skipped";
22444
22489
  thoughtSignature?: string;
22445
22490
  time: {
22446
22491
  start: number;
22447
22492
  end: number;
22448
22493
  };
22449
22494
  type: "toolCall";
22450
- } | {
22451
- type: "thinking";
22452
- thinking: string;
22453
- thinkingSignature?: string;
22454
- redacted?: boolean;
22455
22495
  } | {
22456
22496
  addedToolNames?: string[];
22457
22497
  arguments: Record<string, any>;
22458
22498
  callID: string;
22459
22499
  name: string;
22460
22500
  namespace?: string;
22461
- partial?: {
22462
- content?: ({
22501
+ result: {
22502
+ content: ({
22463
22503
  type: "text";
22464
22504
  text: string;
22465
22505
  textSignature?: string;
@@ -22469,8 +22509,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22469
22509
  mimeType: string;
22470
22510
  })[];
22471
22511
  details?: any;
22512
+ isError: true;
22472
22513
  };
22473
- status: "running";
22514
+ status: "aborted";
22474
22515
  thoughtSignature?: string;
22475
22516
  time: {
22476
22517
  start: number;
@@ -22664,14 +22705,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22664
22705
  type: "image";
22665
22706
  data: string;
22666
22707
  mimeType: string;
22708
+ } | {
22709
+ type: "thinking";
22710
+ thinking: string;
22711
+ thinkingSignature?: string;
22712
+ redacted?: boolean;
22667
22713
  } | {
22668
22714
  addedToolNames?: string[];
22669
22715
  arguments: Record<string, any>;
22670
22716
  callID: string;
22671
22717
  name: string;
22672
22718
  namespace?: string;
22673
- result: {
22674
- content: ({
22719
+ partial?: {
22720
+ content?: ({
22675
22721
  type: "text";
22676
22722
  text: string;
22677
22723
  textSignature?: string;
@@ -22681,9 +22727,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22681
22727
  mimeType: string;
22682
22728
  })[];
22683
22729
  details?: any;
22684
- isError: false;
22685
22730
  };
22686
- status: "completed";
22731
+ status: "running";
22687
22732
  thoughtSignature?: string;
22688
22733
  time: {
22689
22734
  start: number;
@@ -22707,9 +22752,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22707
22752
  mimeType: string;
22708
22753
  })[];
22709
22754
  details?: any;
22710
- isError: true;
22755
+ isError: false;
22711
22756
  };
22712
- status: "error";
22757
+ status: "completed";
22713
22758
  thoughtSignature?: string;
22714
22759
  time: {
22715
22760
  start: number;
@@ -22735,7 +22780,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22735
22780
  details?: any;
22736
22781
  isError: true;
22737
22782
  };
22738
- status: "skipped";
22783
+ status: "error";
22739
22784
  thoughtSignature?: string;
22740
22785
  time: {
22741
22786
  start: number;
@@ -22761,26 +22806,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22761
22806
  details?: any;
22762
22807
  isError: true;
22763
22808
  };
22764
- status: "aborted";
22809
+ status: "skipped";
22765
22810
  thoughtSignature?: string;
22766
22811
  time: {
22767
22812
  start: number;
22768
22813
  end: number;
22769
22814
  };
22770
22815
  type: "toolCall";
22771
- } | {
22772
- type: "thinking";
22773
- thinking: string;
22774
- thinkingSignature?: string;
22775
- redacted?: boolean;
22776
22816
  } | {
22777
22817
  addedToolNames?: string[];
22778
22818
  arguments: Record<string, any>;
22779
22819
  callID: string;
22780
22820
  name: string;
22781
22821
  namespace?: string;
22782
- partial?: {
22783
- content?: ({
22822
+ result: {
22823
+ content: ({
22784
22824
  type: "text";
22785
22825
  text: string;
22786
22826
  textSignature?: string;
@@ -22790,8 +22830,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22790
22830
  mimeType: string;
22791
22831
  })[];
22792
22832
  details?: any;
22833
+ isError: true;
22793
22834
  };
22794
- status: "running";
22835
+ status: "aborted";
22795
22836
  thoughtSignature?: string;
22796
22837
  time: {
22797
22838
  start: number;
@@ -22966,14 +23007,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22966
23007
  type: "image";
22967
23008
  data: string;
22968
23009
  mimeType: string;
23010
+ } | {
23011
+ type: "thinking";
23012
+ thinking: string;
23013
+ thinkingSignature?: string;
23014
+ redacted?: boolean;
22969
23015
  } | {
22970
23016
  addedToolNames?: string[];
22971
23017
  arguments: Record<string, any>;
22972
23018
  callID: string;
22973
23019
  name: string;
22974
23020
  namespace?: string;
22975
- result: {
22976
- content: ({
23021
+ partial?: {
23022
+ content?: ({
22977
23023
  type: "text";
22978
23024
  text: string;
22979
23025
  textSignature?: string;
@@ -22983,9 +23029,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22983
23029
  mimeType: string;
22984
23030
  })[];
22985
23031
  details?: any;
22986
- isError: false;
22987
23032
  };
22988
- status: "completed";
23033
+ status: "running";
22989
23034
  thoughtSignature?: string;
22990
23035
  time: {
22991
23036
  start: number;
@@ -23009,9 +23054,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23009
23054
  mimeType: string;
23010
23055
  })[];
23011
23056
  details?: any;
23012
- isError: true;
23057
+ isError: false;
23013
23058
  };
23014
- status: "error";
23059
+ status: "completed";
23015
23060
  thoughtSignature?: string;
23016
23061
  time: {
23017
23062
  start: number;
@@ -23037,7 +23082,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23037
23082
  details?: any;
23038
23083
  isError: true;
23039
23084
  };
23040
- status: "skipped";
23085
+ status: "error";
23041
23086
  thoughtSignature?: string;
23042
23087
  time: {
23043
23088
  start: number;
@@ -23063,26 +23108,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23063
23108
  details?: any;
23064
23109
  isError: true;
23065
23110
  };
23066
- status: "aborted";
23111
+ status: "skipped";
23067
23112
  thoughtSignature?: string;
23068
23113
  time: {
23069
23114
  start: number;
23070
23115
  end: number;
23071
23116
  };
23072
23117
  type: "toolCall";
23073
- } | {
23074
- type: "thinking";
23075
- thinking: string;
23076
- thinkingSignature?: string;
23077
- redacted?: boolean;
23078
23118
  } | {
23079
23119
  addedToolNames?: string[];
23080
23120
  arguments: Record<string, any>;
23081
23121
  callID: string;
23082
23122
  name: string;
23083
23123
  namespace?: string;
23084
- partial?: {
23085
- content?: ({
23124
+ result: {
23125
+ content: ({
23086
23126
  type: "text";
23087
23127
  text: string;
23088
23128
  textSignature?: string;
@@ -23092,8 +23132,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23092
23132
  mimeType: string;
23093
23133
  })[];
23094
23134
  details?: any;
23135
+ isError: true;
23095
23136
  };
23096
- status: "running";
23137
+ status: "aborted";
23097
23138
  thoughtSignature?: string;
23098
23139
  time: {
23099
23140
  start: number;
@@ -23296,14 +23337,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23296
23337
  type: "image";
23297
23338
  data: string;
23298
23339
  mimeType: string;
23340
+ } | {
23341
+ type: "thinking";
23342
+ thinking: string;
23343
+ thinkingSignature?: string;
23344
+ redacted?: boolean;
23299
23345
  } | {
23300
23346
  addedToolNames?: string[];
23301
23347
  arguments: Record<string, any>;
23302
23348
  callID: string;
23303
23349
  name: string;
23304
23350
  namespace?: string;
23305
- result: {
23306
- content: ({
23351
+ partial?: {
23352
+ content?: ({
23307
23353
  type: "text";
23308
23354
  text: string;
23309
23355
  textSignature?: string;
@@ -23313,9 +23359,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23313
23359
  mimeType: string;
23314
23360
  })[];
23315
23361
  details?: any;
23316
- isError: false;
23317
23362
  };
23318
- status: "completed";
23363
+ status: "running";
23319
23364
  thoughtSignature?: string;
23320
23365
  time: {
23321
23366
  start: number;
@@ -23339,9 +23384,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23339
23384
  mimeType: string;
23340
23385
  })[];
23341
23386
  details?: any;
23342
- isError: true;
23387
+ isError: false;
23343
23388
  };
23344
- status: "error";
23389
+ status: "completed";
23345
23390
  thoughtSignature?: string;
23346
23391
  time: {
23347
23392
  start: number;
@@ -23367,7 +23412,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23367
23412
  details?: any;
23368
23413
  isError: true;
23369
23414
  };
23370
- status: "skipped";
23415
+ status: "error";
23371
23416
  thoughtSignature?: string;
23372
23417
  time: {
23373
23418
  start: number;
@@ -23393,26 +23438,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23393
23438
  details?: any;
23394
23439
  isError: true;
23395
23440
  };
23396
- status: "aborted";
23441
+ status: "skipped";
23397
23442
  thoughtSignature?: string;
23398
23443
  time: {
23399
23444
  start: number;
23400
23445
  end: number;
23401
23446
  };
23402
23447
  type: "toolCall";
23403
- } | {
23404
- type: "thinking";
23405
- thinking: string;
23406
- thinkingSignature?: string;
23407
- redacted?: boolean;
23408
23448
  } | {
23409
23449
  addedToolNames?: string[];
23410
23450
  arguments: Record<string, any>;
23411
23451
  callID: string;
23412
23452
  name: string;
23413
23453
  namespace?: string;
23414
- partial?: {
23415
- content?: ({
23454
+ result: {
23455
+ content: ({
23416
23456
  type: "text";
23417
23457
  text: string;
23418
23458
  textSignature?: string;
@@ -23422,8 +23462,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23422
23462
  mimeType: string;
23423
23463
  })[];
23424
23464
  details?: any;
23465
+ isError: true;
23425
23466
  };
23426
- status: "running";
23467
+ status: "aborted";
23427
23468
  thoughtSignature?: string;
23428
23469
  time: {
23429
23470
  start: number;
@@ -23598,14 +23639,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23598
23639
  type: "image";
23599
23640
  data: string;
23600
23641
  mimeType: string;
23642
+ } | {
23643
+ type: "thinking";
23644
+ thinking: string;
23645
+ thinkingSignature?: string;
23646
+ redacted?: boolean;
23601
23647
  } | {
23602
23648
  addedToolNames?: string[];
23603
23649
  arguments: Record<string, any>;
23604
23650
  callID: string;
23605
23651
  name: string;
23606
23652
  namespace?: string;
23607
- result: {
23608
- content: ({
23653
+ partial?: {
23654
+ content?: ({
23609
23655
  type: "text";
23610
23656
  text: string;
23611
23657
  textSignature?: string;
@@ -23615,9 +23661,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23615
23661
  mimeType: string;
23616
23662
  })[];
23617
23663
  details?: any;
23618
- isError: false;
23619
23664
  };
23620
- status: "completed";
23665
+ status: "running";
23621
23666
  thoughtSignature?: string;
23622
23667
  time: {
23623
23668
  start: number;
@@ -23641,9 +23686,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23641
23686
  mimeType: string;
23642
23687
  })[];
23643
23688
  details?: any;
23644
- isError: true;
23689
+ isError: false;
23645
23690
  };
23646
- status: "error";
23691
+ status: "completed";
23647
23692
  thoughtSignature?: string;
23648
23693
  time: {
23649
23694
  start: number;
@@ -23669,7 +23714,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23669
23714
  details?: any;
23670
23715
  isError: true;
23671
23716
  };
23672
- status: "skipped";
23717
+ status: "error";
23673
23718
  thoughtSignature?: string;
23674
23719
  time: {
23675
23720
  start: number;
@@ -23695,26 +23740,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23695
23740
  details?: any;
23696
23741
  isError: true;
23697
23742
  };
23698
- status: "aborted";
23743
+ status: "skipped";
23699
23744
  thoughtSignature?: string;
23700
23745
  time: {
23701
23746
  start: number;
23702
23747
  end: number;
23703
23748
  };
23704
23749
  type: "toolCall";
23705
- } | {
23706
- type: "thinking";
23707
- thinking: string;
23708
- thinkingSignature?: string;
23709
- redacted?: boolean;
23710
23750
  } | {
23711
23751
  addedToolNames?: string[];
23712
23752
  arguments: Record<string, any>;
23713
23753
  callID: string;
23714
23754
  name: string;
23715
23755
  namespace?: string;
23716
- partial?: {
23717
- content?: ({
23756
+ result: {
23757
+ content: ({
23718
23758
  type: "text";
23719
23759
  text: string;
23720
23760
  textSignature?: string;
@@ -23724,8 +23764,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23724
23764
  mimeType: string;
23725
23765
  })[];
23726
23766
  details?: any;
23767
+ isError: true;
23727
23768
  };
23728
- status: "running";
23769
+ status: "aborted";
23729
23770
  thoughtSignature?: string;
23730
23771
  time: {
23731
23772
  start: number;
@@ -23919,14 +23960,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23919
23960
  type: "image";
23920
23961
  data: string;
23921
23962
  mimeType: string;
23963
+ } | {
23964
+ type: "thinking";
23965
+ thinking: string;
23966
+ thinkingSignature?: string;
23967
+ redacted?: boolean;
23922
23968
  } | {
23923
23969
  addedToolNames?: string[];
23924
23970
  arguments: Record<string, any>;
23925
23971
  callID: string;
23926
23972
  name: string;
23927
23973
  namespace?: string;
23928
- result: {
23929
- content: ({
23974
+ partial?: {
23975
+ content?: ({
23930
23976
  type: "text";
23931
23977
  text: string;
23932
23978
  textSignature?: string;
@@ -23936,9 +23982,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23936
23982
  mimeType: string;
23937
23983
  })[];
23938
23984
  details?: any;
23939
- isError: false;
23940
23985
  };
23941
- status: "completed";
23986
+ status: "running";
23942
23987
  thoughtSignature?: string;
23943
23988
  time: {
23944
23989
  start: number;
@@ -23962,9 +24007,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23962
24007
  mimeType: string;
23963
24008
  })[];
23964
24009
  details?: any;
23965
- isError: true;
24010
+ isError: false;
23966
24011
  };
23967
- status: "error";
24012
+ status: "completed";
23968
24013
  thoughtSignature?: string;
23969
24014
  time: {
23970
24015
  start: number;
@@ -23990,7 +24035,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23990
24035
  details?: any;
23991
24036
  isError: true;
23992
24037
  };
23993
- status: "skipped";
24038
+ status: "error";
23994
24039
  thoughtSignature?: string;
23995
24040
  time: {
23996
24041
  start: number;
@@ -24016,26 +24061,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24016
24061
  details?: any;
24017
24062
  isError: true;
24018
24063
  };
24019
- status: "aborted";
24064
+ status: "skipped";
24020
24065
  thoughtSignature?: string;
24021
24066
  time: {
24022
24067
  start: number;
24023
24068
  end: number;
24024
24069
  };
24025
24070
  type: "toolCall";
24026
- } | {
24027
- type: "thinking";
24028
- thinking: string;
24029
- thinkingSignature?: string;
24030
- redacted?: boolean;
24031
24071
  } | {
24032
24072
  addedToolNames?: string[];
24033
24073
  arguments: Record<string, any>;
24034
24074
  callID: string;
24035
24075
  name: string;
24036
24076
  namespace?: string;
24037
- partial?: {
24038
- content?: ({
24077
+ result: {
24078
+ content: ({
24039
24079
  type: "text";
24040
24080
  text: string;
24041
24081
  textSignature?: string;
@@ -24045,8 +24085,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24045
24085
  mimeType: string;
24046
24086
  })[];
24047
24087
  details?: any;
24088
+ isError: true;
24048
24089
  };
24049
- status: "running";
24090
+ status: "aborted";
24050
24091
  thoughtSignature?: string;
24051
24092
  time: {
24052
24093
  start: number;
@@ -24221,14 +24262,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24221
24262
  type: "image";
24222
24263
  data: string;
24223
24264
  mimeType: string;
24265
+ } | {
24266
+ type: "thinking";
24267
+ thinking: string;
24268
+ thinkingSignature?: string;
24269
+ redacted?: boolean;
24224
24270
  } | {
24225
24271
  addedToolNames?: string[];
24226
24272
  arguments: Record<string, any>;
24227
24273
  callID: string;
24228
24274
  name: string;
24229
24275
  namespace?: string;
24230
- result: {
24231
- content: ({
24276
+ partial?: {
24277
+ content?: ({
24232
24278
  type: "text";
24233
24279
  text: string;
24234
24280
  textSignature?: string;
@@ -24238,9 +24284,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24238
24284
  mimeType: string;
24239
24285
  })[];
24240
24286
  details?: any;
24241
- isError: false;
24242
24287
  };
24243
- status: "completed";
24288
+ status: "running";
24244
24289
  thoughtSignature?: string;
24245
24290
  time: {
24246
24291
  start: number;
@@ -24264,9 +24309,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24264
24309
  mimeType: string;
24265
24310
  })[];
24266
24311
  details?: any;
24267
- isError: true;
24312
+ isError: false;
24268
24313
  };
24269
- status: "error";
24314
+ status: "completed";
24270
24315
  thoughtSignature?: string;
24271
24316
  time: {
24272
24317
  start: number;
@@ -24292,7 +24337,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24292
24337
  details?: any;
24293
24338
  isError: true;
24294
24339
  };
24295
- status: "skipped";
24340
+ status: "error";
24296
24341
  thoughtSignature?: string;
24297
24342
  time: {
24298
24343
  start: number;
@@ -24318,26 +24363,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24318
24363
  details?: any;
24319
24364
  isError: true;
24320
24365
  };
24321
- status: "aborted";
24366
+ status: "skipped";
24322
24367
  thoughtSignature?: string;
24323
24368
  time: {
24324
24369
  start: number;
24325
24370
  end: number;
24326
24371
  };
24327
24372
  type: "toolCall";
24328
- } | {
24329
- type: "thinking";
24330
- thinking: string;
24331
- thinkingSignature?: string;
24332
- redacted?: boolean;
24333
24373
  } | {
24334
24374
  addedToolNames?: string[];
24335
24375
  arguments: Record<string, any>;
24336
24376
  callID: string;
24337
24377
  name: string;
24338
24378
  namespace?: string;
24339
- partial?: {
24340
- content?: ({
24379
+ result: {
24380
+ content: ({
24341
24381
  type: "text";
24342
24382
  text: string;
24343
24383
  textSignature?: string;
@@ -24347,8 +24387,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24347
24387
  mimeType: string;
24348
24388
  })[];
24349
24389
  details?: any;
24390
+ isError: true;
24350
24391
  };
24351
- status: "running";
24392
+ status: "aborted";
24352
24393
  thoughtSignature?: string;
24353
24394
  time: {
24354
24395
  start: number;