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