@codeworksh/harness 0.1.0-dev.20261007133219 → 0.2.0-canary.8.1.g763b062a

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.
package/effect.d.mts CHANGED
@@ -1,5 +1,5 @@
1
- import "./index-DjPzwUHF.mjs";
2
- import "./index-DIP2u0Pr.mjs";
1
+ import "./index-BlvIgEtU.mjs";
2
+ import "./index-BEZ8eL--.mjs";
3
3
  import { Cause, Config, Context, Duration, Effect, JsonSchema, Layer, Option, Ref, Schema, Stream } from "effect";
4
4
  import { Event, Message, Model, Protocol } from "@codeworksh/aikit";
5
5
  import { MessageID as ID, SessionID as ID$1 } from "@codeworksh/plugin/ids";
@@ -1530,6 +1530,7 @@ interface Interface$8 {
1530
1530
  readonly cache: string;
1531
1531
  readonly data: string;
1532
1532
  readonly log: string;
1533
+ readonly bin: string;
1533
1534
  }
1534
1535
  declare function make$3(input?: Partial<Interface$8>): Interface$8;
1535
1536
  /**
@@ -1658,6 +1659,7 @@ declare const parse$1: (path: string, source: string) => Effect.Effect<{
1658
1659
  readonly [x: string]: string;
1659
1660
  } | undefined;
1660
1661
  readonly timeoutMs?: number | undefined;
1662
+ readonly idleTimeoutMs?: number | undefined;
1661
1663
  readonly maxRetries?: number | undefined;
1662
1664
  readonly metadata?: {
1663
1665
  readonly [x: string]: unknown;
@@ -1692,6 +1694,7 @@ declare const parse$1: (path: string, source: string) => Effect.Effect<{
1692
1694
  readonly [x: string]: string;
1693
1695
  } | undefined;
1694
1696
  readonly timeoutMs?: number | undefined;
1697
+ readonly idleTimeoutMs?: number | undefined;
1695
1698
  readonly maxRetries?: number | undefined;
1696
1699
  readonly metadata?: {
1697
1700
  readonly [x: string]: unknown;
@@ -1848,6 +1851,7 @@ declare const load$1: (options: Options$4 & {
1848
1851
  readonly [x: string]: string;
1849
1852
  } | undefined;
1850
1853
  readonly timeoutMs?: number | undefined;
1854
+ readonly idleTimeoutMs?: number | undefined;
1851
1855
  readonly maxRetries?: number | undefined;
1852
1856
  readonly metadata?: {
1853
1857
  readonly [x: string]: unknown;
@@ -1882,6 +1886,7 @@ declare const load$1: (options: Options$4 & {
1882
1886
  readonly [x: string]: string;
1883
1887
  } | undefined;
1884
1888
  readonly timeoutMs?: number | undefined;
1889
+ readonly idleTimeoutMs?: number | undefined;
1885
1890
  readonly maxRetries?: number | undefined;
1886
1891
  readonly metadata?: {
1887
1892
  readonly [x: string]: unknown;
@@ -2428,9 +2433,9 @@ interface Interface$4 {
2428
2433
  /**
2429
2434
  * The model and thinking level a session's next exchange runs with: its runtime bindings over
2430
2435
  * its chosen `SessionSchema.Config` over the caller's options over settings, resolved the
2431
- * way {@link snapshot} resolves them. Nothing is looked up in the catalog.
2436
+ * way {@link snapshot} resolves them. The level is the one the model will actually run at.
2432
2437
  */
2433
- readonly configuration: (sessionId: ID$1) => Effect.Effect<Configuration, SettingsError>;
2438
+ readonly configuration: (sessionId: ID$1) => Effect.Effect<Configuration, SettingsError | ModelCatalogError | ModelNotFoundError | ProviderError>;
2434
2439
  /**
2435
2440
  * Capture runtime state for one exchange. Called inside a session drain,
2436
2441
  * where the mount it reads is already open.
@@ -2484,7 +2489,7 @@ rebuild: (root: string | undefined, current: Pool) => Effect.Effect<Pool, {
2484
2489
  readonly message: string;
2485
2490
  }>,
2486
2491
  /** The view a session in `hostDir` runs from: its project root, or the process view. */
2487
- viewOf?: (hostDir: string | undefined) => Effect.Effect<string | undefined>) => Layer.Layer<Service$5, never, Service$8 | Service$17 | Service$16 | Service$7 | Service$6>;
2492
+ viewOf?: (hostDir: string | undefined) => Effect.Effect<string | undefined>) => Layer.Layer<Service$5, never, Service$9 | Service$8 | Service$17 | Service$16 | Service$7 | Service$6>;
2488
2493
  declare namespace run_d_exports {
2489
2494
  export { Interface$3 as Interface, LLMStreamError, ModelCatalogError, ModelNotFoundError, ProviderAuthenticationError, ProviderAuthorizationError, ProviderConfigurationError, ProviderContentPolicyError, ProviderError, ProviderFailureReason, ProviderInvalidRequestError, ProviderInvalidResponseError, ProviderModelUnavailableError, ProviderQuotaError, ProviderRateLimitError, ProviderTimeoutError, ProviderTransportError, ProviderUnavailableError, ProviderUnknownError, RunError, run_d_exports as Runner, SandboxDirectoryNotFoundError, Service$4 as Service };
2490
2495
  }
@@ -2710,21 +2715,6 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
2710
2715
  declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
2711
2716
  declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
2712
2717
  declare const encodeMessage: (message: {
2713
- messageId: string;
2714
- role: "user";
2715
- time: {
2716
- created: number;
2717
- };
2718
- parts: ({
2719
- type: "text";
2720
- text: string;
2721
- textSignature?: string;
2722
- } | {
2723
- type: "image";
2724
- data: string;
2725
- mimeType: string;
2726
- })[];
2727
- } | {
2728
2718
  role: "assistant";
2729
2719
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
2730
2720
  provider: {
@@ -2736,6 +2726,8 @@ declare const encodeMessage: (message: {
2736
2726
  options?: Record<string, any>;
2737
2727
  };
2738
2728
  model: string;
2729
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
2730
+ providerThinkingLevel?: string;
2739
2731
  usage: {
2740
2732
  input: number;
2741
2733
  output: number;
@@ -3024,8 +3016,7 @@ declare const encodeMessage: (message: {
3024
3016
  responseId?: string;
3025
3017
  responseModel?: string;
3026
3018
  messageId: string;
3027
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3028
- declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3019
+ } | {
3029
3020
  messageId: string;
3030
3021
  role: "user";
3031
3022
  time: {
@@ -3040,8 +3031,8 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
3040
3031
  data: string;
3041
3032
  mimeType: string;
3042
3033
  })[];
3043
- }, ContextDecodeError, never>;
3044
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3034
+ }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
3035
+ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3045
3036
  messageId: string;
3046
3037
  role: "user";
3047
3038
  time: {
@@ -3056,7 +3047,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3056
3047
  data: string;
3057
3048
  mimeType: string;
3058
3049
  })[];
3059
- } | {
3050
+ }, ContextDecodeError, never>;
3051
+ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3060
3052
  role: "assistant";
3061
3053
  protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
3062
3054
  provider: {
@@ -3068,6 +3060,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3068
3060
  options?: Record<string, any>;
3069
3061
  };
3070
3062
  model: string;
3063
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
3064
+ providerThinkingLevel?: string;
3071
3065
  usage: {
3072
3066
  input: number;
3073
3067
  output: number;
@@ -3356,6 +3350,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
3356
3350
  responseId?: string;
3357
3351
  responseModel?: string;
3358
3352
  messageId: string;
3353
+ } | {
3354
+ messageId: string;
3355
+ role: "user";
3356
+ time: {
3357
+ created: number;
3358
+ };
3359
+ parts: ({
3360
+ type: "text";
3361
+ text: string;
3362
+ textSignature?: string;
3363
+ } | {
3364
+ type: "image";
3365
+ data: string;
3366
+ mimeType: string;
3367
+ })[];
3359
3368
  }, ContextDecodeError, never>;
3360
3369
  declare namespace context_d_exports {
3361
3370
  export { context_d_exports as Context, assemble_d_exports as ContextAssembly, codec_d_exports as ContextCodec, ContextDecodeError, ContextEncodeError, ContextInvariantError, ContextReadError, EncodedMessage, Interface$1 as Interface, Service$2 as Service, Snapshot, assemblePath, decodeMessage, decodeSyntheticMessage, encodeMessage, encodePart, layer$4 as layer, validateUserMessage };
@@ -3805,6 +3814,7 @@ declare const runtimeOptions: (input: Input, model: Model.Info, signal: AbortSig
3805
3814
  apiKey?: string;
3806
3815
  cacheRetention?: "long" | "none" | "short";
3807
3816
  headers?: Record<string, string>;
3817
+ idleTimeoutMs?: number;
3808
3818
  maxRetries?: number;
3809
3819
  maxTokens?: number;
3810
3820
  metadata?: Record<string, unknown>;
@@ -4114,7 +4124,7 @@ declare const attach: (input: AttachInput) => Effect.Effect<Handle, SessionNotFo
4114
4124
  * {@link create} or {@link attach} is saved with the session and outlives the process; without
4115
4125
  * one, the session follows its settings.
4116
4126
  */
4117
- declare const configuration: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<Configuration, SessionNotFoundError | SettingsError, Service$16 | Service$5>;
4127
+ declare const configuration: (sessionId: string & import("effect/Brand").Brand<"Session.ID">) => Effect.Effect<Configuration, ModelCatalogError | ModelNotFoundError | ProviderError | SessionNotFoundError | SettingsError, Service$16 | Service$5>;
4118
4128
  declare namespace list_d_exports {
4119
4129
  export { ConfigChanged, Definitions, DurableDefinitions, list_d_exports as EventList, ExecutionFailed, ExecutionInterrupted, ExecutionStarted, ExecutionSucceeded, LLMEnded, LLMFailed, LLMStarted, LLMTextDelta, LLMTextEnd, LLMTextStart, LLMThinkingDelta, LLMThinkingEnd, LLMThinkingStart, PluginUpdated, PromptAdmitted, Prompted, PublicDefinitions, RetryFinished, RetryScheduled, SessionForked, ToolProgress, ToolSettled, ToolStarted, TurnAbortCause, TurnAborted, TurnEnded, TurnStarted };
4120
4130
  }
@@ -4659,6 +4669,8 @@ declare const LLMStarted: Schema.Struct<{
4659
4669
  options?: Record<string, any>;
4660
4670
  };
4661
4671
  model: string;
4672
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
4673
+ providerThinkingLevel?: string;
4662
4674
  usage: {
4663
4675
  input: number;
4664
4676
  output: number;
@@ -4795,14 +4807,19 @@ declare const LLMStarted: Schema.Struct<{
4795
4807
  type: "image";
4796
4808
  data: string;
4797
4809
  mimeType: string;
4810
+ } | {
4811
+ type: "thinking";
4812
+ thinking: string;
4813
+ thinkingSignature?: string;
4814
+ redacted?: boolean;
4798
4815
  } | {
4799
4816
  addedToolNames?: string[];
4800
4817
  arguments: Record<string, any>;
4801
4818
  callID: string;
4802
4819
  name: string;
4803
4820
  namespace?: string;
4804
- result: {
4805
- content: ({
4821
+ partial?: {
4822
+ content?: ({
4806
4823
  type: "text";
4807
4824
  text: string;
4808
4825
  textSignature?: string;
@@ -4812,9 +4829,8 @@ declare const LLMStarted: Schema.Struct<{
4812
4829
  mimeType: string;
4813
4830
  })[];
4814
4831
  details?: any;
4815
- isError: false;
4816
4832
  };
4817
- status: "completed";
4833
+ status: "running";
4818
4834
  thoughtSignature?: string;
4819
4835
  time: {
4820
4836
  start: number;
@@ -4838,9 +4854,9 @@ declare const LLMStarted: Schema.Struct<{
4838
4854
  mimeType: string;
4839
4855
  })[];
4840
4856
  details?: any;
4841
- isError: true;
4857
+ isError: false;
4842
4858
  };
4843
- status: "error";
4859
+ status: "completed";
4844
4860
  thoughtSignature?: string;
4845
4861
  time: {
4846
4862
  start: number;
@@ -4866,7 +4882,7 @@ declare const LLMStarted: Schema.Struct<{
4866
4882
  details?: any;
4867
4883
  isError: true;
4868
4884
  };
4869
- status: "skipped";
4885
+ status: "error";
4870
4886
  thoughtSignature?: string;
4871
4887
  time: {
4872
4888
  start: number;
@@ -4892,26 +4908,21 @@ declare const LLMStarted: Schema.Struct<{
4892
4908
  details?: any;
4893
4909
  isError: true;
4894
4910
  };
4895
- status: "aborted";
4911
+ status: "skipped";
4896
4912
  thoughtSignature?: string;
4897
4913
  time: {
4898
4914
  start: number;
4899
4915
  end: number;
4900
4916
  };
4901
4917
  type: "toolCall";
4902
- } | {
4903
- type: "thinking";
4904
- thinking: string;
4905
- thinkingSignature?: string;
4906
- redacted?: boolean;
4907
4918
  } | {
4908
4919
  addedToolNames?: string[];
4909
4920
  arguments: Record<string, any>;
4910
4921
  callID: string;
4911
4922
  name: string;
4912
4923
  namespace?: string;
4913
- partial?: {
4914
- content?: ({
4924
+ result: {
4925
+ content: ({
4915
4926
  type: "text";
4916
4927
  text: string;
4917
4928
  textSignature?: string;
@@ -4921,8 +4932,9 @@ declare const LLMStarted: Schema.Struct<{
4921
4932
  mimeType: string;
4922
4933
  })[];
4923
4934
  details?: any;
4935
+ isError: true;
4924
4936
  };
4925
- status: "running";
4937
+ status: "aborted";
4926
4938
  thoughtSignature?: string;
4927
4939
  time: {
4928
4940
  start: number;
@@ -4959,6 +4971,8 @@ declare const LLMStarted: Schema.Struct<{
4959
4971
  options?: Record<string, any>;
4960
4972
  };
4961
4973
  model: string;
4974
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
4975
+ providerThinkingLevel?: string;
4962
4976
  usage: {
4963
4977
  input: number;
4964
4978
  output: number;
@@ -5095,14 +5109,19 @@ declare const LLMStarted: Schema.Struct<{
5095
5109
  type: "image";
5096
5110
  data: string;
5097
5111
  mimeType: string;
5112
+ } | {
5113
+ type: "thinking";
5114
+ thinking: string;
5115
+ thinkingSignature?: string;
5116
+ redacted?: boolean;
5098
5117
  } | {
5099
5118
  addedToolNames?: string[];
5100
5119
  arguments: Record<string, any>;
5101
5120
  callID: string;
5102
5121
  name: string;
5103
5122
  namespace?: string;
5104
- result: {
5105
- content: ({
5123
+ partial?: {
5124
+ content?: ({
5106
5125
  type: "text";
5107
5126
  text: string;
5108
5127
  textSignature?: string;
@@ -5112,9 +5131,8 @@ declare const LLMStarted: Schema.Struct<{
5112
5131
  mimeType: string;
5113
5132
  })[];
5114
5133
  details?: any;
5115
- isError: false;
5116
5134
  };
5117
- status: "completed";
5135
+ status: "running";
5118
5136
  thoughtSignature?: string;
5119
5137
  time: {
5120
5138
  start: number;
@@ -5138,9 +5156,9 @@ declare const LLMStarted: Schema.Struct<{
5138
5156
  mimeType: string;
5139
5157
  })[];
5140
5158
  details?: any;
5141
- isError: true;
5159
+ isError: false;
5142
5160
  };
5143
- status: "error";
5161
+ status: "completed";
5144
5162
  thoughtSignature?: string;
5145
5163
  time: {
5146
5164
  start: number;
@@ -5166,7 +5184,7 @@ declare const LLMStarted: Schema.Struct<{
5166
5184
  details?: any;
5167
5185
  isError: true;
5168
5186
  };
5169
- status: "skipped";
5187
+ status: "error";
5170
5188
  thoughtSignature?: string;
5171
5189
  time: {
5172
5190
  start: number;
@@ -5192,26 +5210,21 @@ declare const LLMStarted: Schema.Struct<{
5192
5210
  details?: any;
5193
5211
  isError: true;
5194
5212
  };
5195
- status: "aborted";
5213
+ status: "skipped";
5196
5214
  thoughtSignature?: string;
5197
5215
  time: {
5198
5216
  start: number;
5199
5217
  end: number;
5200
5218
  };
5201
5219
  type: "toolCall";
5202
- } | {
5203
- type: "thinking";
5204
- thinking: string;
5205
- thinkingSignature?: string;
5206
- redacted?: boolean;
5207
5220
  } | {
5208
5221
  addedToolNames?: string[];
5209
5222
  arguments: Record<string, any>;
5210
5223
  callID: string;
5211
5224
  name: string;
5212
5225
  namespace?: string;
5213
- partial?: {
5214
- content?: ({
5226
+ result: {
5227
+ content: ({
5215
5228
  type: "text";
5216
5229
  text: string;
5217
5230
  textSignature?: string;
@@ -5221,8 +5234,9 @@ declare const LLMStarted: Schema.Struct<{
5221
5234
  mimeType: string;
5222
5235
  })[];
5223
5236
  details?: any;
5237
+ isError: true;
5224
5238
  };
5225
- status: "running";
5239
+ status: "aborted";
5226
5240
  thoughtSignature?: string;
5227
5241
  time: {
5228
5242
  start: number;
@@ -5277,6 +5291,8 @@ declare const LLMStarted: Schema.Struct<{
5277
5291
  options?: Record<string, any>;
5278
5292
  };
5279
5293
  model: string;
5294
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
5295
+ providerThinkingLevel?: string;
5280
5296
  usage: {
5281
5297
  input: number;
5282
5298
  output: number;
@@ -5413,14 +5429,19 @@ declare const LLMStarted: Schema.Struct<{
5413
5429
  type: "image";
5414
5430
  data: string;
5415
5431
  mimeType: string;
5432
+ } | {
5433
+ type: "thinking";
5434
+ thinking: string;
5435
+ thinkingSignature?: string;
5436
+ redacted?: boolean;
5416
5437
  } | {
5417
5438
  addedToolNames?: string[];
5418
5439
  arguments: Record<string, any>;
5419
5440
  callID: string;
5420
5441
  name: string;
5421
5442
  namespace?: string;
5422
- result: {
5423
- content: ({
5443
+ partial?: {
5444
+ content?: ({
5424
5445
  type: "text";
5425
5446
  text: string;
5426
5447
  textSignature?: string;
@@ -5430,9 +5451,8 @@ declare const LLMStarted: Schema.Struct<{
5430
5451
  mimeType: string;
5431
5452
  })[];
5432
5453
  details?: any;
5433
- isError: false;
5434
5454
  };
5435
- status: "completed";
5455
+ status: "running";
5436
5456
  thoughtSignature?: string;
5437
5457
  time: {
5438
5458
  start: number;
@@ -5456,9 +5476,9 @@ declare const LLMStarted: Schema.Struct<{
5456
5476
  mimeType: string;
5457
5477
  })[];
5458
5478
  details?: any;
5459
- isError: true;
5479
+ isError: false;
5460
5480
  };
5461
- status: "error";
5481
+ status: "completed";
5462
5482
  thoughtSignature?: string;
5463
5483
  time: {
5464
5484
  start: number;
@@ -5484,7 +5504,7 @@ declare const LLMStarted: Schema.Struct<{
5484
5504
  details?: any;
5485
5505
  isError: true;
5486
5506
  };
5487
- status: "skipped";
5507
+ status: "error";
5488
5508
  thoughtSignature?: string;
5489
5509
  time: {
5490
5510
  start: number;
@@ -5510,26 +5530,21 @@ declare const LLMStarted: Schema.Struct<{
5510
5530
  details?: any;
5511
5531
  isError: true;
5512
5532
  };
5513
- status: "aborted";
5533
+ status: "skipped";
5514
5534
  thoughtSignature?: string;
5515
5535
  time: {
5516
5536
  start: number;
5517
5537
  end: number;
5518
5538
  };
5519
5539
  type: "toolCall";
5520
- } | {
5521
- type: "thinking";
5522
- thinking: string;
5523
- thinkingSignature?: string;
5524
- redacted?: boolean;
5525
5540
  } | {
5526
5541
  addedToolNames?: string[];
5527
5542
  arguments: Record<string, any>;
5528
5543
  callID: string;
5529
5544
  name: string;
5530
5545
  namespace?: string;
5531
- partial?: {
5532
- content?: ({
5546
+ result: {
5547
+ content: ({
5533
5548
  type: "text";
5534
5549
  text: string;
5535
5550
  textSignature?: string;
@@ -5539,8 +5554,9 @@ declare const LLMStarted: Schema.Struct<{
5539
5554
  mimeType: string;
5540
5555
  })[];
5541
5556
  details?: any;
5557
+ isError: true;
5542
5558
  };
5543
- status: "running";
5559
+ status: "aborted";
5544
5560
  thoughtSignature?: string;
5545
5561
  time: {
5546
5562
  start: number;
@@ -5577,6 +5593,8 @@ declare const LLMStarted: Schema.Struct<{
5577
5593
  options?: Record<string, any>;
5578
5594
  };
5579
5595
  model: string;
5596
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
5597
+ providerThinkingLevel?: string;
5580
5598
  usage: {
5581
5599
  input: number;
5582
5600
  output: number;
@@ -5713,14 +5731,19 @@ declare const LLMStarted: Schema.Struct<{
5713
5731
  type: "image";
5714
5732
  data: string;
5715
5733
  mimeType: string;
5734
+ } | {
5735
+ type: "thinking";
5736
+ thinking: string;
5737
+ thinkingSignature?: string;
5738
+ redacted?: boolean;
5716
5739
  } | {
5717
5740
  addedToolNames?: string[];
5718
5741
  arguments: Record<string, any>;
5719
5742
  callID: string;
5720
5743
  name: string;
5721
5744
  namespace?: string;
5722
- result: {
5723
- content: ({
5745
+ partial?: {
5746
+ content?: ({
5724
5747
  type: "text";
5725
5748
  text: string;
5726
5749
  textSignature?: string;
@@ -5730,9 +5753,8 @@ declare const LLMStarted: Schema.Struct<{
5730
5753
  mimeType: string;
5731
5754
  })[];
5732
5755
  details?: any;
5733
- isError: false;
5734
5756
  };
5735
- status: "completed";
5757
+ status: "running";
5736
5758
  thoughtSignature?: string;
5737
5759
  time: {
5738
5760
  start: number;
@@ -5756,9 +5778,9 @@ declare const LLMStarted: Schema.Struct<{
5756
5778
  mimeType: string;
5757
5779
  })[];
5758
5780
  details?: any;
5759
- isError: true;
5781
+ isError: false;
5760
5782
  };
5761
- status: "error";
5783
+ status: "completed";
5762
5784
  thoughtSignature?: string;
5763
5785
  time: {
5764
5786
  start: number;
@@ -5784,7 +5806,7 @@ declare const LLMStarted: Schema.Struct<{
5784
5806
  details?: any;
5785
5807
  isError: true;
5786
5808
  };
5787
- status: "skipped";
5809
+ status: "error";
5788
5810
  thoughtSignature?: string;
5789
5811
  time: {
5790
5812
  start: number;
@@ -5810,26 +5832,21 @@ declare const LLMStarted: Schema.Struct<{
5810
5832
  details?: any;
5811
5833
  isError: true;
5812
5834
  };
5813
- status: "aborted";
5835
+ status: "skipped";
5814
5836
  thoughtSignature?: string;
5815
5837
  time: {
5816
5838
  start: number;
5817
5839
  end: number;
5818
5840
  };
5819
5841
  type: "toolCall";
5820
- } | {
5821
- type: "thinking";
5822
- thinking: string;
5823
- thinkingSignature?: string;
5824
- redacted?: boolean;
5825
5842
  } | {
5826
5843
  addedToolNames?: string[];
5827
5844
  arguments: Record<string, any>;
5828
5845
  callID: string;
5829
5846
  name: string;
5830
5847
  namespace?: string;
5831
- partial?: {
5832
- content?: ({
5848
+ result: {
5849
+ content: ({
5833
5850
  type: "text";
5834
5851
  text: string;
5835
5852
  textSignature?: string;
@@ -5839,8 +5856,9 @@ declare const LLMStarted: Schema.Struct<{
5839
5856
  mimeType: string;
5840
5857
  })[];
5841
5858
  details?: any;
5859
+ isError: true;
5842
5860
  };
5843
- status: "running";
5861
+ status: "aborted";
5844
5862
  thoughtSignature?: string;
5845
5863
  time: {
5846
5864
  start: number;
@@ -6198,6 +6216,8 @@ declare const LLMEnded: Schema.Struct<{
6198
6216
  options?: Record<string, any>;
6199
6217
  };
6200
6218
  model: string;
6219
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
6220
+ providerThinkingLevel?: string;
6201
6221
  usage: {
6202
6222
  input: number;
6203
6223
  output: number;
@@ -6334,14 +6354,19 @@ declare const LLMEnded: Schema.Struct<{
6334
6354
  type: "image";
6335
6355
  data: string;
6336
6356
  mimeType: string;
6357
+ } | {
6358
+ type: "thinking";
6359
+ thinking: string;
6360
+ thinkingSignature?: string;
6361
+ redacted?: boolean;
6337
6362
  } | {
6338
6363
  addedToolNames?: string[];
6339
6364
  arguments: Record<string, any>;
6340
6365
  callID: string;
6341
6366
  name: string;
6342
6367
  namespace?: string;
6343
- result: {
6344
- content: ({
6368
+ partial?: {
6369
+ content?: ({
6345
6370
  type: "text";
6346
6371
  text: string;
6347
6372
  textSignature?: string;
@@ -6351,9 +6376,8 @@ declare const LLMEnded: Schema.Struct<{
6351
6376
  mimeType: string;
6352
6377
  })[];
6353
6378
  details?: any;
6354
- isError: false;
6355
6379
  };
6356
- status: "completed";
6380
+ status: "running";
6357
6381
  thoughtSignature?: string;
6358
6382
  time: {
6359
6383
  start: number;
@@ -6377,9 +6401,9 @@ declare const LLMEnded: Schema.Struct<{
6377
6401
  mimeType: string;
6378
6402
  })[];
6379
6403
  details?: any;
6380
- isError: true;
6404
+ isError: false;
6381
6405
  };
6382
- status: "error";
6406
+ status: "completed";
6383
6407
  thoughtSignature?: string;
6384
6408
  time: {
6385
6409
  start: number;
@@ -6405,7 +6429,7 @@ declare const LLMEnded: Schema.Struct<{
6405
6429
  details?: any;
6406
6430
  isError: true;
6407
6431
  };
6408
- status: "skipped";
6432
+ status: "error";
6409
6433
  thoughtSignature?: string;
6410
6434
  time: {
6411
6435
  start: number;
@@ -6431,26 +6455,21 @@ declare const LLMEnded: Schema.Struct<{
6431
6455
  details?: any;
6432
6456
  isError: true;
6433
6457
  };
6434
- status: "aborted";
6458
+ status: "skipped";
6435
6459
  thoughtSignature?: string;
6436
6460
  time: {
6437
6461
  start: number;
6438
6462
  end: number;
6439
6463
  };
6440
6464
  type: "toolCall";
6441
- } | {
6442
- type: "thinking";
6443
- thinking: string;
6444
- thinkingSignature?: string;
6445
- redacted?: boolean;
6446
6465
  } | {
6447
6466
  addedToolNames?: string[];
6448
6467
  arguments: Record<string, any>;
6449
6468
  callID: string;
6450
6469
  name: string;
6451
6470
  namespace?: string;
6452
- partial?: {
6453
- content?: ({
6471
+ result: {
6472
+ content: ({
6454
6473
  type: "text";
6455
6474
  text: string;
6456
6475
  textSignature?: string;
@@ -6460,8 +6479,9 @@ declare const LLMEnded: Schema.Struct<{
6460
6479
  mimeType: string;
6461
6480
  })[];
6462
6481
  details?: any;
6482
+ isError: true;
6463
6483
  };
6464
- status: "running";
6484
+ status: "aborted";
6465
6485
  thoughtSignature?: string;
6466
6486
  time: {
6467
6487
  start: number;
@@ -6498,6 +6518,8 @@ declare const LLMEnded: Schema.Struct<{
6498
6518
  options?: Record<string, any>;
6499
6519
  };
6500
6520
  model: string;
6521
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
6522
+ providerThinkingLevel?: string;
6501
6523
  usage: {
6502
6524
  input: number;
6503
6525
  output: number;
@@ -6634,14 +6656,19 @@ declare const LLMEnded: Schema.Struct<{
6634
6656
  type: "image";
6635
6657
  data: string;
6636
6658
  mimeType: string;
6659
+ } | {
6660
+ type: "thinking";
6661
+ thinking: string;
6662
+ thinkingSignature?: string;
6663
+ redacted?: boolean;
6637
6664
  } | {
6638
6665
  addedToolNames?: string[];
6639
6666
  arguments: Record<string, any>;
6640
6667
  callID: string;
6641
6668
  name: string;
6642
6669
  namespace?: string;
6643
- result: {
6644
- content: ({
6670
+ partial?: {
6671
+ content?: ({
6645
6672
  type: "text";
6646
6673
  text: string;
6647
6674
  textSignature?: string;
@@ -6651,9 +6678,8 @@ declare const LLMEnded: Schema.Struct<{
6651
6678
  mimeType: string;
6652
6679
  })[];
6653
6680
  details?: any;
6654
- isError: false;
6655
6681
  };
6656
- status: "completed";
6682
+ status: "running";
6657
6683
  thoughtSignature?: string;
6658
6684
  time: {
6659
6685
  start: number;
@@ -6677,9 +6703,9 @@ declare const LLMEnded: Schema.Struct<{
6677
6703
  mimeType: string;
6678
6704
  })[];
6679
6705
  details?: any;
6680
- isError: true;
6706
+ isError: false;
6681
6707
  };
6682
- status: "error";
6708
+ status: "completed";
6683
6709
  thoughtSignature?: string;
6684
6710
  time: {
6685
6711
  start: number;
@@ -6705,7 +6731,7 @@ declare const LLMEnded: Schema.Struct<{
6705
6731
  details?: any;
6706
6732
  isError: true;
6707
6733
  };
6708
- status: "skipped";
6734
+ status: "error";
6709
6735
  thoughtSignature?: string;
6710
6736
  time: {
6711
6737
  start: number;
@@ -6731,26 +6757,21 @@ declare const LLMEnded: Schema.Struct<{
6731
6757
  details?: any;
6732
6758
  isError: true;
6733
6759
  };
6734
- status: "aborted";
6760
+ status: "skipped";
6735
6761
  thoughtSignature?: string;
6736
6762
  time: {
6737
6763
  start: number;
6738
6764
  end: number;
6739
6765
  };
6740
6766
  type: "toolCall";
6741
- } | {
6742
- type: "thinking";
6743
- thinking: string;
6744
- thinkingSignature?: string;
6745
- redacted?: boolean;
6746
6767
  } | {
6747
6768
  addedToolNames?: string[];
6748
6769
  arguments: Record<string, any>;
6749
6770
  callID: string;
6750
6771
  name: string;
6751
6772
  namespace?: string;
6752
- partial?: {
6753
- content?: ({
6773
+ result: {
6774
+ content: ({
6754
6775
  type: "text";
6755
6776
  text: string;
6756
6777
  textSignature?: string;
@@ -6760,8 +6781,9 @@ declare const LLMEnded: Schema.Struct<{
6760
6781
  mimeType: string;
6761
6782
  })[];
6762
6783
  details?: any;
6784
+ isError: true;
6763
6785
  };
6764
- status: "running";
6786
+ status: "aborted";
6765
6787
  thoughtSignature?: string;
6766
6788
  time: {
6767
6789
  start: number;
@@ -6817,6 +6839,8 @@ declare const LLMEnded: Schema.Struct<{
6817
6839
  options?: Record<string, any>;
6818
6840
  };
6819
6841
  model: string;
6842
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
6843
+ providerThinkingLevel?: string;
6820
6844
  usage: {
6821
6845
  input: number;
6822
6846
  output: number;
@@ -6953,14 +6977,19 @@ declare const LLMEnded: Schema.Struct<{
6953
6977
  type: "image";
6954
6978
  data: string;
6955
6979
  mimeType: string;
6980
+ } | {
6981
+ type: "thinking";
6982
+ thinking: string;
6983
+ thinkingSignature?: string;
6984
+ redacted?: boolean;
6956
6985
  } | {
6957
6986
  addedToolNames?: string[];
6958
6987
  arguments: Record<string, any>;
6959
6988
  callID: string;
6960
6989
  name: string;
6961
6990
  namespace?: string;
6962
- result: {
6963
- content: ({
6991
+ partial?: {
6992
+ content?: ({
6964
6993
  type: "text";
6965
6994
  text: string;
6966
6995
  textSignature?: string;
@@ -6970,9 +6999,8 @@ declare const LLMEnded: Schema.Struct<{
6970
6999
  mimeType: string;
6971
7000
  })[];
6972
7001
  details?: any;
6973
- isError: false;
6974
7002
  };
6975
- status: "completed";
7003
+ status: "running";
6976
7004
  thoughtSignature?: string;
6977
7005
  time: {
6978
7006
  start: number;
@@ -6996,9 +7024,9 @@ declare const LLMEnded: Schema.Struct<{
6996
7024
  mimeType: string;
6997
7025
  })[];
6998
7026
  details?: any;
6999
- isError: true;
7027
+ isError: false;
7000
7028
  };
7001
- status: "error";
7029
+ status: "completed";
7002
7030
  thoughtSignature?: string;
7003
7031
  time: {
7004
7032
  start: number;
@@ -7024,7 +7052,7 @@ declare const LLMEnded: Schema.Struct<{
7024
7052
  details?: any;
7025
7053
  isError: true;
7026
7054
  };
7027
- status: "skipped";
7055
+ status: "error";
7028
7056
  thoughtSignature?: string;
7029
7057
  time: {
7030
7058
  start: number;
@@ -7050,26 +7078,21 @@ declare const LLMEnded: Schema.Struct<{
7050
7078
  details?: any;
7051
7079
  isError: true;
7052
7080
  };
7053
- status: "aborted";
7081
+ status: "skipped";
7054
7082
  thoughtSignature?: string;
7055
7083
  time: {
7056
7084
  start: number;
7057
7085
  end: number;
7058
7086
  };
7059
7087
  type: "toolCall";
7060
- } | {
7061
- type: "thinking";
7062
- thinking: string;
7063
- thinkingSignature?: string;
7064
- redacted?: boolean;
7065
7088
  } | {
7066
7089
  addedToolNames?: string[];
7067
7090
  arguments: Record<string, any>;
7068
7091
  callID: string;
7069
7092
  name: string;
7070
7093
  namespace?: string;
7071
- partial?: {
7072
- content?: ({
7094
+ result: {
7095
+ content: ({
7073
7096
  type: "text";
7074
7097
  text: string;
7075
7098
  textSignature?: string;
@@ -7079,8 +7102,9 @@ declare const LLMEnded: Schema.Struct<{
7079
7102
  mimeType: string;
7080
7103
  })[];
7081
7104
  details?: any;
7105
+ isError: true;
7082
7106
  };
7083
- status: "running";
7107
+ status: "aborted";
7084
7108
  thoughtSignature?: string;
7085
7109
  time: {
7086
7110
  start: number;
@@ -7117,6 +7141,8 @@ declare const LLMEnded: Schema.Struct<{
7117
7141
  options?: Record<string, any>;
7118
7142
  };
7119
7143
  model: string;
7144
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
7145
+ providerThinkingLevel?: string;
7120
7146
  usage: {
7121
7147
  input: number;
7122
7148
  output: number;
@@ -7253,14 +7279,19 @@ declare const LLMEnded: Schema.Struct<{
7253
7279
  type: "image";
7254
7280
  data: string;
7255
7281
  mimeType: string;
7282
+ } | {
7283
+ type: "thinking";
7284
+ thinking: string;
7285
+ thinkingSignature?: string;
7286
+ redacted?: boolean;
7256
7287
  } | {
7257
7288
  addedToolNames?: string[];
7258
7289
  arguments: Record<string, any>;
7259
7290
  callID: string;
7260
7291
  name: string;
7261
7292
  namespace?: string;
7262
- result: {
7263
- content: ({
7293
+ partial?: {
7294
+ content?: ({
7264
7295
  type: "text";
7265
7296
  text: string;
7266
7297
  textSignature?: string;
@@ -7270,9 +7301,8 @@ declare const LLMEnded: Schema.Struct<{
7270
7301
  mimeType: string;
7271
7302
  })[];
7272
7303
  details?: any;
7273
- isError: false;
7274
7304
  };
7275
- status: "completed";
7305
+ status: "running";
7276
7306
  thoughtSignature?: string;
7277
7307
  time: {
7278
7308
  start: number;
@@ -7296,9 +7326,9 @@ declare const LLMEnded: Schema.Struct<{
7296
7326
  mimeType: string;
7297
7327
  })[];
7298
7328
  details?: any;
7299
- isError: true;
7329
+ isError: false;
7300
7330
  };
7301
- status: "error";
7331
+ status: "completed";
7302
7332
  thoughtSignature?: string;
7303
7333
  time: {
7304
7334
  start: number;
@@ -7324,7 +7354,7 @@ declare const LLMEnded: Schema.Struct<{
7324
7354
  details?: any;
7325
7355
  isError: true;
7326
7356
  };
7327
- status: "skipped";
7357
+ status: "error";
7328
7358
  thoughtSignature?: string;
7329
7359
  time: {
7330
7360
  start: number;
@@ -7350,26 +7380,21 @@ declare const LLMEnded: Schema.Struct<{
7350
7380
  details?: any;
7351
7381
  isError: true;
7352
7382
  };
7353
- status: "aborted";
7383
+ status: "skipped";
7354
7384
  thoughtSignature?: string;
7355
7385
  time: {
7356
7386
  start: number;
7357
7387
  end: number;
7358
7388
  };
7359
7389
  type: "toolCall";
7360
- } | {
7361
- type: "thinking";
7362
- thinking: string;
7363
- thinkingSignature?: string;
7364
- redacted?: boolean;
7365
7390
  } | {
7366
7391
  addedToolNames?: string[];
7367
7392
  arguments: Record<string, any>;
7368
7393
  callID: string;
7369
7394
  name: string;
7370
7395
  namespace?: string;
7371
- partial?: {
7372
- content?: ({
7396
+ result: {
7397
+ content: ({
7373
7398
  type: "text";
7374
7399
  text: string;
7375
7400
  textSignature?: string;
@@ -7379,8 +7404,9 @@ declare const LLMEnded: Schema.Struct<{
7379
7404
  mimeType: string;
7380
7405
  })[];
7381
7406
  details?: any;
7407
+ isError: true;
7382
7408
  };
7383
- status: "running";
7409
+ status: "aborted";
7384
7410
  thoughtSignature?: string;
7385
7411
  time: {
7386
7412
  start: number;
@@ -7448,6 +7474,8 @@ declare const LLMFailed: Schema.Struct<{
7448
7474
  options?: Record<string, any>;
7449
7475
  };
7450
7476
  model: string;
7477
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
7478
+ providerThinkingLevel?: string;
7451
7479
  usage: {
7452
7480
  input: number;
7453
7481
  output: number;
@@ -7584,14 +7612,19 @@ declare const LLMFailed: Schema.Struct<{
7584
7612
  type: "image";
7585
7613
  data: string;
7586
7614
  mimeType: string;
7615
+ } | {
7616
+ type: "thinking";
7617
+ thinking: string;
7618
+ thinkingSignature?: string;
7619
+ redacted?: boolean;
7587
7620
  } | {
7588
7621
  addedToolNames?: string[];
7589
7622
  arguments: Record<string, any>;
7590
7623
  callID: string;
7591
7624
  name: string;
7592
7625
  namespace?: string;
7593
- result: {
7594
- content: ({
7626
+ partial?: {
7627
+ content?: ({
7595
7628
  type: "text";
7596
7629
  text: string;
7597
7630
  textSignature?: string;
@@ -7601,9 +7634,8 @@ declare const LLMFailed: Schema.Struct<{
7601
7634
  mimeType: string;
7602
7635
  })[];
7603
7636
  details?: any;
7604
- isError: false;
7605
7637
  };
7606
- status: "completed";
7638
+ status: "running";
7607
7639
  thoughtSignature?: string;
7608
7640
  time: {
7609
7641
  start: number;
@@ -7627,9 +7659,9 @@ declare const LLMFailed: Schema.Struct<{
7627
7659
  mimeType: string;
7628
7660
  })[];
7629
7661
  details?: any;
7630
- isError: true;
7662
+ isError: false;
7631
7663
  };
7632
- status: "error";
7664
+ status: "completed";
7633
7665
  thoughtSignature?: string;
7634
7666
  time: {
7635
7667
  start: number;
@@ -7655,7 +7687,7 @@ declare const LLMFailed: Schema.Struct<{
7655
7687
  details?: any;
7656
7688
  isError: true;
7657
7689
  };
7658
- status: "skipped";
7690
+ status: "error";
7659
7691
  thoughtSignature?: string;
7660
7692
  time: {
7661
7693
  start: number;
@@ -7681,26 +7713,21 @@ declare const LLMFailed: Schema.Struct<{
7681
7713
  details?: any;
7682
7714
  isError: true;
7683
7715
  };
7684
- status: "aborted";
7716
+ status: "skipped";
7685
7717
  thoughtSignature?: string;
7686
7718
  time: {
7687
7719
  start: number;
7688
7720
  end: number;
7689
7721
  };
7690
7722
  type: "toolCall";
7691
- } | {
7692
- type: "thinking";
7693
- thinking: string;
7694
- thinkingSignature?: string;
7695
- redacted?: boolean;
7696
7723
  } | {
7697
7724
  addedToolNames?: string[];
7698
7725
  arguments: Record<string, any>;
7699
7726
  callID: string;
7700
7727
  name: string;
7701
7728
  namespace?: string;
7702
- partial?: {
7703
- content?: ({
7729
+ result: {
7730
+ content: ({
7704
7731
  type: "text";
7705
7732
  text: string;
7706
7733
  textSignature?: string;
@@ -7710,8 +7737,9 @@ declare const LLMFailed: Schema.Struct<{
7710
7737
  mimeType: string;
7711
7738
  })[];
7712
7739
  details?: any;
7740
+ isError: true;
7713
7741
  };
7714
- status: "running";
7742
+ status: "aborted";
7715
7743
  thoughtSignature?: string;
7716
7744
  time: {
7717
7745
  start: number;
@@ -7748,6 +7776,8 @@ declare const LLMFailed: Schema.Struct<{
7748
7776
  options?: Record<string, any>;
7749
7777
  };
7750
7778
  model: string;
7779
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
7780
+ providerThinkingLevel?: string;
7751
7781
  usage: {
7752
7782
  input: number;
7753
7783
  output: number;
@@ -7884,14 +7914,19 @@ declare const LLMFailed: Schema.Struct<{
7884
7914
  type: "image";
7885
7915
  data: string;
7886
7916
  mimeType: string;
7917
+ } | {
7918
+ type: "thinking";
7919
+ thinking: string;
7920
+ thinkingSignature?: string;
7921
+ redacted?: boolean;
7887
7922
  } | {
7888
7923
  addedToolNames?: string[];
7889
7924
  arguments: Record<string, any>;
7890
7925
  callID: string;
7891
7926
  name: string;
7892
7927
  namespace?: string;
7893
- result: {
7894
- content: ({
7928
+ partial?: {
7929
+ content?: ({
7895
7930
  type: "text";
7896
7931
  text: string;
7897
7932
  textSignature?: string;
@@ -7901,9 +7936,8 @@ declare const LLMFailed: Schema.Struct<{
7901
7936
  mimeType: string;
7902
7937
  })[];
7903
7938
  details?: any;
7904
- isError: false;
7905
7939
  };
7906
- status: "completed";
7940
+ status: "running";
7907
7941
  thoughtSignature?: string;
7908
7942
  time: {
7909
7943
  start: number;
@@ -7927,9 +7961,9 @@ declare const LLMFailed: Schema.Struct<{
7927
7961
  mimeType: string;
7928
7962
  })[];
7929
7963
  details?: any;
7930
- isError: true;
7964
+ isError: false;
7931
7965
  };
7932
- status: "error";
7966
+ status: "completed";
7933
7967
  thoughtSignature?: string;
7934
7968
  time: {
7935
7969
  start: number;
@@ -7955,7 +7989,7 @@ declare const LLMFailed: Schema.Struct<{
7955
7989
  details?: any;
7956
7990
  isError: true;
7957
7991
  };
7958
- status: "skipped";
7992
+ status: "error";
7959
7993
  thoughtSignature?: string;
7960
7994
  time: {
7961
7995
  start: number;
@@ -7981,26 +8015,21 @@ declare const LLMFailed: Schema.Struct<{
7981
8015
  details?: any;
7982
8016
  isError: true;
7983
8017
  };
7984
- status: "aborted";
8018
+ status: "skipped";
7985
8019
  thoughtSignature?: string;
7986
8020
  time: {
7987
8021
  start: number;
7988
8022
  end: number;
7989
8023
  };
7990
8024
  type: "toolCall";
7991
- } | {
7992
- type: "thinking";
7993
- thinking: string;
7994
- thinkingSignature?: string;
7995
- redacted?: boolean;
7996
8025
  } | {
7997
8026
  addedToolNames?: string[];
7998
8027
  arguments: Record<string, any>;
7999
8028
  callID: string;
8000
8029
  name: string;
8001
8030
  namespace?: string;
8002
- partial?: {
8003
- content?: ({
8031
+ result: {
8032
+ content: ({
8004
8033
  type: "text";
8005
8034
  text: string;
8006
8035
  textSignature?: string;
@@ -8010,8 +8039,9 @@ declare const LLMFailed: Schema.Struct<{
8010
8039
  mimeType: string;
8011
8040
  })[];
8012
8041
  details?: any;
8042
+ isError: true;
8013
8043
  };
8014
- status: "running";
8044
+ status: "aborted";
8015
8045
  thoughtSignature?: string;
8016
8046
  time: {
8017
8047
  start: number;
@@ -8067,6 +8097,8 @@ declare const LLMFailed: Schema.Struct<{
8067
8097
  options?: Record<string, any>;
8068
8098
  };
8069
8099
  model: string;
8100
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
8101
+ providerThinkingLevel?: string;
8070
8102
  usage: {
8071
8103
  input: number;
8072
8104
  output: number;
@@ -8203,14 +8235,19 @@ declare const LLMFailed: Schema.Struct<{
8203
8235
  type: "image";
8204
8236
  data: string;
8205
8237
  mimeType: string;
8238
+ } | {
8239
+ type: "thinking";
8240
+ thinking: string;
8241
+ thinkingSignature?: string;
8242
+ redacted?: boolean;
8206
8243
  } | {
8207
8244
  addedToolNames?: string[];
8208
8245
  arguments: Record<string, any>;
8209
8246
  callID: string;
8210
8247
  name: string;
8211
8248
  namespace?: string;
8212
- result: {
8213
- content: ({
8249
+ partial?: {
8250
+ content?: ({
8214
8251
  type: "text";
8215
8252
  text: string;
8216
8253
  textSignature?: string;
@@ -8220,9 +8257,8 @@ declare const LLMFailed: Schema.Struct<{
8220
8257
  mimeType: string;
8221
8258
  })[];
8222
8259
  details?: any;
8223
- isError: false;
8224
8260
  };
8225
- status: "completed";
8261
+ status: "running";
8226
8262
  thoughtSignature?: string;
8227
8263
  time: {
8228
8264
  start: number;
@@ -8246,9 +8282,9 @@ declare const LLMFailed: Schema.Struct<{
8246
8282
  mimeType: string;
8247
8283
  })[];
8248
8284
  details?: any;
8249
- isError: true;
8285
+ isError: false;
8250
8286
  };
8251
- status: "error";
8287
+ status: "completed";
8252
8288
  thoughtSignature?: string;
8253
8289
  time: {
8254
8290
  start: number;
@@ -8274,7 +8310,7 @@ declare const LLMFailed: Schema.Struct<{
8274
8310
  details?: any;
8275
8311
  isError: true;
8276
8312
  };
8277
- status: "skipped";
8313
+ status: "error";
8278
8314
  thoughtSignature?: string;
8279
8315
  time: {
8280
8316
  start: number;
@@ -8300,26 +8336,21 @@ declare const LLMFailed: Schema.Struct<{
8300
8336
  details?: any;
8301
8337
  isError: true;
8302
8338
  };
8303
- status: "aborted";
8339
+ status: "skipped";
8304
8340
  thoughtSignature?: string;
8305
8341
  time: {
8306
8342
  start: number;
8307
8343
  end: number;
8308
8344
  };
8309
8345
  type: "toolCall";
8310
- } | {
8311
- type: "thinking";
8312
- thinking: string;
8313
- thinkingSignature?: string;
8314
- redacted?: boolean;
8315
8346
  } | {
8316
8347
  addedToolNames?: string[];
8317
8348
  arguments: Record<string, any>;
8318
8349
  callID: string;
8319
8350
  name: string;
8320
8351
  namespace?: string;
8321
- partial?: {
8322
- content?: ({
8352
+ result: {
8353
+ content: ({
8323
8354
  type: "text";
8324
8355
  text: string;
8325
8356
  textSignature?: string;
@@ -8329,8 +8360,9 @@ declare const LLMFailed: Schema.Struct<{
8329
8360
  mimeType: string;
8330
8361
  })[];
8331
8362
  details?: any;
8363
+ isError: true;
8332
8364
  };
8333
- status: "running";
8365
+ status: "aborted";
8334
8366
  thoughtSignature?: string;
8335
8367
  time: {
8336
8368
  start: number;
@@ -8367,6 +8399,8 @@ declare const LLMFailed: Schema.Struct<{
8367
8399
  options?: Record<string, any>;
8368
8400
  };
8369
8401
  model: string;
8402
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
8403
+ providerThinkingLevel?: string;
8370
8404
  usage: {
8371
8405
  input: number;
8372
8406
  output: number;
@@ -8503,14 +8537,19 @@ declare const LLMFailed: Schema.Struct<{
8503
8537
  type: "image";
8504
8538
  data: string;
8505
8539
  mimeType: string;
8540
+ } | {
8541
+ type: "thinking";
8542
+ thinking: string;
8543
+ thinkingSignature?: string;
8544
+ redacted?: boolean;
8506
8545
  } | {
8507
8546
  addedToolNames?: string[];
8508
8547
  arguments: Record<string, any>;
8509
8548
  callID: string;
8510
8549
  name: string;
8511
8550
  namespace?: string;
8512
- result: {
8513
- content: ({
8551
+ partial?: {
8552
+ content?: ({
8514
8553
  type: "text";
8515
8554
  text: string;
8516
8555
  textSignature?: string;
@@ -8520,9 +8559,8 @@ declare const LLMFailed: Schema.Struct<{
8520
8559
  mimeType: string;
8521
8560
  })[];
8522
8561
  details?: any;
8523
- isError: false;
8524
8562
  };
8525
- status: "completed";
8563
+ status: "running";
8526
8564
  thoughtSignature?: string;
8527
8565
  time: {
8528
8566
  start: number;
@@ -8546,9 +8584,9 @@ declare const LLMFailed: Schema.Struct<{
8546
8584
  mimeType: string;
8547
8585
  })[];
8548
8586
  details?: any;
8549
- isError: true;
8587
+ isError: false;
8550
8588
  };
8551
- status: "error";
8589
+ status: "completed";
8552
8590
  thoughtSignature?: string;
8553
8591
  time: {
8554
8592
  start: number;
@@ -8574,7 +8612,7 @@ declare const LLMFailed: Schema.Struct<{
8574
8612
  details?: any;
8575
8613
  isError: true;
8576
8614
  };
8577
- status: "skipped";
8615
+ status: "error";
8578
8616
  thoughtSignature?: string;
8579
8617
  time: {
8580
8618
  start: number;
@@ -8600,26 +8638,21 @@ declare const LLMFailed: Schema.Struct<{
8600
8638
  details?: any;
8601
8639
  isError: true;
8602
8640
  };
8603
- status: "aborted";
8641
+ status: "skipped";
8604
8642
  thoughtSignature?: string;
8605
8643
  time: {
8606
8644
  start: number;
8607
8645
  end: number;
8608
8646
  };
8609
8647
  type: "toolCall";
8610
- } | {
8611
- type: "thinking";
8612
- thinking: string;
8613
- thinkingSignature?: string;
8614
- redacted?: boolean;
8615
8648
  } | {
8616
8649
  addedToolNames?: string[];
8617
8650
  arguments: Record<string, any>;
8618
8651
  callID: string;
8619
8652
  name: string;
8620
8653
  namespace?: string;
8621
- partial?: {
8622
- content?: ({
8654
+ result: {
8655
+ content: ({
8623
8656
  type: "text";
8624
8657
  text: string;
8625
8658
  textSignature?: string;
@@ -8629,8 +8662,9 @@ declare const LLMFailed: Schema.Struct<{
8629
8662
  mimeType: string;
8630
8663
  })[];
8631
8664
  details?: any;
8665
+ isError: true;
8632
8666
  };
8633
- status: "running";
8667
+ status: "aborted";
8634
8668
  thoughtSignature?: string;
8635
8669
  time: {
8636
8670
  start: number;
@@ -10240,6 +10274,8 @@ declare const Definitions: readonly [Schema.Struct<{
10240
10274
  options?: Record<string, any>;
10241
10275
  };
10242
10276
  model: string;
10277
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
10278
+ providerThinkingLevel?: string;
10243
10279
  usage: {
10244
10280
  input: number;
10245
10281
  output: number;
@@ -10376,14 +10412,19 @@ declare const Definitions: readonly [Schema.Struct<{
10376
10412
  type: "image";
10377
10413
  data: string;
10378
10414
  mimeType: string;
10415
+ } | {
10416
+ type: "thinking";
10417
+ thinking: string;
10418
+ thinkingSignature?: string;
10419
+ redacted?: boolean;
10379
10420
  } | {
10380
10421
  addedToolNames?: string[];
10381
10422
  arguments: Record<string, any>;
10382
10423
  callID: string;
10383
10424
  name: string;
10384
10425
  namespace?: string;
10385
- result: {
10386
- content: ({
10426
+ partial?: {
10427
+ content?: ({
10387
10428
  type: "text";
10388
10429
  text: string;
10389
10430
  textSignature?: string;
@@ -10393,9 +10434,8 @@ declare const Definitions: readonly [Schema.Struct<{
10393
10434
  mimeType: string;
10394
10435
  })[];
10395
10436
  details?: any;
10396
- isError: false;
10397
10437
  };
10398
- status: "completed";
10438
+ status: "running";
10399
10439
  thoughtSignature?: string;
10400
10440
  time: {
10401
10441
  start: number;
@@ -10419,9 +10459,9 @@ declare const Definitions: readonly [Schema.Struct<{
10419
10459
  mimeType: string;
10420
10460
  })[];
10421
10461
  details?: any;
10422
- isError: true;
10462
+ isError: false;
10423
10463
  };
10424
- status: "error";
10464
+ status: "completed";
10425
10465
  thoughtSignature?: string;
10426
10466
  time: {
10427
10467
  start: number;
@@ -10447,7 +10487,7 @@ declare const Definitions: readonly [Schema.Struct<{
10447
10487
  details?: any;
10448
10488
  isError: true;
10449
10489
  };
10450
- status: "skipped";
10490
+ status: "error";
10451
10491
  thoughtSignature?: string;
10452
10492
  time: {
10453
10493
  start: number;
@@ -10473,26 +10513,21 @@ declare const Definitions: readonly [Schema.Struct<{
10473
10513
  details?: any;
10474
10514
  isError: true;
10475
10515
  };
10476
- status: "aborted";
10516
+ status: "skipped";
10477
10517
  thoughtSignature?: string;
10478
10518
  time: {
10479
10519
  start: number;
10480
10520
  end: number;
10481
10521
  };
10482
10522
  type: "toolCall";
10483
- } | {
10484
- type: "thinking";
10485
- thinking: string;
10486
- thinkingSignature?: string;
10487
- redacted?: boolean;
10488
10523
  } | {
10489
10524
  addedToolNames?: string[];
10490
10525
  arguments: Record<string, any>;
10491
10526
  callID: string;
10492
10527
  name: string;
10493
10528
  namespace?: string;
10494
- partial?: {
10495
- content?: ({
10529
+ result: {
10530
+ content: ({
10496
10531
  type: "text";
10497
10532
  text: string;
10498
10533
  textSignature?: string;
@@ -10502,8 +10537,9 @@ declare const Definitions: readonly [Schema.Struct<{
10502
10537
  mimeType: string;
10503
10538
  })[];
10504
10539
  details?: any;
10540
+ isError: true;
10505
10541
  };
10506
- status: "running";
10542
+ status: "aborted";
10507
10543
  thoughtSignature?: string;
10508
10544
  time: {
10509
10545
  start: number;
@@ -10540,6 +10576,8 @@ declare const Definitions: readonly [Schema.Struct<{
10540
10576
  options?: Record<string, any>;
10541
10577
  };
10542
10578
  model: string;
10579
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
10580
+ providerThinkingLevel?: string;
10543
10581
  usage: {
10544
10582
  input: number;
10545
10583
  output: number;
@@ -10676,14 +10714,19 @@ declare const Definitions: readonly [Schema.Struct<{
10676
10714
  type: "image";
10677
10715
  data: string;
10678
10716
  mimeType: string;
10717
+ } | {
10718
+ type: "thinking";
10719
+ thinking: string;
10720
+ thinkingSignature?: string;
10721
+ redacted?: boolean;
10679
10722
  } | {
10680
10723
  addedToolNames?: string[];
10681
10724
  arguments: Record<string, any>;
10682
10725
  callID: string;
10683
10726
  name: string;
10684
10727
  namespace?: string;
10685
- result: {
10686
- content: ({
10728
+ partial?: {
10729
+ content?: ({
10687
10730
  type: "text";
10688
10731
  text: string;
10689
10732
  textSignature?: string;
@@ -10693,9 +10736,8 @@ declare const Definitions: readonly [Schema.Struct<{
10693
10736
  mimeType: string;
10694
10737
  })[];
10695
10738
  details?: any;
10696
- isError: false;
10697
10739
  };
10698
- status: "completed";
10740
+ status: "running";
10699
10741
  thoughtSignature?: string;
10700
10742
  time: {
10701
10743
  start: number;
@@ -10719,9 +10761,9 @@ declare const Definitions: readonly [Schema.Struct<{
10719
10761
  mimeType: string;
10720
10762
  })[];
10721
10763
  details?: any;
10722
- isError: true;
10764
+ isError: false;
10723
10765
  };
10724
- status: "error";
10766
+ status: "completed";
10725
10767
  thoughtSignature?: string;
10726
10768
  time: {
10727
10769
  start: number;
@@ -10747,7 +10789,7 @@ declare const Definitions: readonly [Schema.Struct<{
10747
10789
  details?: any;
10748
10790
  isError: true;
10749
10791
  };
10750
- status: "skipped";
10792
+ status: "error";
10751
10793
  thoughtSignature?: string;
10752
10794
  time: {
10753
10795
  start: number;
@@ -10773,26 +10815,21 @@ declare const Definitions: readonly [Schema.Struct<{
10773
10815
  details?: any;
10774
10816
  isError: true;
10775
10817
  };
10776
- status: "aborted";
10818
+ status: "skipped";
10777
10819
  thoughtSignature?: string;
10778
10820
  time: {
10779
10821
  start: number;
10780
10822
  end: number;
10781
10823
  };
10782
10824
  type: "toolCall";
10783
- } | {
10784
- type: "thinking";
10785
- thinking: string;
10786
- thinkingSignature?: string;
10787
- redacted?: boolean;
10788
10825
  } | {
10789
10826
  addedToolNames?: string[];
10790
10827
  arguments: Record<string, any>;
10791
10828
  callID: string;
10792
10829
  name: string;
10793
10830
  namespace?: string;
10794
- partial?: {
10795
- content?: ({
10831
+ result: {
10832
+ content: ({
10796
10833
  type: "text";
10797
10834
  text: string;
10798
10835
  textSignature?: string;
@@ -10802,8 +10839,9 @@ declare const Definitions: readonly [Schema.Struct<{
10802
10839
  mimeType: string;
10803
10840
  })[];
10804
10841
  details?: any;
10842
+ isError: true;
10805
10843
  };
10806
- status: "running";
10844
+ status: "aborted";
10807
10845
  thoughtSignature?: string;
10808
10846
  time: {
10809
10847
  start: number;
@@ -10858,6 +10896,8 @@ declare const Definitions: readonly [Schema.Struct<{
10858
10896
  options?: Record<string, any>;
10859
10897
  };
10860
10898
  model: string;
10899
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
10900
+ providerThinkingLevel?: string;
10861
10901
  usage: {
10862
10902
  input: number;
10863
10903
  output: number;
@@ -10994,14 +11034,19 @@ declare const Definitions: readonly [Schema.Struct<{
10994
11034
  type: "image";
10995
11035
  data: string;
10996
11036
  mimeType: string;
11037
+ } | {
11038
+ type: "thinking";
11039
+ thinking: string;
11040
+ thinkingSignature?: string;
11041
+ redacted?: boolean;
10997
11042
  } | {
10998
11043
  addedToolNames?: string[];
10999
11044
  arguments: Record<string, any>;
11000
11045
  callID: string;
11001
11046
  name: string;
11002
11047
  namespace?: string;
11003
- result: {
11004
- content: ({
11048
+ partial?: {
11049
+ content?: ({
11005
11050
  type: "text";
11006
11051
  text: string;
11007
11052
  textSignature?: string;
@@ -11011,9 +11056,8 @@ declare const Definitions: readonly [Schema.Struct<{
11011
11056
  mimeType: string;
11012
11057
  })[];
11013
11058
  details?: any;
11014
- isError: false;
11015
11059
  };
11016
- status: "completed";
11060
+ status: "running";
11017
11061
  thoughtSignature?: string;
11018
11062
  time: {
11019
11063
  start: number;
@@ -11037,9 +11081,9 @@ declare const Definitions: readonly [Schema.Struct<{
11037
11081
  mimeType: string;
11038
11082
  })[];
11039
11083
  details?: any;
11040
- isError: true;
11084
+ isError: false;
11041
11085
  };
11042
- status: "error";
11086
+ status: "completed";
11043
11087
  thoughtSignature?: string;
11044
11088
  time: {
11045
11089
  start: number;
@@ -11065,7 +11109,7 @@ declare const Definitions: readonly [Schema.Struct<{
11065
11109
  details?: any;
11066
11110
  isError: true;
11067
11111
  };
11068
- status: "skipped";
11112
+ status: "error";
11069
11113
  thoughtSignature?: string;
11070
11114
  time: {
11071
11115
  start: number;
@@ -11091,26 +11135,21 @@ declare const Definitions: readonly [Schema.Struct<{
11091
11135
  details?: any;
11092
11136
  isError: true;
11093
11137
  };
11094
- status: "aborted";
11138
+ status: "skipped";
11095
11139
  thoughtSignature?: string;
11096
11140
  time: {
11097
11141
  start: number;
11098
11142
  end: number;
11099
11143
  };
11100
11144
  type: "toolCall";
11101
- } | {
11102
- type: "thinking";
11103
- thinking: string;
11104
- thinkingSignature?: string;
11105
- redacted?: boolean;
11106
11145
  } | {
11107
11146
  addedToolNames?: string[];
11108
11147
  arguments: Record<string, any>;
11109
11148
  callID: string;
11110
11149
  name: string;
11111
11150
  namespace?: string;
11112
- partial?: {
11113
- content?: ({
11151
+ result: {
11152
+ content: ({
11114
11153
  type: "text";
11115
11154
  text: string;
11116
11155
  textSignature?: string;
@@ -11120,8 +11159,9 @@ declare const Definitions: readonly [Schema.Struct<{
11120
11159
  mimeType: string;
11121
11160
  })[];
11122
11161
  details?: any;
11162
+ isError: true;
11123
11163
  };
11124
- status: "running";
11164
+ status: "aborted";
11125
11165
  thoughtSignature?: string;
11126
11166
  time: {
11127
11167
  start: number;
@@ -11158,6 +11198,8 @@ declare const Definitions: readonly [Schema.Struct<{
11158
11198
  options?: Record<string, any>;
11159
11199
  };
11160
11200
  model: string;
11201
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
11202
+ providerThinkingLevel?: string;
11161
11203
  usage: {
11162
11204
  input: number;
11163
11205
  output: number;
@@ -11294,14 +11336,19 @@ declare const Definitions: readonly [Schema.Struct<{
11294
11336
  type: "image";
11295
11337
  data: string;
11296
11338
  mimeType: string;
11339
+ } | {
11340
+ type: "thinking";
11341
+ thinking: string;
11342
+ thinkingSignature?: string;
11343
+ redacted?: boolean;
11297
11344
  } | {
11298
11345
  addedToolNames?: string[];
11299
11346
  arguments: Record<string, any>;
11300
11347
  callID: string;
11301
11348
  name: string;
11302
11349
  namespace?: string;
11303
- result: {
11304
- content: ({
11350
+ partial?: {
11351
+ content?: ({
11305
11352
  type: "text";
11306
11353
  text: string;
11307
11354
  textSignature?: string;
@@ -11311,9 +11358,8 @@ declare const Definitions: readonly [Schema.Struct<{
11311
11358
  mimeType: string;
11312
11359
  })[];
11313
11360
  details?: any;
11314
- isError: false;
11315
11361
  };
11316
- status: "completed";
11362
+ status: "running";
11317
11363
  thoughtSignature?: string;
11318
11364
  time: {
11319
11365
  start: number;
@@ -11337,9 +11383,9 @@ declare const Definitions: readonly [Schema.Struct<{
11337
11383
  mimeType: string;
11338
11384
  })[];
11339
11385
  details?: any;
11340
- isError: true;
11386
+ isError: false;
11341
11387
  };
11342
- status: "error";
11388
+ status: "completed";
11343
11389
  thoughtSignature?: string;
11344
11390
  time: {
11345
11391
  start: number;
@@ -11365,7 +11411,7 @@ declare const Definitions: readonly [Schema.Struct<{
11365
11411
  details?: any;
11366
11412
  isError: true;
11367
11413
  };
11368
- status: "skipped";
11414
+ status: "error";
11369
11415
  thoughtSignature?: string;
11370
11416
  time: {
11371
11417
  start: number;
@@ -11391,26 +11437,21 @@ declare const Definitions: readonly [Schema.Struct<{
11391
11437
  details?: any;
11392
11438
  isError: true;
11393
11439
  };
11394
- status: "aborted";
11440
+ status: "skipped";
11395
11441
  thoughtSignature?: string;
11396
11442
  time: {
11397
11443
  start: number;
11398
11444
  end: number;
11399
11445
  };
11400
11446
  type: "toolCall";
11401
- } | {
11402
- type: "thinking";
11403
- thinking: string;
11404
- thinkingSignature?: string;
11405
- redacted?: boolean;
11406
11447
  } | {
11407
11448
  addedToolNames?: string[];
11408
11449
  arguments: Record<string, any>;
11409
11450
  callID: string;
11410
11451
  name: string;
11411
11452
  namespace?: string;
11412
- partial?: {
11413
- content?: ({
11453
+ result: {
11454
+ content: ({
11414
11455
  type: "text";
11415
11456
  text: string;
11416
11457
  textSignature?: string;
@@ -11420,8 +11461,9 @@ declare const Definitions: readonly [Schema.Struct<{
11420
11461
  mimeType: string;
11421
11462
  })[];
11422
11463
  details?: any;
11464
+ isError: true;
11423
11465
  };
11424
- status: "running";
11466
+ status: "aborted";
11425
11467
  thoughtSignature?: string;
11426
11468
  time: {
11427
11469
  start: number;
@@ -11764,6 +11806,8 @@ declare const Definitions: readonly [Schema.Struct<{
11764
11806
  options?: Record<string, any>;
11765
11807
  };
11766
11808
  model: string;
11809
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
11810
+ providerThinkingLevel?: string;
11767
11811
  usage: {
11768
11812
  input: number;
11769
11813
  output: number;
@@ -11900,14 +11944,19 @@ declare const Definitions: readonly [Schema.Struct<{
11900
11944
  type: "image";
11901
11945
  data: string;
11902
11946
  mimeType: string;
11947
+ } | {
11948
+ type: "thinking";
11949
+ thinking: string;
11950
+ thinkingSignature?: string;
11951
+ redacted?: boolean;
11903
11952
  } | {
11904
11953
  addedToolNames?: string[];
11905
11954
  arguments: Record<string, any>;
11906
11955
  callID: string;
11907
11956
  name: string;
11908
11957
  namespace?: string;
11909
- result: {
11910
- content: ({
11958
+ partial?: {
11959
+ content?: ({
11911
11960
  type: "text";
11912
11961
  text: string;
11913
11962
  textSignature?: string;
@@ -11917,9 +11966,8 @@ declare const Definitions: readonly [Schema.Struct<{
11917
11966
  mimeType: string;
11918
11967
  })[];
11919
11968
  details?: any;
11920
- isError: false;
11921
11969
  };
11922
- status: "completed";
11970
+ status: "running";
11923
11971
  thoughtSignature?: string;
11924
11972
  time: {
11925
11973
  start: number;
@@ -11943,9 +11991,9 @@ declare const Definitions: readonly [Schema.Struct<{
11943
11991
  mimeType: string;
11944
11992
  })[];
11945
11993
  details?: any;
11946
- isError: true;
11994
+ isError: false;
11947
11995
  };
11948
- status: "error";
11996
+ status: "completed";
11949
11997
  thoughtSignature?: string;
11950
11998
  time: {
11951
11999
  start: number;
@@ -11971,7 +12019,7 @@ declare const Definitions: readonly [Schema.Struct<{
11971
12019
  details?: any;
11972
12020
  isError: true;
11973
12021
  };
11974
- status: "skipped";
12022
+ status: "error";
11975
12023
  thoughtSignature?: string;
11976
12024
  time: {
11977
12025
  start: number;
@@ -11997,26 +12045,21 @@ declare const Definitions: readonly [Schema.Struct<{
11997
12045
  details?: any;
11998
12046
  isError: true;
11999
12047
  };
12000
- status: "aborted";
12048
+ status: "skipped";
12001
12049
  thoughtSignature?: string;
12002
12050
  time: {
12003
12051
  start: number;
12004
12052
  end: number;
12005
12053
  };
12006
12054
  type: "toolCall";
12007
- } | {
12008
- type: "thinking";
12009
- thinking: string;
12010
- thinkingSignature?: string;
12011
- redacted?: boolean;
12012
12055
  } | {
12013
12056
  addedToolNames?: string[];
12014
12057
  arguments: Record<string, any>;
12015
12058
  callID: string;
12016
12059
  name: string;
12017
12060
  namespace?: string;
12018
- partial?: {
12019
- content?: ({
12061
+ result: {
12062
+ content: ({
12020
12063
  type: "text";
12021
12064
  text: string;
12022
12065
  textSignature?: string;
@@ -12026,8 +12069,9 @@ declare const Definitions: readonly [Schema.Struct<{
12026
12069
  mimeType: string;
12027
12070
  })[];
12028
12071
  details?: any;
12072
+ isError: true;
12029
12073
  };
12030
- status: "running";
12074
+ status: "aborted";
12031
12075
  thoughtSignature?: string;
12032
12076
  time: {
12033
12077
  start: number;
@@ -12064,6 +12108,8 @@ declare const Definitions: readonly [Schema.Struct<{
12064
12108
  options?: Record<string, any>;
12065
12109
  };
12066
12110
  model: string;
12111
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
12112
+ providerThinkingLevel?: string;
12067
12113
  usage: {
12068
12114
  input: number;
12069
12115
  output: number;
@@ -12200,14 +12246,19 @@ declare const Definitions: readonly [Schema.Struct<{
12200
12246
  type: "image";
12201
12247
  data: string;
12202
12248
  mimeType: string;
12249
+ } | {
12250
+ type: "thinking";
12251
+ thinking: string;
12252
+ thinkingSignature?: string;
12253
+ redacted?: boolean;
12203
12254
  } | {
12204
12255
  addedToolNames?: string[];
12205
12256
  arguments: Record<string, any>;
12206
12257
  callID: string;
12207
12258
  name: string;
12208
12259
  namespace?: string;
12209
- result: {
12210
- content: ({
12260
+ partial?: {
12261
+ content?: ({
12211
12262
  type: "text";
12212
12263
  text: string;
12213
12264
  textSignature?: string;
@@ -12217,9 +12268,8 @@ declare const Definitions: readonly [Schema.Struct<{
12217
12268
  mimeType: string;
12218
12269
  })[];
12219
12270
  details?: any;
12220
- isError: false;
12221
12271
  };
12222
- status: "completed";
12272
+ status: "running";
12223
12273
  thoughtSignature?: string;
12224
12274
  time: {
12225
12275
  start: number;
@@ -12243,9 +12293,9 @@ declare const Definitions: readonly [Schema.Struct<{
12243
12293
  mimeType: string;
12244
12294
  })[];
12245
12295
  details?: any;
12246
- isError: true;
12296
+ isError: false;
12247
12297
  };
12248
- status: "error";
12298
+ status: "completed";
12249
12299
  thoughtSignature?: string;
12250
12300
  time: {
12251
12301
  start: number;
@@ -12271,7 +12321,7 @@ declare const Definitions: readonly [Schema.Struct<{
12271
12321
  details?: any;
12272
12322
  isError: true;
12273
12323
  };
12274
- status: "skipped";
12324
+ status: "error";
12275
12325
  thoughtSignature?: string;
12276
12326
  time: {
12277
12327
  start: number;
@@ -12297,26 +12347,21 @@ declare const Definitions: readonly [Schema.Struct<{
12297
12347
  details?: any;
12298
12348
  isError: true;
12299
12349
  };
12300
- status: "aborted";
12350
+ status: "skipped";
12301
12351
  thoughtSignature?: string;
12302
12352
  time: {
12303
12353
  start: number;
12304
12354
  end: number;
12305
12355
  };
12306
12356
  type: "toolCall";
12307
- } | {
12308
- type: "thinking";
12309
- thinking: string;
12310
- thinkingSignature?: string;
12311
- redacted?: boolean;
12312
12357
  } | {
12313
12358
  addedToolNames?: string[];
12314
12359
  arguments: Record<string, any>;
12315
12360
  callID: string;
12316
12361
  name: string;
12317
12362
  namespace?: string;
12318
- partial?: {
12319
- content?: ({
12363
+ result: {
12364
+ content: ({
12320
12365
  type: "text";
12321
12366
  text: string;
12322
12367
  textSignature?: string;
@@ -12326,8 +12371,9 @@ declare const Definitions: readonly [Schema.Struct<{
12326
12371
  mimeType: string;
12327
12372
  })[];
12328
12373
  details?: any;
12374
+ isError: true;
12329
12375
  };
12330
- status: "running";
12376
+ status: "aborted";
12331
12377
  thoughtSignature?: string;
12332
12378
  time: {
12333
12379
  start: number;
@@ -12383,6 +12429,8 @@ declare const Definitions: readonly [Schema.Struct<{
12383
12429
  options?: Record<string, any>;
12384
12430
  };
12385
12431
  model: string;
12432
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
12433
+ providerThinkingLevel?: string;
12386
12434
  usage: {
12387
12435
  input: number;
12388
12436
  output: number;
@@ -12519,14 +12567,19 @@ declare const Definitions: readonly [Schema.Struct<{
12519
12567
  type: "image";
12520
12568
  data: string;
12521
12569
  mimeType: string;
12570
+ } | {
12571
+ type: "thinking";
12572
+ thinking: string;
12573
+ thinkingSignature?: string;
12574
+ redacted?: boolean;
12522
12575
  } | {
12523
12576
  addedToolNames?: string[];
12524
12577
  arguments: Record<string, any>;
12525
12578
  callID: string;
12526
12579
  name: string;
12527
12580
  namespace?: string;
12528
- result: {
12529
- content: ({
12581
+ partial?: {
12582
+ content?: ({
12530
12583
  type: "text";
12531
12584
  text: string;
12532
12585
  textSignature?: string;
@@ -12536,9 +12589,8 @@ declare const Definitions: readonly [Schema.Struct<{
12536
12589
  mimeType: string;
12537
12590
  })[];
12538
12591
  details?: any;
12539
- isError: false;
12540
12592
  };
12541
- status: "completed";
12593
+ status: "running";
12542
12594
  thoughtSignature?: string;
12543
12595
  time: {
12544
12596
  start: number;
@@ -12562,9 +12614,9 @@ declare const Definitions: readonly [Schema.Struct<{
12562
12614
  mimeType: string;
12563
12615
  })[];
12564
12616
  details?: any;
12565
- isError: true;
12617
+ isError: false;
12566
12618
  };
12567
- status: "error";
12619
+ status: "completed";
12568
12620
  thoughtSignature?: string;
12569
12621
  time: {
12570
12622
  start: number;
@@ -12590,7 +12642,7 @@ declare const Definitions: readonly [Schema.Struct<{
12590
12642
  details?: any;
12591
12643
  isError: true;
12592
12644
  };
12593
- status: "skipped";
12645
+ status: "error";
12594
12646
  thoughtSignature?: string;
12595
12647
  time: {
12596
12648
  start: number;
@@ -12616,26 +12668,21 @@ declare const Definitions: readonly [Schema.Struct<{
12616
12668
  details?: any;
12617
12669
  isError: true;
12618
12670
  };
12619
- status: "aborted";
12671
+ status: "skipped";
12620
12672
  thoughtSignature?: string;
12621
12673
  time: {
12622
12674
  start: number;
12623
12675
  end: number;
12624
12676
  };
12625
12677
  type: "toolCall";
12626
- } | {
12627
- type: "thinking";
12628
- thinking: string;
12629
- thinkingSignature?: string;
12630
- redacted?: boolean;
12631
12678
  } | {
12632
12679
  addedToolNames?: string[];
12633
12680
  arguments: Record<string, any>;
12634
12681
  callID: string;
12635
12682
  name: string;
12636
12683
  namespace?: string;
12637
- partial?: {
12638
- content?: ({
12684
+ result: {
12685
+ content: ({
12639
12686
  type: "text";
12640
12687
  text: string;
12641
12688
  textSignature?: string;
@@ -12645,8 +12692,9 @@ declare const Definitions: readonly [Schema.Struct<{
12645
12692
  mimeType: string;
12646
12693
  })[];
12647
12694
  details?: any;
12695
+ isError: true;
12648
12696
  };
12649
- status: "running";
12697
+ status: "aborted";
12650
12698
  thoughtSignature?: string;
12651
12699
  time: {
12652
12700
  start: number;
@@ -12683,6 +12731,8 @@ declare const Definitions: readonly [Schema.Struct<{
12683
12731
  options?: Record<string, any>;
12684
12732
  };
12685
12733
  model: string;
12734
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
12735
+ providerThinkingLevel?: string;
12686
12736
  usage: {
12687
12737
  input: number;
12688
12738
  output: number;
@@ -12819,14 +12869,19 @@ declare const Definitions: readonly [Schema.Struct<{
12819
12869
  type: "image";
12820
12870
  data: string;
12821
12871
  mimeType: string;
12872
+ } | {
12873
+ type: "thinking";
12874
+ thinking: string;
12875
+ thinkingSignature?: string;
12876
+ redacted?: boolean;
12822
12877
  } | {
12823
12878
  addedToolNames?: string[];
12824
12879
  arguments: Record<string, any>;
12825
12880
  callID: string;
12826
12881
  name: string;
12827
12882
  namespace?: string;
12828
- result: {
12829
- content: ({
12883
+ partial?: {
12884
+ content?: ({
12830
12885
  type: "text";
12831
12886
  text: string;
12832
12887
  textSignature?: string;
@@ -12836,9 +12891,8 @@ declare const Definitions: readonly [Schema.Struct<{
12836
12891
  mimeType: string;
12837
12892
  })[];
12838
12893
  details?: any;
12839
- isError: false;
12840
12894
  };
12841
- status: "completed";
12895
+ status: "running";
12842
12896
  thoughtSignature?: string;
12843
12897
  time: {
12844
12898
  start: number;
@@ -12862,9 +12916,9 @@ declare const Definitions: readonly [Schema.Struct<{
12862
12916
  mimeType: string;
12863
12917
  })[];
12864
12918
  details?: any;
12865
- isError: true;
12919
+ isError: false;
12866
12920
  };
12867
- status: "error";
12921
+ status: "completed";
12868
12922
  thoughtSignature?: string;
12869
12923
  time: {
12870
12924
  start: number;
@@ -12890,7 +12944,7 @@ declare const Definitions: readonly [Schema.Struct<{
12890
12944
  details?: any;
12891
12945
  isError: true;
12892
12946
  };
12893
- status: "skipped";
12947
+ status: "error";
12894
12948
  thoughtSignature?: string;
12895
12949
  time: {
12896
12950
  start: number;
@@ -12916,26 +12970,21 @@ declare const Definitions: readonly [Schema.Struct<{
12916
12970
  details?: any;
12917
12971
  isError: true;
12918
12972
  };
12919
- status: "aborted";
12973
+ status: "skipped";
12920
12974
  thoughtSignature?: string;
12921
12975
  time: {
12922
12976
  start: number;
12923
12977
  end: number;
12924
12978
  };
12925
12979
  type: "toolCall";
12926
- } | {
12927
- type: "thinking";
12928
- thinking: string;
12929
- thinkingSignature?: string;
12930
- redacted?: boolean;
12931
12980
  } | {
12932
12981
  addedToolNames?: string[];
12933
12982
  arguments: Record<string, any>;
12934
12983
  callID: string;
12935
12984
  name: string;
12936
12985
  namespace?: string;
12937
- partial?: {
12938
- content?: ({
12986
+ result: {
12987
+ content: ({
12939
12988
  type: "text";
12940
12989
  text: string;
12941
12990
  textSignature?: string;
@@ -12945,8 +12994,9 @@ declare const Definitions: readonly [Schema.Struct<{
12945
12994
  mimeType: string;
12946
12995
  })[];
12947
12996
  details?: any;
12997
+ isError: true;
12948
12998
  };
12949
- status: "running";
12999
+ status: "aborted";
12950
13000
  thoughtSignature?: string;
12951
13001
  time: {
12952
13002
  start: number;
@@ -13011,6 +13061,8 @@ declare const Definitions: readonly [Schema.Struct<{
13011
13061
  options?: Record<string, any>;
13012
13062
  };
13013
13063
  model: string;
13064
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
13065
+ providerThinkingLevel?: string;
13014
13066
  usage: {
13015
13067
  input: number;
13016
13068
  output: number;
@@ -13147,14 +13199,19 @@ declare const Definitions: readonly [Schema.Struct<{
13147
13199
  type: "image";
13148
13200
  data: string;
13149
13201
  mimeType: string;
13202
+ } | {
13203
+ type: "thinking";
13204
+ thinking: string;
13205
+ thinkingSignature?: string;
13206
+ redacted?: boolean;
13150
13207
  } | {
13151
13208
  addedToolNames?: string[];
13152
13209
  arguments: Record<string, any>;
13153
13210
  callID: string;
13154
13211
  name: string;
13155
13212
  namespace?: string;
13156
- result: {
13157
- content: ({
13213
+ partial?: {
13214
+ content?: ({
13158
13215
  type: "text";
13159
13216
  text: string;
13160
13217
  textSignature?: string;
@@ -13164,9 +13221,8 @@ declare const Definitions: readonly [Schema.Struct<{
13164
13221
  mimeType: string;
13165
13222
  })[];
13166
13223
  details?: any;
13167
- isError: false;
13168
13224
  };
13169
- status: "completed";
13225
+ status: "running";
13170
13226
  thoughtSignature?: string;
13171
13227
  time: {
13172
13228
  start: number;
@@ -13190,9 +13246,9 @@ declare const Definitions: readonly [Schema.Struct<{
13190
13246
  mimeType: string;
13191
13247
  })[];
13192
13248
  details?: any;
13193
- isError: true;
13249
+ isError: false;
13194
13250
  };
13195
- status: "error";
13251
+ status: "completed";
13196
13252
  thoughtSignature?: string;
13197
13253
  time: {
13198
13254
  start: number;
@@ -13218,7 +13274,7 @@ declare const Definitions: readonly [Schema.Struct<{
13218
13274
  details?: any;
13219
13275
  isError: true;
13220
13276
  };
13221
- status: "skipped";
13277
+ status: "error";
13222
13278
  thoughtSignature?: string;
13223
13279
  time: {
13224
13280
  start: number;
@@ -13244,26 +13300,21 @@ declare const Definitions: readonly [Schema.Struct<{
13244
13300
  details?: any;
13245
13301
  isError: true;
13246
13302
  };
13247
- status: "aborted";
13303
+ status: "skipped";
13248
13304
  thoughtSignature?: string;
13249
13305
  time: {
13250
13306
  start: number;
13251
13307
  end: number;
13252
13308
  };
13253
13309
  type: "toolCall";
13254
- } | {
13255
- type: "thinking";
13256
- thinking: string;
13257
- thinkingSignature?: string;
13258
- redacted?: boolean;
13259
13310
  } | {
13260
13311
  addedToolNames?: string[];
13261
13312
  arguments: Record<string, any>;
13262
13313
  callID: string;
13263
13314
  name: string;
13264
13315
  namespace?: string;
13265
- partial?: {
13266
- content?: ({
13316
+ result: {
13317
+ content: ({
13267
13318
  type: "text";
13268
13319
  text: string;
13269
13320
  textSignature?: string;
@@ -13273,8 +13324,9 @@ declare const Definitions: readonly [Schema.Struct<{
13273
13324
  mimeType: string;
13274
13325
  })[];
13275
13326
  details?: any;
13327
+ isError: true;
13276
13328
  };
13277
- status: "running";
13329
+ status: "aborted";
13278
13330
  thoughtSignature?: string;
13279
13331
  time: {
13280
13332
  start: number;
@@ -13311,6 +13363,8 @@ declare const Definitions: readonly [Schema.Struct<{
13311
13363
  options?: Record<string, any>;
13312
13364
  };
13313
13365
  model: string;
13366
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
13367
+ providerThinkingLevel?: string;
13314
13368
  usage: {
13315
13369
  input: number;
13316
13370
  output: number;
@@ -13447,14 +13501,19 @@ declare const Definitions: readonly [Schema.Struct<{
13447
13501
  type: "image";
13448
13502
  data: string;
13449
13503
  mimeType: string;
13504
+ } | {
13505
+ type: "thinking";
13506
+ thinking: string;
13507
+ thinkingSignature?: string;
13508
+ redacted?: boolean;
13450
13509
  } | {
13451
13510
  addedToolNames?: string[];
13452
13511
  arguments: Record<string, any>;
13453
13512
  callID: string;
13454
13513
  name: string;
13455
13514
  namespace?: string;
13456
- result: {
13457
- content: ({
13515
+ partial?: {
13516
+ content?: ({
13458
13517
  type: "text";
13459
13518
  text: string;
13460
13519
  textSignature?: string;
@@ -13464,9 +13523,8 @@ declare const Definitions: readonly [Schema.Struct<{
13464
13523
  mimeType: string;
13465
13524
  })[];
13466
13525
  details?: any;
13467
- isError: false;
13468
13526
  };
13469
- status: "completed";
13527
+ status: "running";
13470
13528
  thoughtSignature?: string;
13471
13529
  time: {
13472
13530
  start: number;
@@ -13490,9 +13548,9 @@ declare const Definitions: readonly [Schema.Struct<{
13490
13548
  mimeType: string;
13491
13549
  })[];
13492
13550
  details?: any;
13493
- isError: true;
13551
+ isError: false;
13494
13552
  };
13495
- status: "error";
13553
+ status: "completed";
13496
13554
  thoughtSignature?: string;
13497
13555
  time: {
13498
13556
  start: number;
@@ -13518,7 +13576,7 @@ declare const Definitions: readonly [Schema.Struct<{
13518
13576
  details?: any;
13519
13577
  isError: true;
13520
13578
  };
13521
- status: "skipped";
13579
+ status: "error";
13522
13580
  thoughtSignature?: string;
13523
13581
  time: {
13524
13582
  start: number;
@@ -13544,26 +13602,21 @@ declare const Definitions: readonly [Schema.Struct<{
13544
13602
  details?: any;
13545
13603
  isError: true;
13546
13604
  };
13547
- status: "aborted";
13605
+ status: "skipped";
13548
13606
  thoughtSignature?: string;
13549
13607
  time: {
13550
13608
  start: number;
13551
13609
  end: number;
13552
13610
  };
13553
13611
  type: "toolCall";
13554
- } | {
13555
- type: "thinking";
13556
- thinking: string;
13557
- thinkingSignature?: string;
13558
- redacted?: boolean;
13559
13612
  } | {
13560
13613
  addedToolNames?: string[];
13561
13614
  arguments: Record<string, any>;
13562
13615
  callID: string;
13563
13616
  name: string;
13564
13617
  namespace?: string;
13565
- partial?: {
13566
- content?: ({
13618
+ result: {
13619
+ content: ({
13567
13620
  type: "text";
13568
13621
  text: string;
13569
13622
  textSignature?: string;
@@ -13573,8 +13626,9 @@ declare const Definitions: readonly [Schema.Struct<{
13573
13626
  mimeType: string;
13574
13627
  })[];
13575
13628
  details?: any;
13629
+ isError: true;
13576
13630
  };
13577
- status: "running";
13631
+ status: "aborted";
13578
13632
  thoughtSignature?: string;
13579
13633
  time: {
13580
13634
  start: number;
@@ -13630,6 +13684,8 @@ declare const Definitions: readonly [Schema.Struct<{
13630
13684
  options?: Record<string, any>;
13631
13685
  };
13632
13686
  model: string;
13687
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
13688
+ providerThinkingLevel?: string;
13633
13689
  usage: {
13634
13690
  input: number;
13635
13691
  output: number;
@@ -13766,14 +13822,19 @@ declare const Definitions: readonly [Schema.Struct<{
13766
13822
  type: "image";
13767
13823
  data: string;
13768
13824
  mimeType: string;
13825
+ } | {
13826
+ type: "thinking";
13827
+ thinking: string;
13828
+ thinkingSignature?: string;
13829
+ redacted?: boolean;
13769
13830
  } | {
13770
13831
  addedToolNames?: string[];
13771
13832
  arguments: Record<string, any>;
13772
13833
  callID: string;
13773
13834
  name: string;
13774
13835
  namespace?: string;
13775
- result: {
13776
- content: ({
13836
+ partial?: {
13837
+ content?: ({
13777
13838
  type: "text";
13778
13839
  text: string;
13779
13840
  textSignature?: string;
@@ -13783,9 +13844,8 @@ declare const Definitions: readonly [Schema.Struct<{
13783
13844
  mimeType: string;
13784
13845
  })[];
13785
13846
  details?: any;
13786
- isError: false;
13787
13847
  };
13788
- status: "completed";
13848
+ status: "running";
13789
13849
  thoughtSignature?: string;
13790
13850
  time: {
13791
13851
  start: number;
@@ -13809,9 +13869,9 @@ declare const Definitions: readonly [Schema.Struct<{
13809
13869
  mimeType: string;
13810
13870
  })[];
13811
13871
  details?: any;
13812
- isError: true;
13872
+ isError: false;
13813
13873
  };
13814
- status: "error";
13874
+ status: "completed";
13815
13875
  thoughtSignature?: string;
13816
13876
  time: {
13817
13877
  start: number;
@@ -13837,7 +13897,7 @@ declare const Definitions: readonly [Schema.Struct<{
13837
13897
  details?: any;
13838
13898
  isError: true;
13839
13899
  };
13840
- status: "skipped";
13900
+ status: "error";
13841
13901
  thoughtSignature?: string;
13842
13902
  time: {
13843
13903
  start: number;
@@ -13863,26 +13923,21 @@ declare const Definitions: readonly [Schema.Struct<{
13863
13923
  details?: any;
13864
13924
  isError: true;
13865
13925
  };
13866
- status: "aborted";
13926
+ status: "skipped";
13867
13927
  thoughtSignature?: string;
13868
13928
  time: {
13869
13929
  start: number;
13870
13930
  end: number;
13871
13931
  };
13872
13932
  type: "toolCall";
13873
- } | {
13874
- type: "thinking";
13875
- thinking: string;
13876
- thinkingSignature?: string;
13877
- redacted?: boolean;
13878
13933
  } | {
13879
13934
  addedToolNames?: string[];
13880
13935
  arguments: Record<string, any>;
13881
13936
  callID: string;
13882
13937
  name: string;
13883
13938
  namespace?: string;
13884
- partial?: {
13885
- content?: ({
13939
+ result: {
13940
+ content: ({
13886
13941
  type: "text";
13887
13942
  text: string;
13888
13943
  textSignature?: string;
@@ -13892,8 +13947,9 @@ declare const Definitions: readonly [Schema.Struct<{
13892
13947
  mimeType: string;
13893
13948
  })[];
13894
13949
  details?: any;
13950
+ isError: true;
13895
13951
  };
13896
- status: "running";
13952
+ status: "aborted";
13897
13953
  thoughtSignature?: string;
13898
13954
  time: {
13899
13955
  start: number;
@@ -13930,6 +13986,8 @@ declare const Definitions: readonly [Schema.Struct<{
13930
13986
  options?: Record<string, any>;
13931
13987
  };
13932
13988
  model: string;
13989
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
13990
+ providerThinkingLevel?: string;
13933
13991
  usage: {
13934
13992
  input: number;
13935
13993
  output: number;
@@ -14066,14 +14124,19 @@ declare const Definitions: readonly [Schema.Struct<{
14066
14124
  type: "image";
14067
14125
  data: string;
14068
14126
  mimeType: string;
14127
+ } | {
14128
+ type: "thinking";
14129
+ thinking: string;
14130
+ thinkingSignature?: string;
14131
+ redacted?: boolean;
14069
14132
  } | {
14070
14133
  addedToolNames?: string[];
14071
14134
  arguments: Record<string, any>;
14072
14135
  callID: string;
14073
14136
  name: string;
14074
14137
  namespace?: string;
14075
- result: {
14076
- content: ({
14138
+ partial?: {
14139
+ content?: ({
14077
14140
  type: "text";
14078
14141
  text: string;
14079
14142
  textSignature?: string;
@@ -14083,9 +14146,8 @@ declare const Definitions: readonly [Schema.Struct<{
14083
14146
  mimeType: string;
14084
14147
  })[];
14085
14148
  details?: any;
14086
- isError: false;
14087
14149
  };
14088
- status: "completed";
14150
+ status: "running";
14089
14151
  thoughtSignature?: string;
14090
14152
  time: {
14091
14153
  start: number;
@@ -14109,9 +14171,9 @@ declare const Definitions: readonly [Schema.Struct<{
14109
14171
  mimeType: string;
14110
14172
  })[];
14111
14173
  details?: any;
14112
- isError: true;
14174
+ isError: false;
14113
14175
  };
14114
- status: "error";
14176
+ status: "completed";
14115
14177
  thoughtSignature?: string;
14116
14178
  time: {
14117
14179
  start: number;
@@ -14137,7 +14199,7 @@ declare const Definitions: readonly [Schema.Struct<{
14137
14199
  details?: any;
14138
14200
  isError: true;
14139
14201
  };
14140
- status: "skipped";
14202
+ status: "error";
14141
14203
  thoughtSignature?: string;
14142
14204
  time: {
14143
14205
  start: number;
@@ -14163,26 +14225,21 @@ declare const Definitions: readonly [Schema.Struct<{
14163
14225
  details?: any;
14164
14226
  isError: true;
14165
14227
  };
14166
- status: "aborted";
14228
+ status: "skipped";
14167
14229
  thoughtSignature?: string;
14168
14230
  time: {
14169
14231
  start: number;
14170
14232
  end: number;
14171
14233
  };
14172
14234
  type: "toolCall";
14173
- } | {
14174
- type: "thinking";
14175
- thinking: string;
14176
- thinkingSignature?: string;
14177
- redacted?: boolean;
14178
14235
  } | {
14179
14236
  addedToolNames?: string[];
14180
14237
  arguments: Record<string, any>;
14181
14238
  callID: string;
14182
14239
  name: string;
14183
14240
  namespace?: string;
14184
- partial?: {
14185
- content?: ({
14241
+ result: {
14242
+ content: ({
14186
14243
  type: "text";
14187
14244
  text: string;
14188
14245
  textSignature?: string;
@@ -14192,8 +14249,9 @@ declare const Definitions: readonly [Schema.Struct<{
14192
14249
  mimeType: string;
14193
14250
  })[];
14194
14251
  details?: any;
14252
+ isError: true;
14195
14253
  };
14196
- status: "running";
14254
+ status: "aborted";
14197
14255
  thoughtSignature?: string;
14198
14256
  time: {
14199
14257
  start: number;
@@ -15564,6 +15622,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15564
15622
  options?: Record<string, any>;
15565
15623
  };
15566
15624
  model: string;
15625
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
15626
+ providerThinkingLevel?: string;
15567
15627
  usage: {
15568
15628
  input: number;
15569
15629
  output: number;
@@ -15700,14 +15760,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15700
15760
  type: "image";
15701
15761
  data: string;
15702
15762
  mimeType: string;
15763
+ } | {
15764
+ type: "thinking";
15765
+ thinking: string;
15766
+ thinkingSignature?: string;
15767
+ redacted?: boolean;
15703
15768
  } | {
15704
15769
  addedToolNames?: string[];
15705
15770
  arguments: Record<string, any>;
15706
15771
  callID: string;
15707
15772
  name: string;
15708
15773
  namespace?: string;
15709
- result: {
15710
- content: ({
15774
+ partial?: {
15775
+ content?: ({
15711
15776
  type: "text";
15712
15777
  text: string;
15713
15778
  textSignature?: string;
@@ -15717,9 +15782,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15717
15782
  mimeType: string;
15718
15783
  })[];
15719
15784
  details?: any;
15720
- isError: false;
15721
15785
  };
15722
- status: "completed";
15786
+ status: "running";
15723
15787
  thoughtSignature?: string;
15724
15788
  time: {
15725
15789
  start: number;
@@ -15743,9 +15807,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15743
15807
  mimeType: string;
15744
15808
  })[];
15745
15809
  details?: any;
15746
- isError: true;
15810
+ isError: false;
15747
15811
  };
15748
- status: "error";
15812
+ status: "completed";
15749
15813
  thoughtSignature?: string;
15750
15814
  time: {
15751
15815
  start: number;
@@ -15771,7 +15835,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15771
15835
  details?: any;
15772
15836
  isError: true;
15773
15837
  };
15774
- status: "skipped";
15838
+ status: "error";
15775
15839
  thoughtSignature?: string;
15776
15840
  time: {
15777
15841
  start: number;
@@ -15797,26 +15861,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15797
15861
  details?: any;
15798
15862
  isError: true;
15799
15863
  };
15800
- status: "aborted";
15864
+ status: "skipped";
15801
15865
  thoughtSignature?: string;
15802
15866
  time: {
15803
15867
  start: number;
15804
15868
  end: number;
15805
15869
  };
15806
15870
  type: "toolCall";
15807
- } | {
15808
- type: "thinking";
15809
- thinking: string;
15810
- thinkingSignature?: string;
15811
- redacted?: boolean;
15812
15871
  } | {
15813
15872
  addedToolNames?: string[];
15814
15873
  arguments: Record<string, any>;
15815
15874
  callID: string;
15816
15875
  name: string;
15817
15876
  namespace?: string;
15818
- partial?: {
15819
- content?: ({
15877
+ result: {
15878
+ content: ({
15820
15879
  type: "text";
15821
15880
  text: string;
15822
15881
  textSignature?: string;
@@ -15826,8 +15885,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15826
15885
  mimeType: string;
15827
15886
  })[];
15828
15887
  details?: any;
15888
+ isError: true;
15829
15889
  };
15830
- status: "running";
15890
+ status: "aborted";
15831
15891
  thoughtSignature?: string;
15832
15892
  time: {
15833
15893
  start: number;
@@ -15864,6 +15924,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
15864
15924
  options?: Record<string, any>;
15865
15925
  };
15866
15926
  model: string;
15927
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
15928
+ providerThinkingLevel?: string;
15867
15929
  usage: {
15868
15930
  input: number;
15869
15931
  output: number;
@@ -16000,14 +16062,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16000
16062
  type: "image";
16001
16063
  data: string;
16002
16064
  mimeType: string;
16065
+ } | {
16066
+ type: "thinking";
16067
+ thinking: string;
16068
+ thinkingSignature?: string;
16069
+ redacted?: boolean;
16003
16070
  } | {
16004
16071
  addedToolNames?: string[];
16005
16072
  arguments: Record<string, any>;
16006
16073
  callID: string;
16007
16074
  name: string;
16008
16075
  namespace?: string;
16009
- result: {
16010
- content: ({
16076
+ partial?: {
16077
+ content?: ({
16011
16078
  type: "text";
16012
16079
  text: string;
16013
16080
  textSignature?: string;
@@ -16017,9 +16084,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16017
16084
  mimeType: string;
16018
16085
  })[];
16019
16086
  details?: any;
16020
- isError: false;
16021
16087
  };
16022
- status: "completed";
16088
+ status: "running";
16023
16089
  thoughtSignature?: string;
16024
16090
  time: {
16025
16091
  start: number;
@@ -16043,9 +16109,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16043
16109
  mimeType: string;
16044
16110
  })[];
16045
16111
  details?: any;
16046
- isError: true;
16112
+ isError: false;
16047
16113
  };
16048
- status: "error";
16114
+ status: "completed";
16049
16115
  thoughtSignature?: string;
16050
16116
  time: {
16051
16117
  start: number;
@@ -16071,7 +16137,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16071
16137
  details?: any;
16072
16138
  isError: true;
16073
16139
  };
16074
- status: "skipped";
16140
+ status: "error";
16075
16141
  thoughtSignature?: string;
16076
16142
  time: {
16077
16143
  start: number;
@@ -16097,26 +16163,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16097
16163
  details?: any;
16098
16164
  isError: true;
16099
16165
  };
16100
- status: "aborted";
16166
+ status: "skipped";
16101
16167
  thoughtSignature?: string;
16102
16168
  time: {
16103
16169
  start: number;
16104
16170
  end: number;
16105
16171
  };
16106
16172
  type: "toolCall";
16107
- } | {
16108
- type: "thinking";
16109
- thinking: string;
16110
- thinkingSignature?: string;
16111
- redacted?: boolean;
16112
16173
  } | {
16113
16174
  addedToolNames?: string[];
16114
16175
  arguments: Record<string, any>;
16115
16176
  callID: string;
16116
16177
  name: string;
16117
16178
  namespace?: string;
16118
- partial?: {
16119
- content?: ({
16179
+ result: {
16180
+ content: ({
16120
16181
  type: "text";
16121
16182
  text: string;
16122
16183
  textSignature?: string;
@@ -16126,8 +16187,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16126
16187
  mimeType: string;
16127
16188
  })[];
16128
16189
  details?: any;
16190
+ isError: true;
16129
16191
  };
16130
- status: "running";
16192
+ status: "aborted";
16131
16193
  thoughtSignature?: string;
16132
16194
  time: {
16133
16195
  start: number;
@@ -16182,6 +16244,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16182
16244
  options?: Record<string, any>;
16183
16245
  };
16184
16246
  model: string;
16247
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
16248
+ providerThinkingLevel?: string;
16185
16249
  usage: {
16186
16250
  input: number;
16187
16251
  output: number;
@@ -16318,14 +16382,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16318
16382
  type: "image";
16319
16383
  data: string;
16320
16384
  mimeType: string;
16385
+ } | {
16386
+ type: "thinking";
16387
+ thinking: string;
16388
+ thinkingSignature?: string;
16389
+ redacted?: boolean;
16321
16390
  } | {
16322
16391
  addedToolNames?: string[];
16323
16392
  arguments: Record<string, any>;
16324
16393
  callID: string;
16325
16394
  name: string;
16326
16395
  namespace?: string;
16327
- result: {
16328
- content: ({
16396
+ partial?: {
16397
+ content?: ({
16329
16398
  type: "text";
16330
16399
  text: string;
16331
16400
  textSignature?: string;
@@ -16335,9 +16404,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16335
16404
  mimeType: string;
16336
16405
  })[];
16337
16406
  details?: any;
16338
- isError: false;
16339
16407
  };
16340
- status: "completed";
16408
+ status: "running";
16341
16409
  thoughtSignature?: string;
16342
16410
  time: {
16343
16411
  start: number;
@@ -16361,9 +16429,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16361
16429
  mimeType: string;
16362
16430
  })[];
16363
16431
  details?: any;
16364
- isError: true;
16432
+ isError: false;
16365
16433
  };
16366
- status: "error";
16434
+ status: "completed";
16367
16435
  thoughtSignature?: string;
16368
16436
  time: {
16369
16437
  start: number;
@@ -16389,7 +16457,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16389
16457
  details?: any;
16390
16458
  isError: true;
16391
16459
  };
16392
- status: "skipped";
16460
+ status: "error";
16393
16461
  thoughtSignature?: string;
16394
16462
  time: {
16395
16463
  start: number;
@@ -16415,26 +16483,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16415
16483
  details?: any;
16416
16484
  isError: true;
16417
16485
  };
16418
- status: "aborted";
16486
+ status: "skipped";
16419
16487
  thoughtSignature?: string;
16420
16488
  time: {
16421
16489
  start: number;
16422
16490
  end: number;
16423
16491
  };
16424
16492
  type: "toolCall";
16425
- } | {
16426
- type: "thinking";
16427
- thinking: string;
16428
- thinkingSignature?: string;
16429
- redacted?: boolean;
16430
16493
  } | {
16431
16494
  addedToolNames?: string[];
16432
16495
  arguments: Record<string, any>;
16433
16496
  callID: string;
16434
16497
  name: string;
16435
16498
  namespace?: string;
16436
- partial?: {
16437
- content?: ({
16499
+ result: {
16500
+ content: ({
16438
16501
  type: "text";
16439
16502
  text: string;
16440
16503
  textSignature?: string;
@@ -16444,8 +16507,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16444
16507
  mimeType: string;
16445
16508
  })[];
16446
16509
  details?: any;
16510
+ isError: true;
16447
16511
  };
16448
- status: "running";
16512
+ status: "aborted";
16449
16513
  thoughtSignature?: string;
16450
16514
  time: {
16451
16515
  start: number;
@@ -16482,6 +16546,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16482
16546
  options?: Record<string, any>;
16483
16547
  };
16484
16548
  model: string;
16549
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
16550
+ providerThinkingLevel?: string;
16485
16551
  usage: {
16486
16552
  input: number;
16487
16553
  output: number;
@@ -16618,14 +16684,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16618
16684
  type: "image";
16619
16685
  data: string;
16620
16686
  mimeType: string;
16687
+ } | {
16688
+ type: "thinking";
16689
+ thinking: string;
16690
+ thinkingSignature?: string;
16691
+ redacted?: boolean;
16621
16692
  } | {
16622
16693
  addedToolNames?: string[];
16623
16694
  arguments: Record<string, any>;
16624
16695
  callID: string;
16625
16696
  name: string;
16626
16697
  namespace?: string;
16627
- result: {
16628
- content: ({
16698
+ partial?: {
16699
+ content?: ({
16629
16700
  type: "text";
16630
16701
  text: string;
16631
16702
  textSignature?: string;
@@ -16635,9 +16706,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16635
16706
  mimeType: string;
16636
16707
  })[];
16637
16708
  details?: any;
16638
- isError: false;
16639
16709
  };
16640
- status: "completed";
16710
+ status: "running";
16641
16711
  thoughtSignature?: string;
16642
16712
  time: {
16643
16713
  start: number;
@@ -16661,9 +16731,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16661
16731
  mimeType: string;
16662
16732
  })[];
16663
16733
  details?: any;
16664
- isError: true;
16734
+ isError: false;
16665
16735
  };
16666
- status: "error";
16736
+ status: "completed";
16667
16737
  thoughtSignature?: string;
16668
16738
  time: {
16669
16739
  start: number;
@@ -16689,7 +16759,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16689
16759
  details?: any;
16690
16760
  isError: true;
16691
16761
  };
16692
- status: "skipped";
16762
+ status: "error";
16693
16763
  thoughtSignature?: string;
16694
16764
  time: {
16695
16765
  start: number;
@@ -16715,26 +16785,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16715
16785
  details?: any;
16716
16786
  isError: true;
16717
16787
  };
16718
- status: "aborted";
16788
+ status: "skipped";
16719
16789
  thoughtSignature?: string;
16720
16790
  time: {
16721
16791
  start: number;
16722
16792
  end: number;
16723
16793
  };
16724
16794
  type: "toolCall";
16725
- } | {
16726
- type: "thinking";
16727
- thinking: string;
16728
- thinkingSignature?: string;
16729
- redacted?: boolean;
16730
16795
  } | {
16731
16796
  addedToolNames?: string[];
16732
16797
  arguments: Record<string, any>;
16733
16798
  callID: string;
16734
16799
  name: string;
16735
16800
  namespace?: string;
16736
- partial?: {
16737
- content?: ({
16801
+ result: {
16802
+ content: ({
16738
16803
  type: "text";
16739
16804
  text: string;
16740
16805
  textSignature?: string;
@@ -16744,8 +16809,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
16744
16809
  mimeType: string;
16745
16810
  })[];
16746
16811
  details?: any;
16812
+ isError: true;
16747
16813
  };
16748
- status: "running";
16814
+ status: "aborted";
16749
16815
  thoughtSignature?: string;
16750
16816
  time: {
16751
16817
  start: number;
@@ -17088,6 +17154,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17088
17154
  options?: Record<string, any>;
17089
17155
  };
17090
17156
  model: string;
17157
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
17158
+ providerThinkingLevel?: string;
17091
17159
  usage: {
17092
17160
  input: number;
17093
17161
  output: number;
@@ -17224,14 +17292,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17224
17292
  type: "image";
17225
17293
  data: string;
17226
17294
  mimeType: string;
17295
+ } | {
17296
+ type: "thinking";
17297
+ thinking: string;
17298
+ thinkingSignature?: string;
17299
+ redacted?: boolean;
17227
17300
  } | {
17228
17301
  addedToolNames?: string[];
17229
17302
  arguments: Record<string, any>;
17230
17303
  callID: string;
17231
17304
  name: string;
17232
17305
  namespace?: string;
17233
- result: {
17234
- content: ({
17306
+ partial?: {
17307
+ content?: ({
17235
17308
  type: "text";
17236
17309
  text: string;
17237
17310
  textSignature?: string;
@@ -17241,9 +17314,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17241
17314
  mimeType: string;
17242
17315
  })[];
17243
17316
  details?: any;
17244
- isError: false;
17245
17317
  };
17246
- status: "completed";
17318
+ status: "running";
17247
17319
  thoughtSignature?: string;
17248
17320
  time: {
17249
17321
  start: number;
@@ -17267,9 +17339,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17267
17339
  mimeType: string;
17268
17340
  })[];
17269
17341
  details?: any;
17270
- isError: true;
17342
+ isError: false;
17271
17343
  };
17272
- status: "error";
17344
+ status: "completed";
17273
17345
  thoughtSignature?: string;
17274
17346
  time: {
17275
17347
  start: number;
@@ -17295,7 +17367,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17295
17367
  details?: any;
17296
17368
  isError: true;
17297
17369
  };
17298
- status: "skipped";
17370
+ status: "error";
17299
17371
  thoughtSignature?: string;
17300
17372
  time: {
17301
17373
  start: number;
@@ -17321,26 +17393,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17321
17393
  details?: any;
17322
17394
  isError: true;
17323
17395
  };
17324
- status: "aborted";
17396
+ status: "skipped";
17325
17397
  thoughtSignature?: string;
17326
17398
  time: {
17327
17399
  start: number;
17328
17400
  end: number;
17329
17401
  };
17330
17402
  type: "toolCall";
17331
- } | {
17332
- type: "thinking";
17333
- thinking: string;
17334
- thinkingSignature?: string;
17335
- redacted?: boolean;
17336
17403
  } | {
17337
17404
  addedToolNames?: string[];
17338
17405
  arguments: Record<string, any>;
17339
17406
  callID: string;
17340
17407
  name: string;
17341
17408
  namespace?: string;
17342
- partial?: {
17343
- content?: ({
17409
+ result: {
17410
+ content: ({
17344
17411
  type: "text";
17345
17412
  text: string;
17346
17413
  textSignature?: string;
@@ -17350,8 +17417,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17350
17417
  mimeType: string;
17351
17418
  })[];
17352
17419
  details?: any;
17420
+ isError: true;
17353
17421
  };
17354
- status: "running";
17422
+ status: "aborted";
17355
17423
  thoughtSignature?: string;
17356
17424
  time: {
17357
17425
  start: number;
@@ -17388,6 +17456,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17388
17456
  options?: Record<string, any>;
17389
17457
  };
17390
17458
  model: string;
17459
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
17460
+ providerThinkingLevel?: string;
17391
17461
  usage: {
17392
17462
  input: number;
17393
17463
  output: number;
@@ -17524,14 +17594,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17524
17594
  type: "image";
17525
17595
  data: string;
17526
17596
  mimeType: string;
17597
+ } | {
17598
+ type: "thinking";
17599
+ thinking: string;
17600
+ thinkingSignature?: string;
17601
+ redacted?: boolean;
17527
17602
  } | {
17528
17603
  addedToolNames?: string[];
17529
17604
  arguments: Record<string, any>;
17530
17605
  callID: string;
17531
17606
  name: string;
17532
17607
  namespace?: string;
17533
- result: {
17534
- content: ({
17608
+ partial?: {
17609
+ content?: ({
17535
17610
  type: "text";
17536
17611
  text: string;
17537
17612
  textSignature?: string;
@@ -17541,9 +17616,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17541
17616
  mimeType: string;
17542
17617
  })[];
17543
17618
  details?: any;
17544
- isError: false;
17545
17619
  };
17546
- status: "completed";
17620
+ status: "running";
17547
17621
  thoughtSignature?: string;
17548
17622
  time: {
17549
17623
  start: number;
@@ -17567,9 +17641,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17567
17641
  mimeType: string;
17568
17642
  })[];
17569
17643
  details?: any;
17570
- isError: true;
17644
+ isError: false;
17571
17645
  };
17572
- status: "error";
17646
+ status: "completed";
17573
17647
  thoughtSignature?: string;
17574
17648
  time: {
17575
17649
  start: number;
@@ -17595,7 +17669,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17595
17669
  details?: any;
17596
17670
  isError: true;
17597
17671
  };
17598
- status: "skipped";
17672
+ status: "error";
17599
17673
  thoughtSignature?: string;
17600
17674
  time: {
17601
17675
  start: number;
@@ -17621,26 +17695,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17621
17695
  details?: any;
17622
17696
  isError: true;
17623
17697
  };
17624
- status: "aborted";
17698
+ status: "skipped";
17625
17699
  thoughtSignature?: string;
17626
17700
  time: {
17627
17701
  start: number;
17628
17702
  end: number;
17629
17703
  };
17630
17704
  type: "toolCall";
17631
- } | {
17632
- type: "thinking";
17633
- thinking: string;
17634
- thinkingSignature?: string;
17635
- redacted?: boolean;
17636
17705
  } | {
17637
17706
  addedToolNames?: string[];
17638
17707
  arguments: Record<string, any>;
17639
17708
  callID: string;
17640
17709
  name: string;
17641
17710
  namespace?: string;
17642
- partial?: {
17643
- content?: ({
17711
+ result: {
17712
+ content: ({
17644
17713
  type: "text";
17645
17714
  text: string;
17646
17715
  textSignature?: string;
@@ -17650,8 +17719,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17650
17719
  mimeType: string;
17651
17720
  })[];
17652
17721
  details?: any;
17722
+ isError: true;
17653
17723
  };
17654
- status: "running";
17724
+ status: "aborted";
17655
17725
  thoughtSignature?: string;
17656
17726
  time: {
17657
17727
  start: number;
@@ -17707,6 +17777,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17707
17777
  options?: Record<string, any>;
17708
17778
  };
17709
17779
  model: string;
17780
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
17781
+ providerThinkingLevel?: string;
17710
17782
  usage: {
17711
17783
  input: number;
17712
17784
  output: number;
@@ -17843,14 +17915,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17843
17915
  type: "image";
17844
17916
  data: string;
17845
17917
  mimeType: string;
17918
+ } | {
17919
+ type: "thinking";
17920
+ thinking: string;
17921
+ thinkingSignature?: string;
17922
+ redacted?: boolean;
17846
17923
  } | {
17847
17924
  addedToolNames?: string[];
17848
17925
  arguments: Record<string, any>;
17849
17926
  callID: string;
17850
17927
  name: string;
17851
17928
  namespace?: string;
17852
- result: {
17853
- content: ({
17929
+ partial?: {
17930
+ content?: ({
17854
17931
  type: "text";
17855
17932
  text: string;
17856
17933
  textSignature?: string;
@@ -17860,9 +17937,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17860
17937
  mimeType: string;
17861
17938
  })[];
17862
17939
  details?: any;
17863
- isError: false;
17864
17940
  };
17865
- status: "completed";
17941
+ status: "running";
17866
17942
  thoughtSignature?: string;
17867
17943
  time: {
17868
17944
  start: number;
@@ -17886,9 +17962,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17886
17962
  mimeType: string;
17887
17963
  })[];
17888
17964
  details?: any;
17889
- isError: true;
17965
+ isError: false;
17890
17966
  };
17891
- status: "error";
17967
+ status: "completed";
17892
17968
  thoughtSignature?: string;
17893
17969
  time: {
17894
17970
  start: number;
@@ -17914,7 +17990,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17914
17990
  details?: any;
17915
17991
  isError: true;
17916
17992
  };
17917
- status: "skipped";
17993
+ status: "error";
17918
17994
  thoughtSignature?: string;
17919
17995
  time: {
17920
17996
  start: number;
@@ -17940,26 +18016,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17940
18016
  details?: any;
17941
18017
  isError: true;
17942
18018
  };
17943
- status: "aborted";
18019
+ status: "skipped";
17944
18020
  thoughtSignature?: string;
17945
18021
  time: {
17946
18022
  start: number;
17947
18023
  end: number;
17948
18024
  };
17949
18025
  type: "toolCall";
17950
- } | {
17951
- type: "thinking";
17952
- thinking: string;
17953
- thinkingSignature?: string;
17954
- redacted?: boolean;
17955
18026
  } | {
17956
18027
  addedToolNames?: string[];
17957
18028
  arguments: Record<string, any>;
17958
18029
  callID: string;
17959
18030
  name: string;
17960
18031
  namespace?: string;
17961
- partial?: {
17962
- content?: ({
18032
+ result: {
18033
+ content: ({
17963
18034
  type: "text";
17964
18035
  text: string;
17965
18036
  textSignature?: string;
@@ -17969,8 +18040,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
17969
18040
  mimeType: string;
17970
18041
  })[];
17971
18042
  details?: any;
18043
+ isError: true;
17972
18044
  };
17973
- status: "running";
18045
+ status: "aborted";
17974
18046
  thoughtSignature?: string;
17975
18047
  time: {
17976
18048
  start: number;
@@ -18007,6 +18079,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18007
18079
  options?: Record<string, any>;
18008
18080
  };
18009
18081
  model: string;
18082
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
18083
+ providerThinkingLevel?: string;
18010
18084
  usage: {
18011
18085
  input: number;
18012
18086
  output: number;
@@ -18143,14 +18217,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18143
18217
  type: "image";
18144
18218
  data: string;
18145
18219
  mimeType: string;
18220
+ } | {
18221
+ type: "thinking";
18222
+ thinking: string;
18223
+ thinkingSignature?: string;
18224
+ redacted?: boolean;
18146
18225
  } | {
18147
18226
  addedToolNames?: string[];
18148
18227
  arguments: Record<string, any>;
18149
18228
  callID: string;
18150
18229
  name: string;
18151
18230
  namespace?: string;
18152
- result: {
18153
- content: ({
18231
+ partial?: {
18232
+ content?: ({
18154
18233
  type: "text";
18155
18234
  text: string;
18156
18235
  textSignature?: string;
@@ -18160,9 +18239,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18160
18239
  mimeType: string;
18161
18240
  })[];
18162
18241
  details?: any;
18163
- isError: false;
18164
18242
  };
18165
- status: "completed";
18243
+ status: "running";
18166
18244
  thoughtSignature?: string;
18167
18245
  time: {
18168
18246
  start: number;
@@ -18186,9 +18264,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18186
18264
  mimeType: string;
18187
18265
  })[];
18188
18266
  details?: any;
18189
- isError: true;
18267
+ isError: false;
18190
18268
  };
18191
- status: "error";
18269
+ status: "completed";
18192
18270
  thoughtSignature?: string;
18193
18271
  time: {
18194
18272
  start: number;
@@ -18214,7 +18292,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18214
18292
  details?: any;
18215
18293
  isError: true;
18216
18294
  };
18217
- status: "skipped";
18295
+ status: "error";
18218
18296
  thoughtSignature?: string;
18219
18297
  time: {
18220
18298
  start: number;
@@ -18240,26 +18318,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18240
18318
  details?: any;
18241
18319
  isError: true;
18242
18320
  };
18243
- status: "aborted";
18321
+ status: "skipped";
18244
18322
  thoughtSignature?: string;
18245
18323
  time: {
18246
18324
  start: number;
18247
18325
  end: number;
18248
18326
  };
18249
18327
  type: "toolCall";
18250
- } | {
18251
- type: "thinking";
18252
- thinking: string;
18253
- thinkingSignature?: string;
18254
- redacted?: boolean;
18255
18328
  } | {
18256
18329
  addedToolNames?: string[];
18257
18330
  arguments: Record<string, any>;
18258
18331
  callID: string;
18259
18332
  name: string;
18260
18333
  namespace?: string;
18261
- partial?: {
18262
- content?: ({
18334
+ result: {
18335
+ content: ({
18263
18336
  type: "text";
18264
18337
  text: string;
18265
18338
  textSignature?: string;
@@ -18269,8 +18342,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18269
18342
  mimeType: string;
18270
18343
  })[];
18271
18344
  details?: any;
18345
+ isError: true;
18272
18346
  };
18273
- status: "running";
18347
+ status: "aborted";
18274
18348
  thoughtSignature?: string;
18275
18349
  time: {
18276
18350
  start: number;
@@ -18335,6 +18409,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18335
18409
  options?: Record<string, any>;
18336
18410
  };
18337
18411
  model: string;
18412
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
18413
+ providerThinkingLevel?: string;
18338
18414
  usage: {
18339
18415
  input: number;
18340
18416
  output: number;
@@ -18471,14 +18547,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18471
18547
  type: "image";
18472
18548
  data: string;
18473
18549
  mimeType: string;
18550
+ } | {
18551
+ type: "thinking";
18552
+ thinking: string;
18553
+ thinkingSignature?: string;
18554
+ redacted?: boolean;
18474
18555
  } | {
18475
18556
  addedToolNames?: string[];
18476
18557
  arguments: Record<string, any>;
18477
18558
  callID: string;
18478
18559
  name: string;
18479
18560
  namespace?: string;
18480
- result: {
18481
- content: ({
18561
+ partial?: {
18562
+ content?: ({
18482
18563
  type: "text";
18483
18564
  text: string;
18484
18565
  textSignature?: string;
@@ -18488,9 +18569,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18488
18569
  mimeType: string;
18489
18570
  })[];
18490
18571
  details?: any;
18491
- isError: false;
18492
18572
  };
18493
- status: "completed";
18573
+ status: "running";
18494
18574
  thoughtSignature?: string;
18495
18575
  time: {
18496
18576
  start: number;
@@ -18514,9 +18594,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18514
18594
  mimeType: string;
18515
18595
  })[];
18516
18596
  details?: any;
18517
- isError: true;
18597
+ isError: false;
18518
18598
  };
18519
- status: "error";
18599
+ status: "completed";
18520
18600
  thoughtSignature?: string;
18521
18601
  time: {
18522
18602
  start: number;
@@ -18542,7 +18622,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18542
18622
  details?: any;
18543
18623
  isError: true;
18544
18624
  };
18545
- status: "skipped";
18625
+ status: "error";
18546
18626
  thoughtSignature?: string;
18547
18627
  time: {
18548
18628
  start: number;
@@ -18568,26 +18648,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18568
18648
  details?: any;
18569
18649
  isError: true;
18570
18650
  };
18571
- status: "aborted";
18651
+ status: "skipped";
18572
18652
  thoughtSignature?: string;
18573
18653
  time: {
18574
18654
  start: number;
18575
18655
  end: number;
18576
18656
  };
18577
18657
  type: "toolCall";
18578
- } | {
18579
- type: "thinking";
18580
- thinking: string;
18581
- thinkingSignature?: string;
18582
- redacted?: boolean;
18583
18658
  } | {
18584
18659
  addedToolNames?: string[];
18585
18660
  arguments: Record<string, any>;
18586
18661
  callID: string;
18587
18662
  name: string;
18588
18663
  namespace?: string;
18589
- partial?: {
18590
- content?: ({
18664
+ result: {
18665
+ content: ({
18591
18666
  type: "text";
18592
18667
  text: string;
18593
18668
  textSignature?: string;
@@ -18597,8 +18672,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18597
18672
  mimeType: string;
18598
18673
  })[];
18599
18674
  details?: any;
18675
+ isError: true;
18600
18676
  };
18601
- status: "running";
18677
+ status: "aborted";
18602
18678
  thoughtSignature?: string;
18603
18679
  time: {
18604
18680
  start: number;
@@ -18635,6 +18711,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18635
18711
  options?: Record<string, any>;
18636
18712
  };
18637
18713
  model: string;
18714
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
18715
+ providerThinkingLevel?: string;
18638
18716
  usage: {
18639
18717
  input: number;
18640
18718
  output: number;
@@ -18771,14 +18849,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18771
18849
  type: "image";
18772
18850
  data: string;
18773
18851
  mimeType: string;
18852
+ } | {
18853
+ type: "thinking";
18854
+ thinking: string;
18855
+ thinkingSignature?: string;
18856
+ redacted?: boolean;
18774
18857
  } | {
18775
18858
  addedToolNames?: string[];
18776
18859
  arguments: Record<string, any>;
18777
18860
  callID: string;
18778
18861
  name: string;
18779
18862
  namespace?: string;
18780
- result: {
18781
- content: ({
18863
+ partial?: {
18864
+ content?: ({
18782
18865
  type: "text";
18783
18866
  text: string;
18784
18867
  textSignature?: string;
@@ -18788,9 +18871,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18788
18871
  mimeType: string;
18789
18872
  })[];
18790
18873
  details?: any;
18791
- isError: false;
18792
18874
  };
18793
- status: "completed";
18875
+ status: "running";
18794
18876
  thoughtSignature?: string;
18795
18877
  time: {
18796
18878
  start: number;
@@ -18814,9 +18896,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18814
18896
  mimeType: string;
18815
18897
  })[];
18816
18898
  details?: any;
18817
- isError: true;
18899
+ isError: false;
18818
18900
  };
18819
- status: "error";
18901
+ status: "completed";
18820
18902
  thoughtSignature?: string;
18821
18903
  time: {
18822
18904
  start: number;
@@ -18842,7 +18924,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18842
18924
  details?: any;
18843
18925
  isError: true;
18844
18926
  };
18845
- status: "skipped";
18927
+ status: "error";
18846
18928
  thoughtSignature?: string;
18847
18929
  time: {
18848
18930
  start: number;
@@ -18868,26 +18950,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18868
18950
  details?: any;
18869
18951
  isError: true;
18870
18952
  };
18871
- status: "aborted";
18953
+ status: "skipped";
18872
18954
  thoughtSignature?: string;
18873
18955
  time: {
18874
18956
  start: number;
18875
18957
  end: number;
18876
18958
  };
18877
18959
  type: "toolCall";
18878
- } | {
18879
- type: "thinking";
18880
- thinking: string;
18881
- thinkingSignature?: string;
18882
- redacted?: boolean;
18883
18960
  } | {
18884
18961
  addedToolNames?: string[];
18885
18962
  arguments: Record<string, any>;
18886
18963
  callID: string;
18887
18964
  name: string;
18888
18965
  namespace?: string;
18889
- partial?: {
18890
- content?: ({
18966
+ result: {
18967
+ content: ({
18891
18968
  type: "text";
18892
18969
  text: string;
18893
18970
  textSignature?: string;
@@ -18897,8 +18974,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18897
18974
  mimeType: string;
18898
18975
  })[];
18899
18976
  details?: any;
18977
+ isError: true;
18900
18978
  };
18901
- status: "running";
18979
+ status: "aborted";
18902
18980
  thoughtSignature?: string;
18903
18981
  time: {
18904
18982
  start: number;
@@ -18954,6 +19032,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
18954
19032
  options?: Record<string, any>;
18955
19033
  };
18956
19034
  model: string;
19035
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
19036
+ providerThinkingLevel?: string;
18957
19037
  usage: {
18958
19038
  input: number;
18959
19039
  output: number;
@@ -19090,14 +19170,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19090
19170
  type: "image";
19091
19171
  data: string;
19092
19172
  mimeType: string;
19173
+ } | {
19174
+ type: "thinking";
19175
+ thinking: string;
19176
+ thinkingSignature?: string;
19177
+ redacted?: boolean;
19093
19178
  } | {
19094
19179
  addedToolNames?: string[];
19095
19180
  arguments: Record<string, any>;
19096
19181
  callID: string;
19097
19182
  name: string;
19098
19183
  namespace?: string;
19099
- result: {
19100
- content: ({
19184
+ partial?: {
19185
+ content?: ({
19101
19186
  type: "text";
19102
19187
  text: string;
19103
19188
  textSignature?: string;
@@ -19107,9 +19192,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19107
19192
  mimeType: string;
19108
19193
  })[];
19109
19194
  details?: any;
19110
- isError: false;
19111
19195
  };
19112
- status: "completed";
19196
+ status: "running";
19113
19197
  thoughtSignature?: string;
19114
19198
  time: {
19115
19199
  start: number;
@@ -19133,9 +19217,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19133
19217
  mimeType: string;
19134
19218
  })[];
19135
19219
  details?: any;
19136
- isError: true;
19220
+ isError: false;
19137
19221
  };
19138
- status: "error";
19222
+ status: "completed";
19139
19223
  thoughtSignature?: string;
19140
19224
  time: {
19141
19225
  start: number;
@@ -19161,7 +19245,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19161
19245
  details?: any;
19162
19246
  isError: true;
19163
19247
  };
19164
- status: "skipped";
19248
+ status: "error";
19165
19249
  thoughtSignature?: string;
19166
19250
  time: {
19167
19251
  start: number;
@@ -19187,26 +19271,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19187
19271
  details?: any;
19188
19272
  isError: true;
19189
19273
  };
19190
- status: "aborted";
19274
+ status: "skipped";
19191
19275
  thoughtSignature?: string;
19192
19276
  time: {
19193
19277
  start: number;
19194
19278
  end: number;
19195
19279
  };
19196
19280
  type: "toolCall";
19197
- } | {
19198
- type: "thinking";
19199
- thinking: string;
19200
- thinkingSignature?: string;
19201
- redacted?: boolean;
19202
19281
  } | {
19203
19282
  addedToolNames?: string[];
19204
19283
  arguments: Record<string, any>;
19205
19284
  callID: string;
19206
19285
  name: string;
19207
19286
  namespace?: string;
19208
- partial?: {
19209
- content?: ({
19287
+ result: {
19288
+ content: ({
19210
19289
  type: "text";
19211
19290
  text: string;
19212
19291
  textSignature?: string;
@@ -19216,8 +19295,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19216
19295
  mimeType: string;
19217
19296
  })[];
19218
19297
  details?: any;
19298
+ isError: true;
19219
19299
  };
19220
- status: "running";
19300
+ status: "aborted";
19221
19301
  thoughtSignature?: string;
19222
19302
  time: {
19223
19303
  start: number;
@@ -19254,6 +19334,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19254
19334
  options?: Record<string, any>;
19255
19335
  };
19256
19336
  model: string;
19337
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
19338
+ providerThinkingLevel?: string;
19257
19339
  usage: {
19258
19340
  input: number;
19259
19341
  output: number;
@@ -19390,14 +19472,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19390
19472
  type: "image";
19391
19473
  data: string;
19392
19474
  mimeType: string;
19475
+ } | {
19476
+ type: "thinking";
19477
+ thinking: string;
19478
+ thinkingSignature?: string;
19479
+ redacted?: boolean;
19393
19480
  } | {
19394
19481
  addedToolNames?: string[];
19395
19482
  arguments: Record<string, any>;
19396
19483
  callID: string;
19397
19484
  name: string;
19398
19485
  namespace?: string;
19399
- result: {
19400
- content: ({
19486
+ partial?: {
19487
+ content?: ({
19401
19488
  type: "text";
19402
19489
  text: string;
19403
19490
  textSignature?: string;
@@ -19407,9 +19494,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19407
19494
  mimeType: string;
19408
19495
  })[];
19409
19496
  details?: any;
19410
- isError: false;
19411
19497
  };
19412
- status: "completed";
19498
+ status: "running";
19413
19499
  thoughtSignature?: string;
19414
19500
  time: {
19415
19501
  start: number;
@@ -19433,9 +19519,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19433
19519
  mimeType: string;
19434
19520
  })[];
19435
19521
  details?: any;
19436
- isError: true;
19522
+ isError: false;
19437
19523
  };
19438
- status: "error";
19524
+ status: "completed";
19439
19525
  thoughtSignature?: string;
19440
19526
  time: {
19441
19527
  start: number;
@@ -19461,7 +19547,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19461
19547
  details?: any;
19462
19548
  isError: true;
19463
19549
  };
19464
- status: "skipped";
19550
+ status: "error";
19465
19551
  thoughtSignature?: string;
19466
19552
  time: {
19467
19553
  start: number;
@@ -19487,26 +19573,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19487
19573
  details?: any;
19488
19574
  isError: true;
19489
19575
  };
19490
- status: "aborted";
19576
+ status: "skipped";
19491
19577
  thoughtSignature?: string;
19492
19578
  time: {
19493
19579
  start: number;
19494
19580
  end: number;
19495
19581
  };
19496
19582
  type: "toolCall";
19497
- } | {
19498
- type: "thinking";
19499
- thinking: string;
19500
- thinkingSignature?: string;
19501
- redacted?: boolean;
19502
19583
  } | {
19503
19584
  addedToolNames?: string[];
19504
19585
  arguments: Record<string, any>;
19505
19586
  callID: string;
19506
19587
  name: string;
19507
19588
  namespace?: string;
19508
- partial?: {
19509
- content?: ({
19589
+ result: {
19590
+ content: ({
19510
19591
  type: "text";
19511
19592
  text: string;
19512
19593
  textSignature?: string;
@@ -19516,8 +19597,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
19516
19597
  mimeType: string;
19517
19598
  })[];
19518
19599
  details?: any;
19600
+ isError: true;
19519
19601
  };
19520
- status: "running";
19602
+ status: "aborted";
19521
19603
  thoughtSignature?: string;
19522
19604
  time: {
19523
19605
  start: number;
@@ -20567,6 +20649,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20567
20649
  options?: Record<string, any>;
20568
20650
  };
20569
20651
  model: string;
20652
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
20653
+ providerThinkingLevel?: string;
20570
20654
  usage: {
20571
20655
  input: number;
20572
20656
  output: number;
@@ -20703,14 +20787,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20703
20787
  type: "image";
20704
20788
  data: string;
20705
20789
  mimeType: string;
20790
+ } | {
20791
+ type: "thinking";
20792
+ thinking: string;
20793
+ thinkingSignature?: string;
20794
+ redacted?: boolean;
20706
20795
  } | {
20707
20796
  addedToolNames?: string[];
20708
20797
  arguments: Record<string, any>;
20709
20798
  callID: string;
20710
20799
  name: string;
20711
20800
  namespace?: string;
20712
- result: {
20713
- content: ({
20801
+ partial?: {
20802
+ content?: ({
20714
20803
  type: "text";
20715
20804
  text: string;
20716
20805
  textSignature?: string;
@@ -20720,9 +20809,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20720
20809
  mimeType: string;
20721
20810
  })[];
20722
20811
  details?: any;
20723
- isError: false;
20724
20812
  };
20725
- status: "completed";
20813
+ status: "running";
20726
20814
  thoughtSignature?: string;
20727
20815
  time: {
20728
20816
  start: number;
@@ -20746,9 +20834,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20746
20834
  mimeType: string;
20747
20835
  })[];
20748
20836
  details?: any;
20749
- isError: true;
20837
+ isError: false;
20750
20838
  };
20751
- status: "error";
20839
+ status: "completed";
20752
20840
  thoughtSignature?: string;
20753
20841
  time: {
20754
20842
  start: number;
@@ -20774,7 +20862,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20774
20862
  details?: any;
20775
20863
  isError: true;
20776
20864
  };
20777
- status: "skipped";
20865
+ status: "error";
20778
20866
  thoughtSignature?: string;
20779
20867
  time: {
20780
20868
  start: number;
@@ -20800,26 +20888,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20800
20888
  details?: any;
20801
20889
  isError: true;
20802
20890
  };
20803
- status: "aborted";
20891
+ status: "skipped";
20804
20892
  thoughtSignature?: string;
20805
20893
  time: {
20806
20894
  start: number;
20807
20895
  end: number;
20808
20896
  };
20809
20897
  type: "toolCall";
20810
- } | {
20811
- type: "thinking";
20812
- thinking: string;
20813
- thinkingSignature?: string;
20814
- redacted?: boolean;
20815
20898
  } | {
20816
20899
  addedToolNames?: string[];
20817
20900
  arguments: Record<string, any>;
20818
20901
  callID: string;
20819
20902
  name: string;
20820
20903
  namespace?: string;
20821
- partial?: {
20822
- content?: ({
20904
+ result: {
20905
+ content: ({
20823
20906
  type: "text";
20824
20907
  text: string;
20825
20908
  textSignature?: string;
@@ -20829,8 +20912,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20829
20912
  mimeType: string;
20830
20913
  })[];
20831
20914
  details?: any;
20915
+ isError: true;
20832
20916
  };
20833
- status: "running";
20917
+ status: "aborted";
20834
20918
  thoughtSignature?: string;
20835
20919
  time: {
20836
20920
  start: number;
@@ -20867,6 +20951,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
20867
20951
  options?: Record<string, any>;
20868
20952
  };
20869
20953
  model: string;
20954
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
20955
+ providerThinkingLevel?: string;
20870
20956
  usage: {
20871
20957
  input: number;
20872
20958
  output: number;
@@ -21003,14 +21089,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21003
21089
  type: "image";
21004
21090
  data: string;
21005
21091
  mimeType: string;
21092
+ } | {
21093
+ type: "thinking";
21094
+ thinking: string;
21095
+ thinkingSignature?: string;
21096
+ redacted?: boolean;
21006
21097
  } | {
21007
21098
  addedToolNames?: string[];
21008
21099
  arguments: Record<string, any>;
21009
21100
  callID: string;
21010
21101
  name: string;
21011
21102
  namespace?: string;
21012
- result: {
21013
- content: ({
21103
+ partial?: {
21104
+ content?: ({
21014
21105
  type: "text";
21015
21106
  text: string;
21016
21107
  textSignature?: string;
@@ -21020,9 +21111,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21020
21111
  mimeType: string;
21021
21112
  })[];
21022
21113
  details?: any;
21023
- isError: false;
21024
21114
  };
21025
- status: "completed";
21115
+ status: "running";
21026
21116
  thoughtSignature?: string;
21027
21117
  time: {
21028
21118
  start: number;
@@ -21046,9 +21136,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21046
21136
  mimeType: string;
21047
21137
  })[];
21048
21138
  details?: any;
21049
- isError: true;
21139
+ isError: false;
21050
21140
  };
21051
- status: "error";
21141
+ status: "completed";
21052
21142
  thoughtSignature?: string;
21053
21143
  time: {
21054
21144
  start: number;
@@ -21074,7 +21164,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21074
21164
  details?: any;
21075
21165
  isError: true;
21076
21166
  };
21077
- status: "skipped";
21167
+ status: "error";
21078
21168
  thoughtSignature?: string;
21079
21169
  time: {
21080
21170
  start: number;
@@ -21100,26 +21190,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21100
21190
  details?: any;
21101
21191
  isError: true;
21102
21192
  };
21103
- status: "aborted";
21193
+ status: "skipped";
21104
21194
  thoughtSignature?: string;
21105
21195
  time: {
21106
21196
  start: number;
21107
21197
  end: number;
21108
21198
  };
21109
21199
  type: "toolCall";
21110
- } | {
21111
- type: "thinking";
21112
- thinking: string;
21113
- thinkingSignature?: string;
21114
- redacted?: boolean;
21115
21200
  } | {
21116
21201
  addedToolNames?: string[];
21117
21202
  arguments: Record<string, any>;
21118
21203
  callID: string;
21119
21204
  name: string;
21120
21205
  namespace?: string;
21121
- partial?: {
21122
- content?: ({
21206
+ result: {
21207
+ content: ({
21123
21208
  type: "text";
21124
21209
  text: string;
21125
21210
  textSignature?: string;
@@ -21129,8 +21214,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21129
21214
  mimeType: string;
21130
21215
  })[];
21131
21216
  details?: any;
21217
+ isError: true;
21132
21218
  };
21133
- status: "running";
21219
+ status: "aborted";
21134
21220
  thoughtSignature?: string;
21135
21221
  time: {
21136
21222
  start: number;
@@ -21185,6 +21271,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21185
21271
  options?: Record<string, any>;
21186
21272
  };
21187
21273
  model: string;
21274
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
21275
+ providerThinkingLevel?: string;
21188
21276
  usage: {
21189
21277
  input: number;
21190
21278
  output: number;
@@ -21321,14 +21409,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21321
21409
  type: "image";
21322
21410
  data: string;
21323
21411
  mimeType: string;
21412
+ } | {
21413
+ type: "thinking";
21414
+ thinking: string;
21415
+ thinkingSignature?: string;
21416
+ redacted?: boolean;
21324
21417
  } | {
21325
21418
  addedToolNames?: string[];
21326
21419
  arguments: Record<string, any>;
21327
21420
  callID: string;
21328
21421
  name: string;
21329
21422
  namespace?: string;
21330
- result: {
21331
- content: ({
21423
+ partial?: {
21424
+ content?: ({
21332
21425
  type: "text";
21333
21426
  text: string;
21334
21427
  textSignature?: string;
@@ -21338,9 +21431,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21338
21431
  mimeType: string;
21339
21432
  })[];
21340
21433
  details?: any;
21341
- isError: false;
21342
21434
  };
21343
- status: "completed";
21435
+ status: "running";
21344
21436
  thoughtSignature?: string;
21345
21437
  time: {
21346
21438
  start: number;
@@ -21364,9 +21456,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21364
21456
  mimeType: string;
21365
21457
  })[];
21366
21458
  details?: any;
21367
- isError: true;
21459
+ isError: false;
21368
21460
  };
21369
- status: "error";
21461
+ status: "completed";
21370
21462
  thoughtSignature?: string;
21371
21463
  time: {
21372
21464
  start: number;
@@ -21392,7 +21484,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21392
21484
  details?: any;
21393
21485
  isError: true;
21394
21486
  };
21395
- status: "skipped";
21487
+ status: "error";
21396
21488
  thoughtSignature?: string;
21397
21489
  time: {
21398
21490
  start: number;
@@ -21418,26 +21510,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21418
21510
  details?: any;
21419
21511
  isError: true;
21420
21512
  };
21421
- status: "aborted";
21513
+ status: "skipped";
21422
21514
  thoughtSignature?: string;
21423
21515
  time: {
21424
21516
  start: number;
21425
21517
  end: number;
21426
21518
  };
21427
21519
  type: "toolCall";
21428
- } | {
21429
- type: "thinking";
21430
- thinking: string;
21431
- thinkingSignature?: string;
21432
- redacted?: boolean;
21433
21520
  } | {
21434
21521
  addedToolNames?: string[];
21435
21522
  arguments: Record<string, any>;
21436
21523
  callID: string;
21437
21524
  name: string;
21438
21525
  namespace?: string;
21439
- partial?: {
21440
- content?: ({
21526
+ result: {
21527
+ content: ({
21441
21528
  type: "text";
21442
21529
  text: string;
21443
21530
  textSignature?: string;
@@ -21447,8 +21534,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21447
21534
  mimeType: string;
21448
21535
  })[];
21449
21536
  details?: any;
21537
+ isError: true;
21450
21538
  };
21451
- status: "running";
21539
+ status: "aborted";
21452
21540
  thoughtSignature?: string;
21453
21541
  time: {
21454
21542
  start: number;
@@ -21485,6 +21573,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21485
21573
  options?: Record<string, any>;
21486
21574
  };
21487
21575
  model: string;
21576
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
21577
+ providerThinkingLevel?: string;
21488
21578
  usage: {
21489
21579
  input: number;
21490
21580
  output: number;
@@ -21621,14 +21711,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21621
21711
  type: "image";
21622
21712
  data: string;
21623
21713
  mimeType: string;
21714
+ } | {
21715
+ type: "thinking";
21716
+ thinking: string;
21717
+ thinkingSignature?: string;
21718
+ redacted?: boolean;
21624
21719
  } | {
21625
21720
  addedToolNames?: string[];
21626
21721
  arguments: Record<string, any>;
21627
21722
  callID: string;
21628
21723
  name: string;
21629
21724
  namespace?: string;
21630
- result: {
21631
- content: ({
21725
+ partial?: {
21726
+ content?: ({
21632
21727
  type: "text";
21633
21728
  text: string;
21634
21729
  textSignature?: string;
@@ -21638,9 +21733,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21638
21733
  mimeType: string;
21639
21734
  })[];
21640
21735
  details?: any;
21641
- isError: false;
21642
21736
  };
21643
- status: "completed";
21737
+ status: "running";
21644
21738
  thoughtSignature?: string;
21645
21739
  time: {
21646
21740
  start: number;
@@ -21664,9 +21758,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21664
21758
  mimeType: string;
21665
21759
  })[];
21666
21760
  details?: any;
21667
- isError: true;
21761
+ isError: false;
21668
21762
  };
21669
- status: "error";
21763
+ status: "completed";
21670
21764
  thoughtSignature?: string;
21671
21765
  time: {
21672
21766
  start: number;
@@ -21692,7 +21786,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21692
21786
  details?: any;
21693
21787
  isError: true;
21694
21788
  };
21695
- status: "skipped";
21789
+ status: "error";
21696
21790
  thoughtSignature?: string;
21697
21791
  time: {
21698
21792
  start: number;
@@ -21718,26 +21812,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21718
21812
  details?: any;
21719
21813
  isError: true;
21720
21814
  };
21721
- status: "aborted";
21815
+ status: "skipped";
21722
21816
  thoughtSignature?: string;
21723
21817
  time: {
21724
21818
  start: number;
21725
21819
  end: number;
21726
21820
  };
21727
21821
  type: "toolCall";
21728
- } | {
21729
- type: "thinking";
21730
- thinking: string;
21731
- thinkingSignature?: string;
21732
- redacted?: boolean;
21733
21822
  } | {
21734
21823
  addedToolNames?: string[];
21735
21824
  arguments: Record<string, any>;
21736
21825
  callID: string;
21737
21826
  name: string;
21738
21827
  namespace?: string;
21739
- partial?: {
21740
- content?: ({
21828
+ result: {
21829
+ content: ({
21741
21830
  type: "text";
21742
21831
  text: string;
21743
21832
  textSignature?: string;
@@ -21747,8 +21836,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21747
21836
  mimeType: string;
21748
21837
  })[];
21749
21838
  details?: any;
21839
+ isError: true;
21750
21840
  };
21751
- status: "running";
21841
+ status: "aborted";
21752
21842
  thoughtSignature?: string;
21753
21843
  time: {
21754
21844
  start: number;
@@ -21813,6 +21903,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21813
21903
  options?: Record<string, any>;
21814
21904
  };
21815
21905
  model: string;
21906
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
21907
+ providerThinkingLevel?: string;
21816
21908
  usage: {
21817
21909
  input: number;
21818
21910
  output: number;
@@ -21949,14 +22041,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21949
22041
  type: "image";
21950
22042
  data: string;
21951
22043
  mimeType: string;
22044
+ } | {
22045
+ type: "thinking";
22046
+ thinking: string;
22047
+ thinkingSignature?: string;
22048
+ redacted?: boolean;
21952
22049
  } | {
21953
22050
  addedToolNames?: string[];
21954
22051
  arguments: Record<string, any>;
21955
22052
  callID: string;
21956
22053
  name: string;
21957
22054
  namespace?: string;
21958
- result: {
21959
- content: ({
22055
+ partial?: {
22056
+ content?: ({
21960
22057
  type: "text";
21961
22058
  text: string;
21962
22059
  textSignature?: string;
@@ -21966,9 +22063,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21966
22063
  mimeType: string;
21967
22064
  })[];
21968
22065
  details?: any;
21969
- isError: false;
21970
22066
  };
21971
- status: "completed";
22067
+ status: "running";
21972
22068
  thoughtSignature?: string;
21973
22069
  time: {
21974
22070
  start: number;
@@ -21992,9 +22088,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
21992
22088
  mimeType: string;
21993
22089
  })[];
21994
22090
  details?: any;
21995
- isError: true;
22091
+ isError: false;
21996
22092
  };
21997
- status: "error";
22093
+ status: "completed";
21998
22094
  thoughtSignature?: string;
21999
22095
  time: {
22000
22096
  start: number;
@@ -22020,7 +22116,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22020
22116
  details?: any;
22021
22117
  isError: true;
22022
22118
  };
22023
- status: "skipped";
22119
+ status: "error";
22024
22120
  thoughtSignature?: string;
22025
22121
  time: {
22026
22122
  start: number;
@@ -22046,26 +22142,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22046
22142
  details?: any;
22047
22143
  isError: true;
22048
22144
  };
22049
- status: "aborted";
22145
+ status: "skipped";
22050
22146
  thoughtSignature?: string;
22051
22147
  time: {
22052
22148
  start: number;
22053
22149
  end: number;
22054
22150
  };
22055
22151
  type: "toolCall";
22056
- } | {
22057
- type: "thinking";
22058
- thinking: string;
22059
- thinkingSignature?: string;
22060
- redacted?: boolean;
22061
22152
  } | {
22062
22153
  addedToolNames?: string[];
22063
22154
  arguments: Record<string, any>;
22064
22155
  callID: string;
22065
22156
  name: string;
22066
22157
  namespace?: string;
22067
- partial?: {
22068
- content?: ({
22158
+ result: {
22159
+ content: ({
22069
22160
  type: "text";
22070
22161
  text: string;
22071
22162
  textSignature?: string;
@@ -22075,8 +22166,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22075
22166
  mimeType: string;
22076
22167
  })[];
22077
22168
  details?: any;
22169
+ isError: true;
22078
22170
  };
22079
- status: "running";
22171
+ status: "aborted";
22080
22172
  thoughtSignature?: string;
22081
22173
  time: {
22082
22174
  start: number;
@@ -22113,6 +22205,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22113
22205
  options?: Record<string, any>;
22114
22206
  };
22115
22207
  model: string;
22208
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
22209
+ providerThinkingLevel?: string;
22116
22210
  usage: {
22117
22211
  input: number;
22118
22212
  output: number;
@@ -22249,14 +22343,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22249
22343
  type: "image";
22250
22344
  data: string;
22251
22345
  mimeType: string;
22346
+ } | {
22347
+ type: "thinking";
22348
+ thinking: string;
22349
+ thinkingSignature?: string;
22350
+ redacted?: boolean;
22252
22351
  } | {
22253
22352
  addedToolNames?: string[];
22254
22353
  arguments: Record<string, any>;
22255
22354
  callID: string;
22256
22355
  name: string;
22257
22356
  namespace?: string;
22258
- result: {
22259
- content: ({
22357
+ partial?: {
22358
+ content?: ({
22260
22359
  type: "text";
22261
22360
  text: string;
22262
22361
  textSignature?: string;
@@ -22266,9 +22365,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22266
22365
  mimeType: string;
22267
22366
  })[];
22268
22367
  details?: any;
22269
- isError: false;
22270
22368
  };
22271
- status: "completed";
22369
+ status: "running";
22272
22370
  thoughtSignature?: string;
22273
22371
  time: {
22274
22372
  start: number;
@@ -22292,9 +22390,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22292
22390
  mimeType: string;
22293
22391
  })[];
22294
22392
  details?: any;
22295
- isError: true;
22393
+ isError: false;
22296
22394
  };
22297
- status: "error";
22395
+ status: "completed";
22298
22396
  thoughtSignature?: string;
22299
22397
  time: {
22300
22398
  start: number;
@@ -22320,7 +22418,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22320
22418
  details?: any;
22321
22419
  isError: true;
22322
22420
  };
22323
- status: "skipped";
22421
+ status: "error";
22324
22422
  thoughtSignature?: string;
22325
22423
  time: {
22326
22424
  start: number;
@@ -22346,26 +22444,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22346
22444
  details?: any;
22347
22445
  isError: true;
22348
22446
  };
22349
- status: "aborted";
22447
+ status: "skipped";
22350
22448
  thoughtSignature?: string;
22351
22449
  time: {
22352
22450
  start: number;
22353
22451
  end: number;
22354
22452
  };
22355
22453
  type: "toolCall";
22356
- } | {
22357
- type: "thinking";
22358
- thinking: string;
22359
- thinkingSignature?: string;
22360
- redacted?: boolean;
22361
22454
  } | {
22362
22455
  addedToolNames?: string[];
22363
22456
  arguments: Record<string, any>;
22364
22457
  callID: string;
22365
22458
  name: string;
22366
22459
  namespace?: string;
22367
- partial?: {
22368
- content?: ({
22460
+ result: {
22461
+ content: ({
22369
22462
  type: "text";
22370
22463
  text: string;
22371
22464
  textSignature?: string;
@@ -22375,8 +22468,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22375
22468
  mimeType: string;
22376
22469
  })[];
22377
22470
  details?: any;
22471
+ isError: true;
22378
22472
  };
22379
- status: "running";
22473
+ status: "aborted";
22380
22474
  thoughtSignature?: string;
22381
22475
  time: {
22382
22476
  start: number;
@@ -22432,6 +22526,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22432
22526
  options?: Record<string, any>;
22433
22527
  };
22434
22528
  model: string;
22529
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
22530
+ providerThinkingLevel?: string;
22435
22531
  usage: {
22436
22532
  input: number;
22437
22533
  output: number;
@@ -22568,14 +22664,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22568
22664
  type: "image";
22569
22665
  data: string;
22570
22666
  mimeType: string;
22667
+ } | {
22668
+ type: "thinking";
22669
+ thinking: string;
22670
+ thinkingSignature?: string;
22671
+ redacted?: boolean;
22571
22672
  } | {
22572
22673
  addedToolNames?: string[];
22573
22674
  arguments: Record<string, any>;
22574
22675
  callID: string;
22575
22676
  name: string;
22576
22677
  namespace?: string;
22577
- result: {
22578
- content: ({
22678
+ partial?: {
22679
+ content?: ({
22579
22680
  type: "text";
22580
22681
  text: string;
22581
22682
  textSignature?: string;
@@ -22585,9 +22686,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22585
22686
  mimeType: string;
22586
22687
  })[];
22587
22688
  details?: any;
22588
- isError: false;
22589
22689
  };
22590
- status: "completed";
22690
+ status: "running";
22591
22691
  thoughtSignature?: string;
22592
22692
  time: {
22593
22693
  start: number;
@@ -22611,9 +22711,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22611
22711
  mimeType: string;
22612
22712
  })[];
22613
22713
  details?: any;
22614
- isError: true;
22714
+ isError: false;
22615
22715
  };
22616
- status: "error";
22716
+ status: "completed";
22617
22717
  thoughtSignature?: string;
22618
22718
  time: {
22619
22719
  start: number;
@@ -22639,7 +22739,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22639
22739
  details?: any;
22640
22740
  isError: true;
22641
22741
  };
22642
- status: "skipped";
22742
+ status: "error";
22643
22743
  thoughtSignature?: string;
22644
22744
  time: {
22645
22745
  start: number;
@@ -22665,26 +22765,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22665
22765
  details?: any;
22666
22766
  isError: true;
22667
22767
  };
22668
- status: "aborted";
22768
+ status: "skipped";
22669
22769
  thoughtSignature?: string;
22670
22770
  time: {
22671
22771
  start: number;
22672
22772
  end: number;
22673
22773
  };
22674
22774
  type: "toolCall";
22675
- } | {
22676
- type: "thinking";
22677
- thinking: string;
22678
- thinkingSignature?: string;
22679
- redacted?: boolean;
22680
22775
  } | {
22681
22776
  addedToolNames?: string[];
22682
22777
  arguments: Record<string, any>;
22683
22778
  callID: string;
22684
22779
  name: string;
22685
22780
  namespace?: string;
22686
- partial?: {
22687
- content?: ({
22781
+ result: {
22782
+ content: ({
22688
22783
  type: "text";
22689
22784
  text: string;
22690
22785
  textSignature?: string;
@@ -22694,8 +22789,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22694
22789
  mimeType: string;
22695
22790
  })[];
22696
22791
  details?: any;
22792
+ isError: true;
22697
22793
  };
22698
- status: "running";
22794
+ status: "aborted";
22699
22795
  thoughtSignature?: string;
22700
22796
  time: {
22701
22797
  start: number;
@@ -22732,6 +22828,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22732
22828
  options?: Record<string, any>;
22733
22829
  };
22734
22830
  model: string;
22831
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
22832
+ providerThinkingLevel?: string;
22735
22833
  usage: {
22736
22834
  input: number;
22737
22835
  output: number;
@@ -22868,14 +22966,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22868
22966
  type: "image";
22869
22967
  data: string;
22870
22968
  mimeType: string;
22969
+ } | {
22970
+ type: "thinking";
22971
+ thinking: string;
22972
+ thinkingSignature?: string;
22973
+ redacted?: boolean;
22871
22974
  } | {
22872
22975
  addedToolNames?: string[];
22873
22976
  arguments: Record<string, any>;
22874
22977
  callID: string;
22875
22978
  name: string;
22876
22979
  namespace?: string;
22877
- result: {
22878
- content: ({
22980
+ partial?: {
22981
+ content?: ({
22879
22982
  type: "text";
22880
22983
  text: string;
22881
22984
  textSignature?: string;
@@ -22885,9 +22988,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22885
22988
  mimeType: string;
22886
22989
  })[];
22887
22990
  details?: any;
22888
- isError: false;
22889
22991
  };
22890
- status: "completed";
22992
+ status: "running";
22891
22993
  thoughtSignature?: string;
22892
22994
  time: {
22893
22995
  start: number;
@@ -22911,9 +23013,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22911
23013
  mimeType: string;
22912
23014
  })[];
22913
23015
  details?: any;
22914
- isError: true;
23016
+ isError: false;
22915
23017
  };
22916
- status: "error";
23018
+ status: "completed";
22917
23019
  thoughtSignature?: string;
22918
23020
  time: {
22919
23021
  start: number;
@@ -22939,7 +23041,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22939
23041
  details?: any;
22940
23042
  isError: true;
22941
23043
  };
22942
- status: "skipped";
23044
+ status: "error";
22943
23045
  thoughtSignature?: string;
22944
23046
  time: {
22945
23047
  start: number;
@@ -22965,26 +23067,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22965
23067
  details?: any;
22966
23068
  isError: true;
22967
23069
  };
22968
- status: "aborted";
23070
+ status: "skipped";
22969
23071
  thoughtSignature?: string;
22970
23072
  time: {
22971
23073
  start: number;
22972
23074
  end: number;
22973
23075
  };
22974
23076
  type: "toolCall";
22975
- } | {
22976
- type: "thinking";
22977
- thinking: string;
22978
- thinkingSignature?: string;
22979
- redacted?: boolean;
22980
23077
  } | {
22981
23078
  addedToolNames?: string[];
22982
23079
  arguments: Record<string, any>;
22983
23080
  callID: string;
22984
23081
  name: string;
22985
23082
  namespace?: string;
22986
- partial?: {
22987
- content?: ({
23083
+ result: {
23084
+ content: ({
22988
23085
  type: "text";
22989
23086
  text: string;
22990
23087
  textSignature?: string;
@@ -22994,8 +23091,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
22994
23091
  mimeType: string;
22995
23092
  })[];
22996
23093
  details?: any;
23094
+ isError: true;
22997
23095
  };
22998
- status: "running";
23096
+ status: "aborted";
22999
23097
  thoughtSignature?: string;
23000
23098
  time: {
23001
23099
  start: number;
@@ -23060,6 +23158,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23060
23158
  options?: Record<string, any>;
23061
23159
  };
23062
23160
  model: string;
23161
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
23162
+ providerThinkingLevel?: string;
23063
23163
  usage: {
23064
23164
  input: number;
23065
23165
  output: number;
@@ -23196,14 +23296,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23196
23296
  type: "image";
23197
23297
  data: string;
23198
23298
  mimeType: string;
23299
+ } | {
23300
+ type: "thinking";
23301
+ thinking: string;
23302
+ thinkingSignature?: string;
23303
+ redacted?: boolean;
23199
23304
  } | {
23200
23305
  addedToolNames?: string[];
23201
23306
  arguments: Record<string, any>;
23202
23307
  callID: string;
23203
23308
  name: string;
23204
23309
  namespace?: string;
23205
- result: {
23206
- content: ({
23310
+ partial?: {
23311
+ content?: ({
23207
23312
  type: "text";
23208
23313
  text: string;
23209
23314
  textSignature?: string;
@@ -23213,9 +23318,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23213
23318
  mimeType: string;
23214
23319
  })[];
23215
23320
  details?: any;
23216
- isError: false;
23217
23321
  };
23218
- status: "completed";
23322
+ status: "running";
23219
23323
  thoughtSignature?: string;
23220
23324
  time: {
23221
23325
  start: number;
@@ -23239,9 +23343,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23239
23343
  mimeType: string;
23240
23344
  })[];
23241
23345
  details?: any;
23242
- isError: true;
23346
+ isError: false;
23243
23347
  };
23244
- status: "error";
23348
+ status: "completed";
23245
23349
  thoughtSignature?: string;
23246
23350
  time: {
23247
23351
  start: number;
@@ -23267,7 +23371,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23267
23371
  details?: any;
23268
23372
  isError: true;
23269
23373
  };
23270
- status: "skipped";
23374
+ status: "error";
23271
23375
  thoughtSignature?: string;
23272
23376
  time: {
23273
23377
  start: number;
@@ -23293,26 +23397,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23293
23397
  details?: any;
23294
23398
  isError: true;
23295
23399
  };
23296
- status: "aborted";
23400
+ status: "skipped";
23297
23401
  thoughtSignature?: string;
23298
23402
  time: {
23299
23403
  start: number;
23300
23404
  end: number;
23301
23405
  };
23302
23406
  type: "toolCall";
23303
- } | {
23304
- type: "thinking";
23305
- thinking: string;
23306
- thinkingSignature?: string;
23307
- redacted?: boolean;
23308
23407
  } | {
23309
23408
  addedToolNames?: string[];
23310
23409
  arguments: Record<string, any>;
23311
23410
  callID: string;
23312
23411
  name: string;
23313
23412
  namespace?: string;
23314
- partial?: {
23315
- content?: ({
23413
+ result: {
23414
+ content: ({
23316
23415
  type: "text";
23317
23416
  text: string;
23318
23417
  textSignature?: string;
@@ -23322,8 +23421,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23322
23421
  mimeType: string;
23323
23422
  })[];
23324
23423
  details?: any;
23424
+ isError: true;
23325
23425
  };
23326
- status: "running";
23426
+ status: "aborted";
23327
23427
  thoughtSignature?: string;
23328
23428
  time: {
23329
23429
  start: number;
@@ -23360,6 +23460,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23360
23460
  options?: Record<string, any>;
23361
23461
  };
23362
23462
  model: string;
23463
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
23464
+ providerThinkingLevel?: string;
23363
23465
  usage: {
23364
23466
  input: number;
23365
23467
  output: number;
@@ -23496,14 +23598,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23496
23598
  type: "image";
23497
23599
  data: string;
23498
23600
  mimeType: string;
23601
+ } | {
23602
+ type: "thinking";
23603
+ thinking: string;
23604
+ thinkingSignature?: string;
23605
+ redacted?: boolean;
23499
23606
  } | {
23500
23607
  addedToolNames?: string[];
23501
23608
  arguments: Record<string, any>;
23502
23609
  callID: string;
23503
23610
  name: string;
23504
23611
  namespace?: string;
23505
- result: {
23506
- content: ({
23612
+ partial?: {
23613
+ content?: ({
23507
23614
  type: "text";
23508
23615
  text: string;
23509
23616
  textSignature?: string;
@@ -23513,9 +23620,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23513
23620
  mimeType: string;
23514
23621
  })[];
23515
23622
  details?: any;
23516
- isError: false;
23517
23623
  };
23518
- status: "completed";
23624
+ status: "running";
23519
23625
  thoughtSignature?: string;
23520
23626
  time: {
23521
23627
  start: number;
@@ -23539,9 +23645,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23539
23645
  mimeType: string;
23540
23646
  })[];
23541
23647
  details?: any;
23542
- isError: true;
23648
+ isError: false;
23543
23649
  };
23544
- status: "error";
23650
+ status: "completed";
23545
23651
  thoughtSignature?: string;
23546
23652
  time: {
23547
23653
  start: number;
@@ -23567,7 +23673,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23567
23673
  details?: any;
23568
23674
  isError: true;
23569
23675
  };
23570
- status: "skipped";
23676
+ status: "error";
23571
23677
  thoughtSignature?: string;
23572
23678
  time: {
23573
23679
  start: number;
@@ -23593,26 +23699,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23593
23699
  details?: any;
23594
23700
  isError: true;
23595
23701
  };
23596
- status: "aborted";
23702
+ status: "skipped";
23597
23703
  thoughtSignature?: string;
23598
23704
  time: {
23599
23705
  start: number;
23600
23706
  end: number;
23601
23707
  };
23602
23708
  type: "toolCall";
23603
- } | {
23604
- type: "thinking";
23605
- thinking: string;
23606
- thinkingSignature?: string;
23607
- redacted?: boolean;
23608
23709
  } | {
23609
23710
  addedToolNames?: string[];
23610
23711
  arguments: Record<string, any>;
23611
23712
  callID: string;
23612
23713
  name: string;
23613
23714
  namespace?: string;
23614
- partial?: {
23615
- content?: ({
23715
+ result: {
23716
+ content: ({
23616
23717
  type: "text";
23617
23718
  text: string;
23618
23719
  textSignature?: string;
@@ -23622,8 +23723,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23622
23723
  mimeType: string;
23623
23724
  })[];
23624
23725
  details?: any;
23726
+ isError: true;
23625
23727
  };
23626
- status: "running";
23728
+ status: "aborted";
23627
23729
  thoughtSignature?: string;
23628
23730
  time: {
23629
23731
  start: number;
@@ -23679,6 +23781,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23679
23781
  options?: Record<string, any>;
23680
23782
  };
23681
23783
  model: string;
23784
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
23785
+ providerThinkingLevel?: string;
23682
23786
  usage: {
23683
23787
  input: number;
23684
23788
  output: number;
@@ -23815,14 +23919,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23815
23919
  type: "image";
23816
23920
  data: string;
23817
23921
  mimeType: string;
23922
+ } | {
23923
+ type: "thinking";
23924
+ thinking: string;
23925
+ thinkingSignature?: string;
23926
+ redacted?: boolean;
23818
23927
  } | {
23819
23928
  addedToolNames?: string[];
23820
23929
  arguments: Record<string, any>;
23821
23930
  callID: string;
23822
23931
  name: string;
23823
23932
  namespace?: string;
23824
- result: {
23825
- content: ({
23933
+ partial?: {
23934
+ content?: ({
23826
23935
  type: "text";
23827
23936
  text: string;
23828
23937
  textSignature?: string;
@@ -23832,9 +23941,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23832
23941
  mimeType: string;
23833
23942
  })[];
23834
23943
  details?: any;
23835
- isError: false;
23836
23944
  };
23837
- status: "completed";
23945
+ status: "running";
23838
23946
  thoughtSignature?: string;
23839
23947
  time: {
23840
23948
  start: number;
@@ -23858,9 +23966,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23858
23966
  mimeType: string;
23859
23967
  })[];
23860
23968
  details?: any;
23861
- isError: true;
23969
+ isError: false;
23862
23970
  };
23863
- status: "error";
23971
+ status: "completed";
23864
23972
  thoughtSignature?: string;
23865
23973
  time: {
23866
23974
  start: number;
@@ -23886,7 +23994,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23886
23994
  details?: any;
23887
23995
  isError: true;
23888
23996
  };
23889
- status: "skipped";
23997
+ status: "error";
23890
23998
  thoughtSignature?: string;
23891
23999
  time: {
23892
24000
  start: number;
@@ -23912,26 +24020,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23912
24020
  details?: any;
23913
24021
  isError: true;
23914
24022
  };
23915
- status: "aborted";
24023
+ status: "skipped";
23916
24024
  thoughtSignature?: string;
23917
24025
  time: {
23918
24026
  start: number;
23919
24027
  end: number;
23920
24028
  };
23921
24029
  type: "toolCall";
23922
- } | {
23923
- type: "thinking";
23924
- thinking: string;
23925
- thinkingSignature?: string;
23926
- redacted?: boolean;
23927
24030
  } | {
23928
24031
  addedToolNames?: string[];
23929
24032
  arguments: Record<string, any>;
23930
24033
  callID: string;
23931
24034
  name: string;
23932
24035
  namespace?: string;
23933
- partial?: {
23934
- content?: ({
24036
+ result: {
24037
+ content: ({
23935
24038
  type: "text";
23936
24039
  text: string;
23937
24040
  textSignature?: string;
@@ -23941,8 +24044,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23941
24044
  mimeType: string;
23942
24045
  })[];
23943
24046
  details?: any;
24047
+ isError: true;
23944
24048
  };
23945
- status: "running";
24049
+ status: "aborted";
23946
24050
  thoughtSignature?: string;
23947
24051
  time: {
23948
24052
  start: number;
@@ -23979,6 +24083,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
23979
24083
  options?: Record<string, any>;
23980
24084
  };
23981
24085
  model: string;
24086
+ thinkingLevel: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
24087
+ providerThinkingLevel?: string;
23982
24088
  usage: {
23983
24089
  input: number;
23984
24090
  output: number;
@@ -24115,14 +24221,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24115
24221
  type: "image";
24116
24222
  data: string;
24117
24223
  mimeType: string;
24224
+ } | {
24225
+ type: "thinking";
24226
+ thinking: string;
24227
+ thinkingSignature?: string;
24228
+ redacted?: boolean;
24118
24229
  } | {
24119
24230
  addedToolNames?: string[];
24120
24231
  arguments: Record<string, any>;
24121
24232
  callID: string;
24122
24233
  name: string;
24123
24234
  namespace?: string;
24124
- result: {
24125
- content: ({
24235
+ partial?: {
24236
+ content?: ({
24126
24237
  type: "text";
24127
24238
  text: string;
24128
24239
  textSignature?: string;
@@ -24132,9 +24243,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24132
24243
  mimeType: string;
24133
24244
  })[];
24134
24245
  details?: any;
24135
- isError: false;
24136
24246
  };
24137
- status: "completed";
24247
+ status: "running";
24138
24248
  thoughtSignature?: string;
24139
24249
  time: {
24140
24250
  start: number;
@@ -24158,9 +24268,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24158
24268
  mimeType: string;
24159
24269
  })[];
24160
24270
  details?: any;
24161
- isError: true;
24271
+ isError: false;
24162
24272
  };
24163
- status: "error";
24273
+ status: "completed";
24164
24274
  thoughtSignature?: string;
24165
24275
  time: {
24166
24276
  start: number;
@@ -24186,7 +24296,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24186
24296
  details?: any;
24187
24297
  isError: true;
24188
24298
  };
24189
- status: "skipped";
24299
+ status: "error";
24190
24300
  thoughtSignature?: string;
24191
24301
  time: {
24192
24302
  start: number;
@@ -24212,26 +24322,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24212
24322
  details?: any;
24213
24323
  isError: true;
24214
24324
  };
24215
- status: "aborted";
24325
+ status: "skipped";
24216
24326
  thoughtSignature?: string;
24217
24327
  time: {
24218
24328
  start: number;
24219
24329
  end: number;
24220
24330
  };
24221
24331
  type: "toolCall";
24222
- } | {
24223
- type: "thinking";
24224
- thinking: string;
24225
- thinkingSignature?: string;
24226
- redacted?: boolean;
24227
24332
  } | {
24228
24333
  addedToolNames?: string[];
24229
24334
  arguments: Record<string, any>;
24230
24335
  callID: string;
24231
24336
  name: string;
24232
24337
  namespace?: string;
24233
- partial?: {
24234
- content?: ({
24338
+ result: {
24339
+ content: ({
24235
24340
  type: "text";
24236
24341
  text: string;
24237
24342
  textSignature?: string;
@@ -24241,8 +24346,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
24241
24346
  mimeType: string;
24242
24347
  })[];
24243
24348
  details?: any;
24349
+ isError: true;
24244
24350
  };
24245
- status: "running";
24351
+ status: "aborted";
24246
24352
  thoughtSignature?: string;
24247
24353
  time: {
24248
24354
  start: number;