@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/{daytona-BAurx6Gp.mjs → daytona-ByTHZelc.mjs} +24 -14
- package/daytona-ByTHZelc.mjs.map +1 -0
- package/effect.d.mts +900 -794
- package/effect.mjs +1919 -192
- package/effect.mjs.map +1 -1
- package/{index-DIP2u0Pr.d.mts → index-BEZ8eL--.d.mts} +2 -1
- package/{index-DjPzwUHF.d.mts → index-BlvIgEtU.d.mts} +2 -1
- package/package.json +5 -3
- package/resize-Dwv5dCgY.mjs +263 -0
- package/resize-Dwv5dCgY.mjs.map +1 -0
- package/sandboxes/daytona/index.d.mts +1 -1
- package/sandboxes/daytona/index.mjs +1 -1
- package/sandboxes/vercel/index.d.mts +1 -1
- package/sandboxes/vercel/index.mjs +1 -1
- package/tool/image/worker.d.mts +1 -0
- package/tool/image/worker.mjs +19 -0
- package/tool/image/worker.mjs.map +1 -0
- package/{vercel-C0v5nh20.mjs → vercel-3GouQSJI.mjs} +32 -4
- package/vercel-3GouQSJI.mjs.map +1 -0
- package/daytona-BAurx6Gp.mjs.map +0 -1
- package/vercel-C0v5nh20.mjs.map +0 -1
package/effect.d.mts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import "./index-
|
|
2
|
-
import "./index-
|
|
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.
|
|
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
|
-
}
|
|
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
|
-
},
|
|
3044
|
-
declare const
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
4857
|
+
isError: false;
|
|
4842
4858
|
};
|
|
4843
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
5159
|
+
isError: false;
|
|
5142
5160
|
};
|
|
5143
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
5479
|
+
isError: false;
|
|
5460
5480
|
};
|
|
5461
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
5781
|
+
isError: false;
|
|
5760
5782
|
};
|
|
5761
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
6404
|
+
isError: false;
|
|
6381
6405
|
};
|
|
6382
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
6706
|
+
isError: false;
|
|
6681
6707
|
};
|
|
6682
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
7027
|
+
isError: false;
|
|
7000
7028
|
};
|
|
7001
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
7329
|
+
isError: false;
|
|
7300
7330
|
};
|
|
7301
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
7662
|
+
isError: false;
|
|
7631
7663
|
};
|
|
7632
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
7964
|
+
isError: false;
|
|
7931
7965
|
};
|
|
7932
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
8285
|
+
isError: false;
|
|
8250
8286
|
};
|
|
8251
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
8587
|
+
isError: false;
|
|
8550
8588
|
};
|
|
8551
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
10462
|
+
isError: false;
|
|
10423
10463
|
};
|
|
10424
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
10764
|
+
isError: false;
|
|
10723
10765
|
};
|
|
10724
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
11084
|
+
isError: false;
|
|
11041
11085
|
};
|
|
11042
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
11386
|
+
isError: false;
|
|
11341
11387
|
};
|
|
11342
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
11994
|
+
isError: false;
|
|
11947
11995
|
};
|
|
11948
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
12296
|
+
isError: false;
|
|
12247
12297
|
};
|
|
12248
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
12617
|
+
isError: false;
|
|
12566
12618
|
};
|
|
12567
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
12919
|
+
isError: false;
|
|
12866
12920
|
};
|
|
12867
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
13249
|
+
isError: false;
|
|
13194
13250
|
};
|
|
13195
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
13551
|
+
isError: false;
|
|
13494
13552
|
};
|
|
13495
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
13872
|
+
isError: false;
|
|
13813
13873
|
};
|
|
13814
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
14174
|
+
isError: false;
|
|
14113
14175
|
};
|
|
14114
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
15810
|
+
isError: false;
|
|
15747
15811
|
};
|
|
15748
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
16112
|
+
isError: false;
|
|
16047
16113
|
};
|
|
16048
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
16432
|
+
isError: false;
|
|
16365
16433
|
};
|
|
16366
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
16734
|
+
isError: false;
|
|
16665
16735
|
};
|
|
16666
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
17342
|
+
isError: false;
|
|
17271
17343
|
};
|
|
17272
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
17644
|
+
isError: false;
|
|
17571
17645
|
};
|
|
17572
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
17965
|
+
isError: false;
|
|
17890
17966
|
};
|
|
17891
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
18267
|
+
isError: false;
|
|
18190
18268
|
};
|
|
18191
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
18597
|
+
isError: false;
|
|
18518
18598
|
};
|
|
18519
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
18899
|
+
isError: false;
|
|
18818
18900
|
};
|
|
18819
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
19220
|
+
isError: false;
|
|
19137
19221
|
};
|
|
19138
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
19522
|
+
isError: false;
|
|
19437
19523
|
};
|
|
19438
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
20837
|
+
isError: false;
|
|
20750
20838
|
};
|
|
20751
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
21139
|
+
isError: false;
|
|
21050
21140
|
};
|
|
21051
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
21459
|
+
isError: false;
|
|
21368
21460
|
};
|
|
21369
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
21761
|
+
isError: false;
|
|
21668
21762
|
};
|
|
21669
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
22091
|
+
isError: false;
|
|
21996
22092
|
};
|
|
21997
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
22393
|
+
isError: false;
|
|
22296
22394
|
};
|
|
22297
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
22714
|
+
isError: false;
|
|
22615
22715
|
};
|
|
22616
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
23016
|
+
isError: false;
|
|
22915
23017
|
};
|
|
22916
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
23346
|
+
isError: false;
|
|
23243
23347
|
};
|
|
23244
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
23648
|
+
isError: false;
|
|
23543
23649
|
};
|
|
23544
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
23969
|
+
isError: false;
|
|
23862
23970
|
};
|
|
23863
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
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:
|
|
24271
|
+
isError: false;
|
|
24162
24272
|
};
|
|
24163
|
-
status: "
|
|
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: "
|
|
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: "
|
|
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
|
-
|
|
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: "
|
|
24351
|
+
status: "aborted";
|
|
24246
24352
|
thoughtSignature?: string;
|
|
24247
24353
|
time: {
|
|
24248
24354
|
start: number;
|