@codeworksh/harness 0.1.0-canary.18.1.g00a873ad → 0.1.0-canary.19.1.gbef2d437
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/effect.d.mts +824 -824
- package/package.json +3 -3
package/effect.d.mts
CHANGED
|
@@ -2710,6 +2710,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
|
|
|
2710
2710
|
declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
|
|
2711
2711
|
declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
|
|
2712
2712
|
declare const encodeMessage: (message: {
|
|
2713
|
+
messageId: string;
|
|
2714
|
+
role: "user";
|
|
2715
|
+
time: {
|
|
2716
|
+
created: number;
|
|
2717
|
+
};
|
|
2718
|
+
parts: ({
|
|
2719
|
+
type: "text";
|
|
2720
|
+
text: string;
|
|
2721
|
+
textSignature?: string;
|
|
2722
|
+
} | {
|
|
2723
|
+
type: "image";
|
|
2724
|
+
data: string;
|
|
2725
|
+
mimeType: string;
|
|
2726
|
+
})[];
|
|
2727
|
+
} | {
|
|
2713
2728
|
role: "assistant";
|
|
2714
2729
|
protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
|
|
2715
2730
|
provider: {
|
|
@@ -2859,19 +2874,14 @@ declare const encodeMessage: (message: {
|
|
|
2859
2874
|
type: "image";
|
|
2860
2875
|
data: string;
|
|
2861
2876
|
mimeType: string;
|
|
2862
|
-
} | {
|
|
2863
|
-
type: "thinking";
|
|
2864
|
-
thinking: string;
|
|
2865
|
-
thinkingSignature?: string;
|
|
2866
|
-
redacted?: boolean;
|
|
2867
2877
|
} | {
|
|
2868
2878
|
addedToolNames?: string[];
|
|
2869
2879
|
arguments: Record<string, any>;
|
|
2870
2880
|
callID: string;
|
|
2871
2881
|
name: string;
|
|
2872
2882
|
namespace?: string;
|
|
2873
|
-
|
|
2874
|
-
content
|
|
2883
|
+
result: {
|
|
2884
|
+
content: ({
|
|
2875
2885
|
type: "text";
|
|
2876
2886
|
text: string;
|
|
2877
2887
|
textSignature?: string;
|
|
@@ -2881,8 +2891,9 @@ declare const encodeMessage: (message: {
|
|
|
2881
2891
|
mimeType: string;
|
|
2882
2892
|
})[];
|
|
2883
2893
|
details?: any;
|
|
2894
|
+
isError: false;
|
|
2884
2895
|
};
|
|
2885
|
-
status: "
|
|
2896
|
+
status: "completed";
|
|
2886
2897
|
thoughtSignature?: string;
|
|
2887
2898
|
time: {
|
|
2888
2899
|
start: number;
|
|
@@ -2906,9 +2917,9 @@ declare const encodeMessage: (message: {
|
|
|
2906
2917
|
mimeType: string;
|
|
2907
2918
|
})[];
|
|
2908
2919
|
details?: any;
|
|
2909
|
-
isError:
|
|
2920
|
+
isError: true;
|
|
2910
2921
|
};
|
|
2911
|
-
status: "
|
|
2922
|
+
status: "error";
|
|
2912
2923
|
thoughtSignature?: string;
|
|
2913
2924
|
time: {
|
|
2914
2925
|
start: number;
|
|
@@ -2934,7 +2945,7 @@ declare const encodeMessage: (message: {
|
|
|
2934
2945
|
details?: any;
|
|
2935
2946
|
isError: true;
|
|
2936
2947
|
};
|
|
2937
|
-
status: "
|
|
2948
|
+
status: "skipped";
|
|
2938
2949
|
thoughtSignature?: string;
|
|
2939
2950
|
time: {
|
|
2940
2951
|
start: number;
|
|
@@ -2960,21 +2971,26 @@ declare const encodeMessage: (message: {
|
|
|
2960
2971
|
details?: any;
|
|
2961
2972
|
isError: true;
|
|
2962
2973
|
};
|
|
2963
|
-
status: "
|
|
2974
|
+
status: "aborted";
|
|
2964
2975
|
thoughtSignature?: string;
|
|
2965
2976
|
time: {
|
|
2966
2977
|
start: number;
|
|
2967
2978
|
end: number;
|
|
2968
2979
|
};
|
|
2969
2980
|
type: "toolCall";
|
|
2981
|
+
} | {
|
|
2982
|
+
type: "thinking";
|
|
2983
|
+
thinking: string;
|
|
2984
|
+
thinkingSignature?: string;
|
|
2985
|
+
redacted?: boolean;
|
|
2970
2986
|
} | {
|
|
2971
2987
|
addedToolNames?: string[];
|
|
2972
2988
|
arguments: Record<string, any>;
|
|
2973
2989
|
callID: string;
|
|
2974
2990
|
name: string;
|
|
2975
2991
|
namespace?: string;
|
|
2976
|
-
|
|
2977
|
-
content
|
|
2992
|
+
partial?: {
|
|
2993
|
+
content?: ({
|
|
2978
2994
|
type: "text";
|
|
2979
2995
|
text: string;
|
|
2980
2996
|
textSignature?: string;
|
|
@@ -2984,9 +3000,8 @@ declare const encodeMessage: (message: {
|
|
|
2984
3000
|
mimeType: string;
|
|
2985
3001
|
})[];
|
|
2986
3002
|
details?: any;
|
|
2987
|
-
isError: true;
|
|
2988
3003
|
};
|
|
2989
|
-
status: "
|
|
3004
|
+
status: "running";
|
|
2990
3005
|
thoughtSignature?: string;
|
|
2991
3006
|
time: {
|
|
2992
3007
|
start: number;
|
|
@@ -3011,7 +3026,8 @@ declare const encodeMessage: (message: {
|
|
|
3011
3026
|
responseId?: string;
|
|
3012
3027
|
responseModel?: string;
|
|
3013
3028
|
messageId: string;
|
|
3014
|
-
}
|
|
3029
|
+
}) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
|
|
3030
|
+
declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3015
3031
|
messageId: string;
|
|
3016
3032
|
role: "user";
|
|
3017
3033
|
time: {
|
|
@@ -3026,8 +3042,8 @@ declare const encodeMessage: (message: {
|
|
|
3026
3042
|
data: string;
|
|
3027
3043
|
mimeType: string;
|
|
3028
3044
|
})[];
|
|
3029
|
-
}
|
|
3030
|
-
declare const
|
|
3045
|
+
}, ContextDecodeError, never>;
|
|
3046
|
+
declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3031
3047
|
messageId: string;
|
|
3032
3048
|
role: "user";
|
|
3033
3049
|
time: {
|
|
@@ -3042,8 +3058,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
|
|
|
3042
3058
|
data: string;
|
|
3043
3059
|
mimeType: string;
|
|
3044
3060
|
})[];
|
|
3045
|
-
}
|
|
3046
|
-
declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3061
|
+
} | {
|
|
3047
3062
|
role: "assistant";
|
|
3048
3063
|
protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
|
|
3049
3064
|
provider: {
|
|
@@ -3193,19 +3208,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3193
3208
|
type: "image";
|
|
3194
3209
|
data: string;
|
|
3195
3210
|
mimeType: string;
|
|
3196
|
-
} | {
|
|
3197
|
-
type: "thinking";
|
|
3198
|
-
thinking: string;
|
|
3199
|
-
thinkingSignature?: string;
|
|
3200
|
-
redacted?: boolean;
|
|
3201
3211
|
} | {
|
|
3202
3212
|
addedToolNames?: string[];
|
|
3203
3213
|
arguments: Record<string, any>;
|
|
3204
3214
|
callID: string;
|
|
3205
3215
|
name: string;
|
|
3206
3216
|
namespace?: string;
|
|
3207
|
-
|
|
3208
|
-
content
|
|
3217
|
+
result: {
|
|
3218
|
+
content: ({
|
|
3209
3219
|
type: "text";
|
|
3210
3220
|
text: string;
|
|
3211
3221
|
textSignature?: string;
|
|
@@ -3215,8 +3225,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3215
3225
|
mimeType: string;
|
|
3216
3226
|
})[];
|
|
3217
3227
|
details?: any;
|
|
3228
|
+
isError: false;
|
|
3218
3229
|
};
|
|
3219
|
-
status: "
|
|
3230
|
+
status: "completed";
|
|
3220
3231
|
thoughtSignature?: string;
|
|
3221
3232
|
time: {
|
|
3222
3233
|
start: number;
|
|
@@ -3240,9 +3251,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3240
3251
|
mimeType: string;
|
|
3241
3252
|
})[];
|
|
3242
3253
|
details?: any;
|
|
3243
|
-
isError:
|
|
3254
|
+
isError: true;
|
|
3244
3255
|
};
|
|
3245
|
-
status: "
|
|
3256
|
+
status: "error";
|
|
3246
3257
|
thoughtSignature?: string;
|
|
3247
3258
|
time: {
|
|
3248
3259
|
start: number;
|
|
@@ -3268,7 +3279,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3268
3279
|
details?: any;
|
|
3269
3280
|
isError: true;
|
|
3270
3281
|
};
|
|
3271
|
-
status: "
|
|
3282
|
+
status: "skipped";
|
|
3272
3283
|
thoughtSignature?: string;
|
|
3273
3284
|
time: {
|
|
3274
3285
|
start: number;
|
|
@@ -3294,21 +3305,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3294
3305
|
details?: any;
|
|
3295
3306
|
isError: true;
|
|
3296
3307
|
};
|
|
3297
|
-
status: "
|
|
3308
|
+
status: "aborted";
|
|
3298
3309
|
thoughtSignature?: string;
|
|
3299
3310
|
time: {
|
|
3300
3311
|
start: number;
|
|
3301
3312
|
end: number;
|
|
3302
3313
|
};
|
|
3303
3314
|
type: "toolCall";
|
|
3315
|
+
} | {
|
|
3316
|
+
type: "thinking";
|
|
3317
|
+
thinking: string;
|
|
3318
|
+
thinkingSignature?: string;
|
|
3319
|
+
redacted?: boolean;
|
|
3304
3320
|
} | {
|
|
3305
3321
|
addedToolNames?: string[];
|
|
3306
3322
|
arguments: Record<string, any>;
|
|
3307
3323
|
callID: string;
|
|
3308
3324
|
name: string;
|
|
3309
3325
|
namespace?: string;
|
|
3310
|
-
|
|
3311
|
-
content
|
|
3326
|
+
partial?: {
|
|
3327
|
+
content?: ({
|
|
3312
3328
|
type: "text";
|
|
3313
3329
|
text: string;
|
|
3314
3330
|
textSignature?: string;
|
|
@@ -3318,9 +3334,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3318
3334
|
mimeType: string;
|
|
3319
3335
|
})[];
|
|
3320
3336
|
details?: any;
|
|
3321
|
-
isError: true;
|
|
3322
3337
|
};
|
|
3323
|
-
status: "
|
|
3338
|
+
status: "running";
|
|
3324
3339
|
thoughtSignature?: string;
|
|
3325
3340
|
time: {
|
|
3326
3341
|
start: number;
|
|
@@ -3345,21 +3360,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3345
3360
|
responseId?: string;
|
|
3346
3361
|
responseModel?: string;
|
|
3347
3362
|
messageId: string;
|
|
3348
|
-
} | {
|
|
3349
|
-
messageId: string;
|
|
3350
|
-
role: "user";
|
|
3351
|
-
time: {
|
|
3352
|
-
created: number;
|
|
3353
|
-
};
|
|
3354
|
-
parts: ({
|
|
3355
|
-
type: "text";
|
|
3356
|
-
text: string;
|
|
3357
|
-
textSignature?: string;
|
|
3358
|
-
} | {
|
|
3359
|
-
type: "image";
|
|
3360
|
-
data: string;
|
|
3361
|
-
mimeType: string;
|
|
3362
|
-
})[];
|
|
3363
3363
|
}, ContextDecodeError, never>;
|
|
3364
3364
|
declare namespace context_d_exports {
|
|
3365
3365
|
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 };
|
|
@@ -4801,19 +4801,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4801
4801
|
type: "image";
|
|
4802
4802
|
data: string;
|
|
4803
4803
|
mimeType: string;
|
|
4804
|
-
} | {
|
|
4805
|
-
type: "thinking";
|
|
4806
|
-
thinking: string;
|
|
4807
|
-
thinkingSignature?: string;
|
|
4808
|
-
redacted?: boolean;
|
|
4809
4804
|
} | {
|
|
4810
4805
|
addedToolNames?: string[];
|
|
4811
4806
|
arguments: Record<string, any>;
|
|
4812
4807
|
callID: string;
|
|
4813
4808
|
name: string;
|
|
4814
4809
|
namespace?: string;
|
|
4815
|
-
|
|
4816
|
-
content
|
|
4810
|
+
result: {
|
|
4811
|
+
content: ({
|
|
4817
4812
|
type: "text";
|
|
4818
4813
|
text: string;
|
|
4819
4814
|
textSignature?: string;
|
|
@@ -4823,8 +4818,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4823
4818
|
mimeType: string;
|
|
4824
4819
|
})[];
|
|
4825
4820
|
details?: any;
|
|
4821
|
+
isError: false;
|
|
4826
4822
|
};
|
|
4827
|
-
status: "
|
|
4823
|
+
status: "completed";
|
|
4828
4824
|
thoughtSignature?: string;
|
|
4829
4825
|
time: {
|
|
4830
4826
|
start: number;
|
|
@@ -4848,9 +4844,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4848
4844
|
mimeType: string;
|
|
4849
4845
|
})[];
|
|
4850
4846
|
details?: any;
|
|
4851
|
-
isError:
|
|
4847
|
+
isError: true;
|
|
4852
4848
|
};
|
|
4853
|
-
status: "
|
|
4849
|
+
status: "error";
|
|
4854
4850
|
thoughtSignature?: string;
|
|
4855
4851
|
time: {
|
|
4856
4852
|
start: number;
|
|
@@ -4876,7 +4872,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4876
4872
|
details?: any;
|
|
4877
4873
|
isError: true;
|
|
4878
4874
|
};
|
|
4879
|
-
status: "
|
|
4875
|
+
status: "skipped";
|
|
4880
4876
|
thoughtSignature?: string;
|
|
4881
4877
|
time: {
|
|
4882
4878
|
start: number;
|
|
@@ -4902,21 +4898,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4902
4898
|
details?: any;
|
|
4903
4899
|
isError: true;
|
|
4904
4900
|
};
|
|
4905
|
-
status: "
|
|
4901
|
+
status: "aborted";
|
|
4906
4902
|
thoughtSignature?: string;
|
|
4907
4903
|
time: {
|
|
4908
4904
|
start: number;
|
|
4909
4905
|
end: number;
|
|
4910
4906
|
};
|
|
4911
4907
|
type: "toolCall";
|
|
4908
|
+
} | {
|
|
4909
|
+
type: "thinking";
|
|
4910
|
+
thinking: string;
|
|
4911
|
+
thinkingSignature?: string;
|
|
4912
|
+
redacted?: boolean;
|
|
4912
4913
|
} | {
|
|
4913
4914
|
addedToolNames?: string[];
|
|
4914
4915
|
arguments: Record<string, any>;
|
|
4915
4916
|
callID: string;
|
|
4916
4917
|
name: string;
|
|
4917
4918
|
namespace?: string;
|
|
4918
|
-
|
|
4919
|
-
content
|
|
4919
|
+
partial?: {
|
|
4920
|
+
content?: ({
|
|
4920
4921
|
type: "text";
|
|
4921
4922
|
text: string;
|
|
4922
4923
|
textSignature?: string;
|
|
@@ -4926,9 +4927,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4926
4927
|
mimeType: string;
|
|
4927
4928
|
})[];
|
|
4928
4929
|
details?: any;
|
|
4929
|
-
isError: true;
|
|
4930
4930
|
};
|
|
4931
|
-
status: "
|
|
4931
|
+
status: "running";
|
|
4932
4932
|
thoughtSignature?: string;
|
|
4933
4933
|
time: {
|
|
4934
4934
|
start: number;
|
|
@@ -5103,19 +5103,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5103
5103
|
type: "image";
|
|
5104
5104
|
data: string;
|
|
5105
5105
|
mimeType: string;
|
|
5106
|
-
} | {
|
|
5107
|
-
type: "thinking";
|
|
5108
|
-
thinking: string;
|
|
5109
|
-
thinkingSignature?: string;
|
|
5110
|
-
redacted?: boolean;
|
|
5111
5106
|
} | {
|
|
5112
5107
|
addedToolNames?: string[];
|
|
5113
5108
|
arguments: Record<string, any>;
|
|
5114
5109
|
callID: string;
|
|
5115
5110
|
name: string;
|
|
5116
5111
|
namespace?: string;
|
|
5117
|
-
|
|
5118
|
-
content
|
|
5112
|
+
result: {
|
|
5113
|
+
content: ({
|
|
5119
5114
|
type: "text";
|
|
5120
5115
|
text: string;
|
|
5121
5116
|
textSignature?: string;
|
|
@@ -5125,8 +5120,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5125
5120
|
mimeType: string;
|
|
5126
5121
|
})[];
|
|
5127
5122
|
details?: any;
|
|
5123
|
+
isError: false;
|
|
5128
5124
|
};
|
|
5129
|
-
status: "
|
|
5125
|
+
status: "completed";
|
|
5130
5126
|
thoughtSignature?: string;
|
|
5131
5127
|
time: {
|
|
5132
5128
|
start: number;
|
|
@@ -5150,9 +5146,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5150
5146
|
mimeType: string;
|
|
5151
5147
|
})[];
|
|
5152
5148
|
details?: any;
|
|
5153
|
-
isError:
|
|
5149
|
+
isError: true;
|
|
5154
5150
|
};
|
|
5155
|
-
status: "
|
|
5151
|
+
status: "error";
|
|
5156
5152
|
thoughtSignature?: string;
|
|
5157
5153
|
time: {
|
|
5158
5154
|
start: number;
|
|
@@ -5178,7 +5174,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5178
5174
|
details?: any;
|
|
5179
5175
|
isError: true;
|
|
5180
5176
|
};
|
|
5181
|
-
status: "
|
|
5177
|
+
status: "skipped";
|
|
5182
5178
|
thoughtSignature?: string;
|
|
5183
5179
|
time: {
|
|
5184
5180
|
start: number;
|
|
@@ -5204,21 +5200,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5204
5200
|
details?: any;
|
|
5205
5201
|
isError: true;
|
|
5206
5202
|
};
|
|
5207
|
-
status: "
|
|
5203
|
+
status: "aborted";
|
|
5208
5204
|
thoughtSignature?: string;
|
|
5209
5205
|
time: {
|
|
5210
5206
|
start: number;
|
|
5211
5207
|
end: number;
|
|
5212
5208
|
};
|
|
5213
5209
|
type: "toolCall";
|
|
5210
|
+
} | {
|
|
5211
|
+
type: "thinking";
|
|
5212
|
+
thinking: string;
|
|
5213
|
+
thinkingSignature?: string;
|
|
5214
|
+
redacted?: boolean;
|
|
5214
5215
|
} | {
|
|
5215
5216
|
addedToolNames?: string[];
|
|
5216
5217
|
arguments: Record<string, any>;
|
|
5217
5218
|
callID: string;
|
|
5218
5219
|
name: string;
|
|
5219
5220
|
namespace?: string;
|
|
5220
|
-
|
|
5221
|
-
content
|
|
5221
|
+
partial?: {
|
|
5222
|
+
content?: ({
|
|
5222
5223
|
type: "text";
|
|
5223
5224
|
text: string;
|
|
5224
5225
|
textSignature?: string;
|
|
@@ -5228,9 +5229,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5228
5229
|
mimeType: string;
|
|
5229
5230
|
})[];
|
|
5230
5231
|
details?: any;
|
|
5231
|
-
isError: true;
|
|
5232
5232
|
};
|
|
5233
|
-
status: "
|
|
5233
|
+
status: "running";
|
|
5234
5234
|
thoughtSignature?: string;
|
|
5235
5235
|
time: {
|
|
5236
5236
|
start: number;
|
|
@@ -5423,19 +5423,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5423
5423
|
type: "image";
|
|
5424
5424
|
data: string;
|
|
5425
5425
|
mimeType: string;
|
|
5426
|
-
} | {
|
|
5427
|
-
type: "thinking";
|
|
5428
|
-
thinking: string;
|
|
5429
|
-
thinkingSignature?: string;
|
|
5430
|
-
redacted?: boolean;
|
|
5431
5426
|
} | {
|
|
5432
5427
|
addedToolNames?: string[];
|
|
5433
5428
|
arguments: Record<string, any>;
|
|
5434
5429
|
callID: string;
|
|
5435
5430
|
name: string;
|
|
5436
5431
|
namespace?: string;
|
|
5437
|
-
|
|
5438
|
-
content
|
|
5432
|
+
result: {
|
|
5433
|
+
content: ({
|
|
5439
5434
|
type: "text";
|
|
5440
5435
|
text: string;
|
|
5441
5436
|
textSignature?: string;
|
|
@@ -5445,8 +5440,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5445
5440
|
mimeType: string;
|
|
5446
5441
|
})[];
|
|
5447
5442
|
details?: any;
|
|
5443
|
+
isError: false;
|
|
5448
5444
|
};
|
|
5449
|
-
status: "
|
|
5445
|
+
status: "completed";
|
|
5450
5446
|
thoughtSignature?: string;
|
|
5451
5447
|
time: {
|
|
5452
5448
|
start: number;
|
|
@@ -5470,9 +5466,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5470
5466
|
mimeType: string;
|
|
5471
5467
|
})[];
|
|
5472
5468
|
details?: any;
|
|
5473
|
-
isError:
|
|
5469
|
+
isError: true;
|
|
5474
5470
|
};
|
|
5475
|
-
status: "
|
|
5471
|
+
status: "error";
|
|
5476
5472
|
thoughtSignature?: string;
|
|
5477
5473
|
time: {
|
|
5478
5474
|
start: number;
|
|
@@ -5498,7 +5494,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5498
5494
|
details?: any;
|
|
5499
5495
|
isError: true;
|
|
5500
5496
|
};
|
|
5501
|
-
status: "
|
|
5497
|
+
status: "skipped";
|
|
5502
5498
|
thoughtSignature?: string;
|
|
5503
5499
|
time: {
|
|
5504
5500
|
start: number;
|
|
@@ -5524,21 +5520,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5524
5520
|
details?: any;
|
|
5525
5521
|
isError: true;
|
|
5526
5522
|
};
|
|
5527
|
-
status: "
|
|
5523
|
+
status: "aborted";
|
|
5528
5524
|
thoughtSignature?: string;
|
|
5529
5525
|
time: {
|
|
5530
5526
|
start: number;
|
|
5531
5527
|
end: number;
|
|
5532
5528
|
};
|
|
5533
5529
|
type: "toolCall";
|
|
5530
|
+
} | {
|
|
5531
|
+
type: "thinking";
|
|
5532
|
+
thinking: string;
|
|
5533
|
+
thinkingSignature?: string;
|
|
5534
|
+
redacted?: boolean;
|
|
5534
5535
|
} | {
|
|
5535
5536
|
addedToolNames?: string[];
|
|
5536
5537
|
arguments: Record<string, any>;
|
|
5537
5538
|
callID: string;
|
|
5538
5539
|
name: string;
|
|
5539
5540
|
namespace?: string;
|
|
5540
|
-
|
|
5541
|
-
content
|
|
5541
|
+
partial?: {
|
|
5542
|
+
content?: ({
|
|
5542
5543
|
type: "text";
|
|
5543
5544
|
text: string;
|
|
5544
5545
|
textSignature?: string;
|
|
@@ -5548,9 +5549,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5548
5549
|
mimeType: string;
|
|
5549
5550
|
})[];
|
|
5550
5551
|
details?: any;
|
|
5551
|
-
isError: true;
|
|
5552
5552
|
};
|
|
5553
|
-
status: "
|
|
5553
|
+
status: "running";
|
|
5554
5554
|
thoughtSignature?: string;
|
|
5555
5555
|
time: {
|
|
5556
5556
|
start: number;
|
|
@@ -5725,19 +5725,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5725
5725
|
type: "image";
|
|
5726
5726
|
data: string;
|
|
5727
5727
|
mimeType: string;
|
|
5728
|
-
} | {
|
|
5729
|
-
type: "thinking";
|
|
5730
|
-
thinking: string;
|
|
5731
|
-
thinkingSignature?: string;
|
|
5732
|
-
redacted?: boolean;
|
|
5733
5728
|
} | {
|
|
5734
5729
|
addedToolNames?: string[];
|
|
5735
5730
|
arguments: Record<string, any>;
|
|
5736
5731
|
callID: string;
|
|
5737
5732
|
name: string;
|
|
5738
5733
|
namespace?: string;
|
|
5739
|
-
|
|
5740
|
-
content
|
|
5734
|
+
result: {
|
|
5735
|
+
content: ({
|
|
5741
5736
|
type: "text";
|
|
5742
5737
|
text: string;
|
|
5743
5738
|
textSignature?: string;
|
|
@@ -5747,8 +5742,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5747
5742
|
mimeType: string;
|
|
5748
5743
|
})[];
|
|
5749
5744
|
details?: any;
|
|
5745
|
+
isError: false;
|
|
5750
5746
|
};
|
|
5751
|
-
status: "
|
|
5747
|
+
status: "completed";
|
|
5752
5748
|
thoughtSignature?: string;
|
|
5753
5749
|
time: {
|
|
5754
5750
|
start: number;
|
|
@@ -5772,9 +5768,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5772
5768
|
mimeType: string;
|
|
5773
5769
|
})[];
|
|
5774
5770
|
details?: any;
|
|
5775
|
-
isError:
|
|
5771
|
+
isError: true;
|
|
5776
5772
|
};
|
|
5777
|
-
status: "
|
|
5773
|
+
status: "error";
|
|
5778
5774
|
thoughtSignature?: string;
|
|
5779
5775
|
time: {
|
|
5780
5776
|
start: number;
|
|
@@ -5800,7 +5796,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5800
5796
|
details?: any;
|
|
5801
5797
|
isError: true;
|
|
5802
5798
|
};
|
|
5803
|
-
status: "
|
|
5799
|
+
status: "skipped";
|
|
5804
5800
|
thoughtSignature?: string;
|
|
5805
5801
|
time: {
|
|
5806
5802
|
start: number;
|
|
@@ -5826,21 +5822,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5826
5822
|
details?: any;
|
|
5827
5823
|
isError: true;
|
|
5828
5824
|
};
|
|
5829
|
-
status: "
|
|
5825
|
+
status: "aborted";
|
|
5830
5826
|
thoughtSignature?: string;
|
|
5831
5827
|
time: {
|
|
5832
5828
|
start: number;
|
|
5833
5829
|
end: number;
|
|
5834
5830
|
};
|
|
5835
5831
|
type: "toolCall";
|
|
5832
|
+
} | {
|
|
5833
|
+
type: "thinking";
|
|
5834
|
+
thinking: string;
|
|
5835
|
+
thinkingSignature?: string;
|
|
5836
|
+
redacted?: boolean;
|
|
5836
5837
|
} | {
|
|
5837
5838
|
addedToolNames?: string[];
|
|
5838
5839
|
arguments: Record<string, any>;
|
|
5839
5840
|
callID: string;
|
|
5840
5841
|
name: string;
|
|
5841
5842
|
namespace?: string;
|
|
5842
|
-
|
|
5843
|
-
content
|
|
5843
|
+
partial?: {
|
|
5844
|
+
content?: ({
|
|
5844
5845
|
type: "text";
|
|
5845
5846
|
text: string;
|
|
5846
5847
|
textSignature?: string;
|
|
@@ -5850,9 +5851,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5850
5851
|
mimeType: string;
|
|
5851
5852
|
})[];
|
|
5852
5853
|
details?: any;
|
|
5853
|
-
isError: true;
|
|
5854
5854
|
};
|
|
5855
|
-
status: "
|
|
5855
|
+
status: "running";
|
|
5856
5856
|
thoughtSignature?: string;
|
|
5857
5857
|
time: {
|
|
5858
5858
|
start: number;
|
|
@@ -6348,19 +6348,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6348
6348
|
type: "image";
|
|
6349
6349
|
data: string;
|
|
6350
6350
|
mimeType: string;
|
|
6351
|
-
} | {
|
|
6352
|
-
type: "thinking";
|
|
6353
|
-
thinking: string;
|
|
6354
|
-
thinkingSignature?: string;
|
|
6355
|
-
redacted?: boolean;
|
|
6356
6351
|
} | {
|
|
6357
6352
|
addedToolNames?: string[];
|
|
6358
6353
|
arguments: Record<string, any>;
|
|
6359
6354
|
callID: string;
|
|
6360
6355
|
name: string;
|
|
6361
6356
|
namespace?: string;
|
|
6362
|
-
|
|
6363
|
-
content
|
|
6357
|
+
result: {
|
|
6358
|
+
content: ({
|
|
6364
6359
|
type: "text";
|
|
6365
6360
|
text: string;
|
|
6366
6361
|
textSignature?: string;
|
|
@@ -6370,8 +6365,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6370
6365
|
mimeType: string;
|
|
6371
6366
|
})[];
|
|
6372
6367
|
details?: any;
|
|
6368
|
+
isError: false;
|
|
6373
6369
|
};
|
|
6374
|
-
status: "
|
|
6370
|
+
status: "completed";
|
|
6375
6371
|
thoughtSignature?: string;
|
|
6376
6372
|
time: {
|
|
6377
6373
|
start: number;
|
|
@@ -6395,9 +6391,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6395
6391
|
mimeType: string;
|
|
6396
6392
|
})[];
|
|
6397
6393
|
details?: any;
|
|
6398
|
-
isError:
|
|
6394
|
+
isError: true;
|
|
6399
6395
|
};
|
|
6400
|
-
status: "
|
|
6396
|
+
status: "error";
|
|
6401
6397
|
thoughtSignature?: string;
|
|
6402
6398
|
time: {
|
|
6403
6399
|
start: number;
|
|
@@ -6423,7 +6419,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6423
6419
|
details?: any;
|
|
6424
6420
|
isError: true;
|
|
6425
6421
|
};
|
|
6426
|
-
status: "
|
|
6422
|
+
status: "skipped";
|
|
6427
6423
|
thoughtSignature?: string;
|
|
6428
6424
|
time: {
|
|
6429
6425
|
start: number;
|
|
@@ -6449,7 +6445,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6449
6445
|
details?: any;
|
|
6450
6446
|
isError: true;
|
|
6451
6447
|
};
|
|
6452
|
-
status: "
|
|
6448
|
+
status: "aborted";
|
|
6453
6449
|
thoughtSignature?: string;
|
|
6454
6450
|
time: {
|
|
6455
6451
|
start: number;
|
|
@@ -6457,13 +6453,18 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6457
6453
|
};
|
|
6458
6454
|
type: "toolCall";
|
|
6459
6455
|
} | {
|
|
6460
|
-
|
|
6461
|
-
|
|
6462
|
-
|
|
6463
|
-
|
|
6456
|
+
type: "thinking";
|
|
6457
|
+
thinking: string;
|
|
6458
|
+
thinkingSignature?: string;
|
|
6459
|
+
redacted?: boolean;
|
|
6460
|
+
} | {
|
|
6461
|
+
addedToolNames?: string[];
|
|
6462
|
+
arguments: Record<string, any>;
|
|
6463
|
+
callID: string;
|
|
6464
|
+
name: string;
|
|
6464
6465
|
namespace?: string;
|
|
6465
|
-
|
|
6466
|
-
content
|
|
6466
|
+
partial?: {
|
|
6467
|
+
content?: ({
|
|
6467
6468
|
type: "text";
|
|
6468
6469
|
text: string;
|
|
6469
6470
|
textSignature?: string;
|
|
@@ -6473,9 +6474,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6473
6474
|
mimeType: string;
|
|
6474
6475
|
})[];
|
|
6475
6476
|
details?: any;
|
|
6476
|
-
isError: true;
|
|
6477
6477
|
};
|
|
6478
|
-
status: "
|
|
6478
|
+
status: "running";
|
|
6479
6479
|
thoughtSignature?: string;
|
|
6480
6480
|
time: {
|
|
6481
6481
|
start: number;
|
|
@@ -6650,19 +6650,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6650
6650
|
type: "image";
|
|
6651
6651
|
data: string;
|
|
6652
6652
|
mimeType: string;
|
|
6653
|
-
} | {
|
|
6654
|
-
type: "thinking";
|
|
6655
|
-
thinking: string;
|
|
6656
|
-
thinkingSignature?: string;
|
|
6657
|
-
redacted?: boolean;
|
|
6658
6653
|
} | {
|
|
6659
6654
|
addedToolNames?: string[];
|
|
6660
6655
|
arguments: Record<string, any>;
|
|
6661
6656
|
callID: string;
|
|
6662
6657
|
name: string;
|
|
6663
6658
|
namespace?: string;
|
|
6664
|
-
|
|
6665
|
-
content
|
|
6659
|
+
result: {
|
|
6660
|
+
content: ({
|
|
6666
6661
|
type: "text";
|
|
6667
6662
|
text: string;
|
|
6668
6663
|
textSignature?: string;
|
|
@@ -6672,8 +6667,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6672
6667
|
mimeType: string;
|
|
6673
6668
|
})[];
|
|
6674
6669
|
details?: any;
|
|
6670
|
+
isError: false;
|
|
6675
6671
|
};
|
|
6676
|
-
status: "
|
|
6672
|
+
status: "completed";
|
|
6677
6673
|
thoughtSignature?: string;
|
|
6678
6674
|
time: {
|
|
6679
6675
|
start: number;
|
|
@@ -6697,9 +6693,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6697
6693
|
mimeType: string;
|
|
6698
6694
|
})[];
|
|
6699
6695
|
details?: any;
|
|
6700
|
-
isError:
|
|
6696
|
+
isError: true;
|
|
6701
6697
|
};
|
|
6702
|
-
status: "
|
|
6698
|
+
status: "error";
|
|
6703
6699
|
thoughtSignature?: string;
|
|
6704
6700
|
time: {
|
|
6705
6701
|
start: number;
|
|
@@ -6725,7 +6721,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6725
6721
|
details?: any;
|
|
6726
6722
|
isError: true;
|
|
6727
6723
|
};
|
|
6728
|
-
status: "
|
|
6724
|
+
status: "skipped";
|
|
6729
6725
|
thoughtSignature?: string;
|
|
6730
6726
|
time: {
|
|
6731
6727
|
start: number;
|
|
@@ -6751,21 +6747,26 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6751
6747
|
details?: any;
|
|
6752
6748
|
isError: true;
|
|
6753
6749
|
};
|
|
6754
|
-
status: "
|
|
6750
|
+
status: "aborted";
|
|
6755
6751
|
thoughtSignature?: string;
|
|
6756
6752
|
time: {
|
|
6757
6753
|
start: number;
|
|
6758
6754
|
end: number;
|
|
6759
6755
|
};
|
|
6760
6756
|
type: "toolCall";
|
|
6757
|
+
} | {
|
|
6758
|
+
type: "thinking";
|
|
6759
|
+
thinking: string;
|
|
6760
|
+
thinkingSignature?: string;
|
|
6761
|
+
redacted?: boolean;
|
|
6761
6762
|
} | {
|
|
6762
6763
|
addedToolNames?: string[];
|
|
6763
6764
|
arguments: Record<string, any>;
|
|
6764
6765
|
callID: string;
|
|
6765
6766
|
name: string;
|
|
6766
6767
|
namespace?: string;
|
|
6767
|
-
|
|
6768
|
-
content
|
|
6768
|
+
partial?: {
|
|
6769
|
+
content?: ({
|
|
6769
6770
|
type: "text";
|
|
6770
6771
|
text: string;
|
|
6771
6772
|
textSignature?: string;
|
|
@@ -6775,9 +6776,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6775
6776
|
mimeType: string;
|
|
6776
6777
|
})[];
|
|
6777
6778
|
details?: any;
|
|
6778
|
-
isError: true;
|
|
6779
6779
|
};
|
|
6780
|
-
status: "
|
|
6780
|
+
status: "running";
|
|
6781
6781
|
thoughtSignature?: string;
|
|
6782
6782
|
time: {
|
|
6783
6783
|
start: number;
|
|
@@ -6971,19 +6971,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6971
6971
|
type: "image";
|
|
6972
6972
|
data: string;
|
|
6973
6973
|
mimeType: string;
|
|
6974
|
-
} | {
|
|
6975
|
-
type: "thinking";
|
|
6976
|
-
thinking: string;
|
|
6977
|
-
thinkingSignature?: string;
|
|
6978
|
-
redacted?: boolean;
|
|
6979
6974
|
} | {
|
|
6980
6975
|
addedToolNames?: string[];
|
|
6981
6976
|
arguments: Record<string, any>;
|
|
6982
6977
|
callID: string;
|
|
6983
6978
|
name: string;
|
|
6984
6979
|
namespace?: string;
|
|
6985
|
-
|
|
6986
|
-
content
|
|
6980
|
+
result: {
|
|
6981
|
+
content: ({
|
|
6987
6982
|
type: "text";
|
|
6988
6983
|
text: string;
|
|
6989
6984
|
textSignature?: string;
|
|
@@ -6993,8 +6988,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6993
6988
|
mimeType: string;
|
|
6994
6989
|
})[];
|
|
6995
6990
|
details?: any;
|
|
6991
|
+
isError: false;
|
|
6996
6992
|
};
|
|
6997
|
-
status: "
|
|
6993
|
+
status: "completed";
|
|
6998
6994
|
thoughtSignature?: string;
|
|
6999
6995
|
time: {
|
|
7000
6996
|
start: number;
|
|
@@ -7018,9 +7014,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7018
7014
|
mimeType: string;
|
|
7019
7015
|
})[];
|
|
7020
7016
|
details?: any;
|
|
7021
|
-
isError:
|
|
7017
|
+
isError: true;
|
|
7022
7018
|
};
|
|
7023
|
-
status: "
|
|
7019
|
+
status: "error";
|
|
7024
7020
|
thoughtSignature?: string;
|
|
7025
7021
|
time: {
|
|
7026
7022
|
start: number;
|
|
@@ -7046,7 +7042,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7046
7042
|
details?: any;
|
|
7047
7043
|
isError: true;
|
|
7048
7044
|
};
|
|
7049
|
-
status: "
|
|
7045
|
+
status: "skipped";
|
|
7050
7046
|
thoughtSignature?: string;
|
|
7051
7047
|
time: {
|
|
7052
7048
|
start: number;
|
|
@@ -7072,21 +7068,26 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7072
7068
|
details?: any;
|
|
7073
7069
|
isError: true;
|
|
7074
7070
|
};
|
|
7075
|
-
status: "
|
|
7071
|
+
status: "aborted";
|
|
7076
7072
|
thoughtSignature?: string;
|
|
7077
7073
|
time: {
|
|
7078
7074
|
start: number;
|
|
7079
7075
|
end: number;
|
|
7080
7076
|
};
|
|
7081
7077
|
type: "toolCall";
|
|
7078
|
+
} | {
|
|
7079
|
+
type: "thinking";
|
|
7080
|
+
thinking: string;
|
|
7081
|
+
thinkingSignature?: string;
|
|
7082
|
+
redacted?: boolean;
|
|
7082
7083
|
} | {
|
|
7083
7084
|
addedToolNames?: string[];
|
|
7084
7085
|
arguments: Record<string, any>;
|
|
7085
7086
|
callID: string;
|
|
7086
7087
|
name: string;
|
|
7087
7088
|
namespace?: string;
|
|
7088
|
-
|
|
7089
|
-
content
|
|
7089
|
+
partial?: {
|
|
7090
|
+
content?: ({
|
|
7090
7091
|
type: "text";
|
|
7091
7092
|
text: string;
|
|
7092
7093
|
textSignature?: string;
|
|
@@ -7096,9 +7097,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7096
7097
|
mimeType: string;
|
|
7097
7098
|
})[];
|
|
7098
7099
|
details?: any;
|
|
7099
|
-
isError: true;
|
|
7100
7100
|
};
|
|
7101
|
-
status: "
|
|
7101
|
+
status: "running";
|
|
7102
7102
|
thoughtSignature?: string;
|
|
7103
7103
|
time: {
|
|
7104
7104
|
start: number;
|
|
@@ -7273,19 +7273,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7273
7273
|
type: "image";
|
|
7274
7274
|
data: string;
|
|
7275
7275
|
mimeType: string;
|
|
7276
|
-
} | {
|
|
7277
|
-
type: "thinking";
|
|
7278
|
-
thinking: string;
|
|
7279
|
-
thinkingSignature?: string;
|
|
7280
|
-
redacted?: boolean;
|
|
7281
7276
|
} | {
|
|
7282
7277
|
addedToolNames?: string[];
|
|
7283
7278
|
arguments: Record<string, any>;
|
|
7284
7279
|
callID: string;
|
|
7285
7280
|
name: string;
|
|
7286
7281
|
namespace?: string;
|
|
7287
|
-
|
|
7288
|
-
content
|
|
7282
|
+
result: {
|
|
7283
|
+
content: ({
|
|
7289
7284
|
type: "text";
|
|
7290
7285
|
text: string;
|
|
7291
7286
|
textSignature?: string;
|
|
@@ -7295,8 +7290,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7295
7290
|
mimeType: string;
|
|
7296
7291
|
})[];
|
|
7297
7292
|
details?: any;
|
|
7293
|
+
isError: false;
|
|
7298
7294
|
};
|
|
7299
|
-
status: "
|
|
7295
|
+
status: "completed";
|
|
7300
7296
|
thoughtSignature?: string;
|
|
7301
7297
|
time: {
|
|
7302
7298
|
start: number;
|
|
@@ -7320,9 +7316,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7320
7316
|
mimeType: string;
|
|
7321
7317
|
})[];
|
|
7322
7318
|
details?: any;
|
|
7323
|
-
isError:
|
|
7319
|
+
isError: true;
|
|
7324
7320
|
};
|
|
7325
|
-
status: "
|
|
7321
|
+
status: "error";
|
|
7326
7322
|
thoughtSignature?: string;
|
|
7327
7323
|
time: {
|
|
7328
7324
|
start: number;
|
|
@@ -7348,7 +7344,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7348
7344
|
details?: any;
|
|
7349
7345
|
isError: true;
|
|
7350
7346
|
};
|
|
7351
|
-
status: "
|
|
7347
|
+
status: "skipped";
|
|
7352
7348
|
thoughtSignature?: string;
|
|
7353
7349
|
time: {
|
|
7354
7350
|
start: number;
|
|
@@ -7374,21 +7370,26 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7374
7370
|
details?: any;
|
|
7375
7371
|
isError: true;
|
|
7376
7372
|
};
|
|
7377
|
-
status: "
|
|
7373
|
+
status: "aborted";
|
|
7378
7374
|
thoughtSignature?: string;
|
|
7379
7375
|
time: {
|
|
7380
7376
|
start: number;
|
|
7381
7377
|
end: number;
|
|
7382
7378
|
};
|
|
7383
7379
|
type: "toolCall";
|
|
7380
|
+
} | {
|
|
7381
|
+
type: "thinking";
|
|
7382
|
+
thinking: string;
|
|
7383
|
+
thinkingSignature?: string;
|
|
7384
|
+
redacted?: boolean;
|
|
7384
7385
|
} | {
|
|
7385
7386
|
addedToolNames?: string[];
|
|
7386
7387
|
arguments: Record<string, any>;
|
|
7387
7388
|
callID: string;
|
|
7388
7389
|
name: string;
|
|
7389
7390
|
namespace?: string;
|
|
7390
|
-
|
|
7391
|
-
content
|
|
7391
|
+
partial?: {
|
|
7392
|
+
content?: ({
|
|
7392
7393
|
type: "text";
|
|
7393
7394
|
text: string;
|
|
7394
7395
|
textSignature?: string;
|
|
@@ -7398,9 +7399,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7398
7399
|
mimeType: string;
|
|
7399
7400
|
})[];
|
|
7400
7401
|
details?: any;
|
|
7401
|
-
isError: true;
|
|
7402
7402
|
};
|
|
7403
|
-
status: "
|
|
7403
|
+
status: "running";
|
|
7404
7404
|
thoughtSignature?: string;
|
|
7405
7405
|
time: {
|
|
7406
7406
|
start: number;
|
|
@@ -7606,19 +7606,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7606
7606
|
type: "image";
|
|
7607
7607
|
data: string;
|
|
7608
7608
|
mimeType: string;
|
|
7609
|
-
} | {
|
|
7610
|
-
type: "thinking";
|
|
7611
|
-
thinking: string;
|
|
7612
|
-
thinkingSignature?: string;
|
|
7613
|
-
redacted?: boolean;
|
|
7614
7609
|
} | {
|
|
7615
7610
|
addedToolNames?: string[];
|
|
7616
7611
|
arguments: Record<string, any>;
|
|
7617
7612
|
callID: string;
|
|
7618
7613
|
name: string;
|
|
7619
7614
|
namespace?: string;
|
|
7620
|
-
|
|
7621
|
-
content
|
|
7615
|
+
result: {
|
|
7616
|
+
content: ({
|
|
7622
7617
|
type: "text";
|
|
7623
7618
|
text: string;
|
|
7624
7619
|
textSignature?: string;
|
|
@@ -7628,8 +7623,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7628
7623
|
mimeType: string;
|
|
7629
7624
|
})[];
|
|
7630
7625
|
details?: any;
|
|
7626
|
+
isError: false;
|
|
7631
7627
|
};
|
|
7632
|
-
status: "
|
|
7628
|
+
status: "completed";
|
|
7633
7629
|
thoughtSignature?: string;
|
|
7634
7630
|
time: {
|
|
7635
7631
|
start: number;
|
|
@@ -7653,9 +7649,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7653
7649
|
mimeType: string;
|
|
7654
7650
|
})[];
|
|
7655
7651
|
details?: any;
|
|
7656
|
-
isError:
|
|
7652
|
+
isError: true;
|
|
7657
7653
|
};
|
|
7658
|
-
status: "
|
|
7654
|
+
status: "error";
|
|
7659
7655
|
thoughtSignature?: string;
|
|
7660
7656
|
time: {
|
|
7661
7657
|
start: number;
|
|
@@ -7681,7 +7677,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7681
7677
|
details?: any;
|
|
7682
7678
|
isError: true;
|
|
7683
7679
|
};
|
|
7684
|
-
status: "
|
|
7680
|
+
status: "skipped";
|
|
7685
7681
|
thoughtSignature?: string;
|
|
7686
7682
|
time: {
|
|
7687
7683
|
start: number;
|
|
@@ -7707,21 +7703,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7707
7703
|
details?: any;
|
|
7708
7704
|
isError: true;
|
|
7709
7705
|
};
|
|
7710
|
-
status: "
|
|
7706
|
+
status: "aborted";
|
|
7711
7707
|
thoughtSignature?: string;
|
|
7712
7708
|
time: {
|
|
7713
7709
|
start: number;
|
|
7714
7710
|
end: number;
|
|
7715
7711
|
};
|
|
7716
7712
|
type: "toolCall";
|
|
7713
|
+
} | {
|
|
7714
|
+
type: "thinking";
|
|
7715
|
+
thinking: string;
|
|
7716
|
+
thinkingSignature?: string;
|
|
7717
|
+
redacted?: boolean;
|
|
7717
7718
|
} | {
|
|
7718
7719
|
addedToolNames?: string[];
|
|
7719
7720
|
arguments: Record<string, any>;
|
|
7720
7721
|
callID: string;
|
|
7721
7722
|
name: string;
|
|
7722
7723
|
namespace?: string;
|
|
7723
|
-
|
|
7724
|
-
content
|
|
7724
|
+
partial?: {
|
|
7725
|
+
content?: ({
|
|
7725
7726
|
type: "text";
|
|
7726
7727
|
text: string;
|
|
7727
7728
|
textSignature?: string;
|
|
@@ -7731,9 +7732,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7731
7732
|
mimeType: string;
|
|
7732
7733
|
})[];
|
|
7733
7734
|
details?: any;
|
|
7734
|
-
isError: true;
|
|
7735
7735
|
};
|
|
7736
|
-
status: "
|
|
7736
|
+
status: "running";
|
|
7737
7737
|
thoughtSignature?: string;
|
|
7738
7738
|
time: {
|
|
7739
7739
|
start: number;
|
|
@@ -7908,19 +7908,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7908
7908
|
type: "image";
|
|
7909
7909
|
data: string;
|
|
7910
7910
|
mimeType: string;
|
|
7911
|
-
} | {
|
|
7912
|
-
type: "thinking";
|
|
7913
|
-
thinking: string;
|
|
7914
|
-
thinkingSignature?: string;
|
|
7915
|
-
redacted?: boolean;
|
|
7916
7911
|
} | {
|
|
7917
7912
|
addedToolNames?: string[];
|
|
7918
7913
|
arguments: Record<string, any>;
|
|
7919
7914
|
callID: string;
|
|
7920
7915
|
name: string;
|
|
7921
7916
|
namespace?: string;
|
|
7922
|
-
|
|
7923
|
-
content
|
|
7917
|
+
result: {
|
|
7918
|
+
content: ({
|
|
7924
7919
|
type: "text";
|
|
7925
7920
|
text: string;
|
|
7926
7921
|
textSignature?: string;
|
|
@@ -7930,8 +7925,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7930
7925
|
mimeType: string;
|
|
7931
7926
|
})[];
|
|
7932
7927
|
details?: any;
|
|
7928
|
+
isError: false;
|
|
7933
7929
|
};
|
|
7934
|
-
status: "
|
|
7930
|
+
status: "completed";
|
|
7935
7931
|
thoughtSignature?: string;
|
|
7936
7932
|
time: {
|
|
7937
7933
|
start: number;
|
|
@@ -7955,9 +7951,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7955
7951
|
mimeType: string;
|
|
7956
7952
|
})[];
|
|
7957
7953
|
details?: any;
|
|
7958
|
-
isError:
|
|
7954
|
+
isError: true;
|
|
7959
7955
|
};
|
|
7960
|
-
status: "
|
|
7956
|
+
status: "error";
|
|
7961
7957
|
thoughtSignature?: string;
|
|
7962
7958
|
time: {
|
|
7963
7959
|
start: number;
|
|
@@ -7983,7 +7979,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7983
7979
|
details?: any;
|
|
7984
7980
|
isError: true;
|
|
7985
7981
|
};
|
|
7986
|
-
status: "
|
|
7982
|
+
status: "skipped";
|
|
7987
7983
|
thoughtSignature?: string;
|
|
7988
7984
|
time: {
|
|
7989
7985
|
start: number;
|
|
@@ -8009,21 +8005,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8009
8005
|
details?: any;
|
|
8010
8006
|
isError: true;
|
|
8011
8007
|
};
|
|
8012
|
-
status: "
|
|
8008
|
+
status: "aborted";
|
|
8013
8009
|
thoughtSignature?: string;
|
|
8014
8010
|
time: {
|
|
8015
8011
|
start: number;
|
|
8016
8012
|
end: number;
|
|
8017
8013
|
};
|
|
8018
8014
|
type: "toolCall";
|
|
8015
|
+
} | {
|
|
8016
|
+
type: "thinking";
|
|
8017
|
+
thinking: string;
|
|
8018
|
+
thinkingSignature?: string;
|
|
8019
|
+
redacted?: boolean;
|
|
8019
8020
|
} | {
|
|
8020
8021
|
addedToolNames?: string[];
|
|
8021
8022
|
arguments: Record<string, any>;
|
|
8022
8023
|
callID: string;
|
|
8023
8024
|
name: string;
|
|
8024
8025
|
namespace?: string;
|
|
8025
|
-
|
|
8026
|
-
content
|
|
8026
|
+
partial?: {
|
|
8027
|
+
content?: ({
|
|
8027
8028
|
type: "text";
|
|
8028
8029
|
text: string;
|
|
8029
8030
|
textSignature?: string;
|
|
@@ -8033,9 +8034,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8033
8034
|
mimeType: string;
|
|
8034
8035
|
})[];
|
|
8035
8036
|
details?: any;
|
|
8036
|
-
isError: true;
|
|
8037
8037
|
};
|
|
8038
|
-
status: "
|
|
8038
|
+
status: "running";
|
|
8039
8039
|
thoughtSignature?: string;
|
|
8040
8040
|
time: {
|
|
8041
8041
|
start: number;
|
|
@@ -8229,19 +8229,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8229
8229
|
type: "image";
|
|
8230
8230
|
data: string;
|
|
8231
8231
|
mimeType: string;
|
|
8232
|
-
} | {
|
|
8233
|
-
type: "thinking";
|
|
8234
|
-
thinking: string;
|
|
8235
|
-
thinkingSignature?: string;
|
|
8236
|
-
redacted?: boolean;
|
|
8237
8232
|
} | {
|
|
8238
8233
|
addedToolNames?: string[];
|
|
8239
8234
|
arguments: Record<string, any>;
|
|
8240
8235
|
callID: string;
|
|
8241
8236
|
name: string;
|
|
8242
8237
|
namespace?: string;
|
|
8243
|
-
|
|
8244
|
-
content
|
|
8238
|
+
result: {
|
|
8239
|
+
content: ({
|
|
8245
8240
|
type: "text";
|
|
8246
8241
|
text: string;
|
|
8247
8242
|
textSignature?: string;
|
|
@@ -8251,8 +8246,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8251
8246
|
mimeType: string;
|
|
8252
8247
|
})[];
|
|
8253
8248
|
details?: any;
|
|
8249
|
+
isError: false;
|
|
8254
8250
|
};
|
|
8255
|
-
status: "
|
|
8251
|
+
status: "completed";
|
|
8256
8252
|
thoughtSignature?: string;
|
|
8257
8253
|
time: {
|
|
8258
8254
|
start: number;
|
|
@@ -8276,9 +8272,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8276
8272
|
mimeType: string;
|
|
8277
8273
|
})[];
|
|
8278
8274
|
details?: any;
|
|
8279
|
-
isError:
|
|
8275
|
+
isError: true;
|
|
8280
8276
|
};
|
|
8281
|
-
status: "
|
|
8277
|
+
status: "error";
|
|
8282
8278
|
thoughtSignature?: string;
|
|
8283
8279
|
time: {
|
|
8284
8280
|
start: number;
|
|
@@ -8304,7 +8300,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8304
8300
|
details?: any;
|
|
8305
8301
|
isError: true;
|
|
8306
8302
|
};
|
|
8307
|
-
status: "
|
|
8303
|
+
status: "skipped";
|
|
8308
8304
|
thoughtSignature?: string;
|
|
8309
8305
|
time: {
|
|
8310
8306
|
start: number;
|
|
@@ -8330,21 +8326,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8330
8326
|
details?: any;
|
|
8331
8327
|
isError: true;
|
|
8332
8328
|
};
|
|
8333
|
-
status: "
|
|
8329
|
+
status: "aborted";
|
|
8334
8330
|
thoughtSignature?: string;
|
|
8335
8331
|
time: {
|
|
8336
8332
|
start: number;
|
|
8337
8333
|
end: number;
|
|
8338
8334
|
};
|
|
8339
8335
|
type: "toolCall";
|
|
8336
|
+
} | {
|
|
8337
|
+
type: "thinking";
|
|
8338
|
+
thinking: string;
|
|
8339
|
+
thinkingSignature?: string;
|
|
8340
|
+
redacted?: boolean;
|
|
8340
8341
|
} | {
|
|
8341
8342
|
addedToolNames?: string[];
|
|
8342
8343
|
arguments: Record<string, any>;
|
|
8343
8344
|
callID: string;
|
|
8344
8345
|
name: string;
|
|
8345
8346
|
namespace?: string;
|
|
8346
|
-
|
|
8347
|
-
content
|
|
8347
|
+
partial?: {
|
|
8348
|
+
content?: ({
|
|
8348
8349
|
type: "text";
|
|
8349
8350
|
text: string;
|
|
8350
8351
|
textSignature?: string;
|
|
@@ -8354,9 +8355,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8354
8355
|
mimeType: string;
|
|
8355
8356
|
})[];
|
|
8356
8357
|
details?: any;
|
|
8357
|
-
isError: true;
|
|
8358
8358
|
};
|
|
8359
|
-
status: "
|
|
8359
|
+
status: "running";
|
|
8360
8360
|
thoughtSignature?: string;
|
|
8361
8361
|
time: {
|
|
8362
8362
|
start: number;
|
|
@@ -8531,19 +8531,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8531
8531
|
type: "image";
|
|
8532
8532
|
data: string;
|
|
8533
8533
|
mimeType: string;
|
|
8534
|
-
} | {
|
|
8535
|
-
type: "thinking";
|
|
8536
|
-
thinking: string;
|
|
8537
|
-
thinkingSignature?: string;
|
|
8538
|
-
redacted?: boolean;
|
|
8539
8534
|
} | {
|
|
8540
8535
|
addedToolNames?: string[];
|
|
8541
8536
|
arguments: Record<string, any>;
|
|
8542
8537
|
callID: string;
|
|
8543
8538
|
name: string;
|
|
8544
8539
|
namespace?: string;
|
|
8545
|
-
|
|
8546
|
-
content
|
|
8540
|
+
result: {
|
|
8541
|
+
content: ({
|
|
8547
8542
|
type: "text";
|
|
8548
8543
|
text: string;
|
|
8549
8544
|
textSignature?: string;
|
|
@@ -8553,8 +8548,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8553
8548
|
mimeType: string;
|
|
8554
8549
|
})[];
|
|
8555
8550
|
details?: any;
|
|
8551
|
+
isError: false;
|
|
8556
8552
|
};
|
|
8557
|
-
status: "
|
|
8553
|
+
status: "completed";
|
|
8558
8554
|
thoughtSignature?: string;
|
|
8559
8555
|
time: {
|
|
8560
8556
|
start: number;
|
|
@@ -8578,9 +8574,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8578
8574
|
mimeType: string;
|
|
8579
8575
|
})[];
|
|
8580
8576
|
details?: any;
|
|
8581
|
-
isError:
|
|
8577
|
+
isError: true;
|
|
8582
8578
|
};
|
|
8583
|
-
status: "
|
|
8579
|
+
status: "error";
|
|
8584
8580
|
thoughtSignature?: string;
|
|
8585
8581
|
time: {
|
|
8586
8582
|
start: number;
|
|
@@ -8606,7 +8602,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8606
8602
|
details?: any;
|
|
8607
8603
|
isError: true;
|
|
8608
8604
|
};
|
|
8609
|
-
status: "
|
|
8605
|
+
status: "skipped";
|
|
8610
8606
|
thoughtSignature?: string;
|
|
8611
8607
|
time: {
|
|
8612
8608
|
start: number;
|
|
@@ -8632,21 +8628,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8632
8628
|
details?: any;
|
|
8633
8629
|
isError: true;
|
|
8634
8630
|
};
|
|
8635
|
-
status: "
|
|
8631
|
+
status: "aborted";
|
|
8636
8632
|
thoughtSignature?: string;
|
|
8637
8633
|
time: {
|
|
8638
8634
|
start: number;
|
|
8639
8635
|
end: number;
|
|
8640
8636
|
};
|
|
8641
8637
|
type: "toolCall";
|
|
8638
|
+
} | {
|
|
8639
|
+
type: "thinking";
|
|
8640
|
+
thinking: string;
|
|
8641
|
+
thinkingSignature?: string;
|
|
8642
|
+
redacted?: boolean;
|
|
8642
8643
|
} | {
|
|
8643
8644
|
addedToolNames?: string[];
|
|
8644
8645
|
arguments: Record<string, any>;
|
|
8645
8646
|
callID: string;
|
|
8646
8647
|
name: string;
|
|
8647
8648
|
namespace?: string;
|
|
8648
|
-
|
|
8649
|
-
content
|
|
8649
|
+
partial?: {
|
|
8650
|
+
content?: ({
|
|
8650
8651
|
type: "text";
|
|
8651
8652
|
text: string;
|
|
8652
8653
|
textSignature?: string;
|
|
@@ -8656,9 +8657,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8656
8657
|
mimeType: string;
|
|
8657
8658
|
})[];
|
|
8658
8659
|
details?: any;
|
|
8659
|
-
isError: true;
|
|
8660
8660
|
};
|
|
8661
|
-
status: "
|
|
8661
|
+
status: "running";
|
|
8662
8662
|
thoughtSignature?: string;
|
|
8663
8663
|
time: {
|
|
8664
8664
|
start: number;
|
|
@@ -10406,19 +10406,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10406
10406
|
type: "image";
|
|
10407
10407
|
data: string;
|
|
10408
10408
|
mimeType: string;
|
|
10409
|
-
} | {
|
|
10410
|
-
type: "thinking";
|
|
10411
|
-
thinking: string;
|
|
10412
|
-
thinkingSignature?: string;
|
|
10413
|
-
redacted?: boolean;
|
|
10414
10409
|
} | {
|
|
10415
10410
|
addedToolNames?: string[];
|
|
10416
10411
|
arguments: Record<string, any>;
|
|
10417
10412
|
callID: string;
|
|
10418
10413
|
name: string;
|
|
10419
10414
|
namespace?: string;
|
|
10420
|
-
|
|
10421
|
-
content
|
|
10415
|
+
result: {
|
|
10416
|
+
content: ({
|
|
10422
10417
|
type: "text";
|
|
10423
10418
|
text: string;
|
|
10424
10419
|
textSignature?: string;
|
|
@@ -10428,8 +10423,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10428
10423
|
mimeType: string;
|
|
10429
10424
|
})[];
|
|
10430
10425
|
details?: any;
|
|
10426
|
+
isError: false;
|
|
10431
10427
|
};
|
|
10432
|
-
status: "
|
|
10428
|
+
status: "completed";
|
|
10433
10429
|
thoughtSignature?: string;
|
|
10434
10430
|
time: {
|
|
10435
10431
|
start: number;
|
|
@@ -10453,9 +10449,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10453
10449
|
mimeType: string;
|
|
10454
10450
|
})[];
|
|
10455
10451
|
details?: any;
|
|
10456
|
-
isError:
|
|
10452
|
+
isError: true;
|
|
10457
10453
|
};
|
|
10458
|
-
status: "
|
|
10454
|
+
status: "error";
|
|
10459
10455
|
thoughtSignature?: string;
|
|
10460
10456
|
time: {
|
|
10461
10457
|
start: number;
|
|
@@ -10481,7 +10477,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10481
10477
|
details?: any;
|
|
10482
10478
|
isError: true;
|
|
10483
10479
|
};
|
|
10484
|
-
status: "
|
|
10480
|
+
status: "skipped";
|
|
10485
10481
|
thoughtSignature?: string;
|
|
10486
10482
|
time: {
|
|
10487
10483
|
start: number;
|
|
@@ -10507,21 +10503,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10507
10503
|
details?: any;
|
|
10508
10504
|
isError: true;
|
|
10509
10505
|
};
|
|
10510
|
-
status: "
|
|
10506
|
+
status: "aborted";
|
|
10511
10507
|
thoughtSignature?: string;
|
|
10512
10508
|
time: {
|
|
10513
10509
|
start: number;
|
|
10514
10510
|
end: number;
|
|
10515
10511
|
};
|
|
10516
10512
|
type: "toolCall";
|
|
10513
|
+
} | {
|
|
10514
|
+
type: "thinking";
|
|
10515
|
+
thinking: string;
|
|
10516
|
+
thinkingSignature?: string;
|
|
10517
|
+
redacted?: boolean;
|
|
10517
10518
|
} | {
|
|
10518
10519
|
addedToolNames?: string[];
|
|
10519
10520
|
arguments: Record<string, any>;
|
|
10520
10521
|
callID: string;
|
|
10521
10522
|
name: string;
|
|
10522
10523
|
namespace?: string;
|
|
10523
|
-
|
|
10524
|
-
content
|
|
10524
|
+
partial?: {
|
|
10525
|
+
content?: ({
|
|
10525
10526
|
type: "text";
|
|
10526
10527
|
text: string;
|
|
10527
10528
|
textSignature?: string;
|
|
@@ -10531,9 +10532,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10531
10532
|
mimeType: string;
|
|
10532
10533
|
})[];
|
|
10533
10534
|
details?: any;
|
|
10534
|
-
isError: true;
|
|
10535
10535
|
};
|
|
10536
|
-
status: "
|
|
10536
|
+
status: "running";
|
|
10537
10537
|
thoughtSignature?: string;
|
|
10538
10538
|
time: {
|
|
10539
10539
|
start: number;
|
|
@@ -10708,19 +10708,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10708
10708
|
type: "image";
|
|
10709
10709
|
data: string;
|
|
10710
10710
|
mimeType: string;
|
|
10711
|
-
} | {
|
|
10712
|
-
type: "thinking";
|
|
10713
|
-
thinking: string;
|
|
10714
|
-
thinkingSignature?: string;
|
|
10715
|
-
redacted?: boolean;
|
|
10716
10711
|
} | {
|
|
10717
10712
|
addedToolNames?: string[];
|
|
10718
10713
|
arguments: Record<string, any>;
|
|
10719
10714
|
callID: string;
|
|
10720
10715
|
name: string;
|
|
10721
10716
|
namespace?: string;
|
|
10722
|
-
|
|
10723
|
-
content
|
|
10717
|
+
result: {
|
|
10718
|
+
content: ({
|
|
10724
10719
|
type: "text";
|
|
10725
10720
|
text: string;
|
|
10726
10721
|
textSignature?: string;
|
|
@@ -10730,8 +10725,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10730
10725
|
mimeType: string;
|
|
10731
10726
|
})[];
|
|
10732
10727
|
details?: any;
|
|
10728
|
+
isError: false;
|
|
10733
10729
|
};
|
|
10734
|
-
status: "
|
|
10730
|
+
status: "completed";
|
|
10735
10731
|
thoughtSignature?: string;
|
|
10736
10732
|
time: {
|
|
10737
10733
|
start: number;
|
|
@@ -10755,9 +10751,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10755
10751
|
mimeType: string;
|
|
10756
10752
|
})[];
|
|
10757
10753
|
details?: any;
|
|
10758
|
-
isError:
|
|
10754
|
+
isError: true;
|
|
10759
10755
|
};
|
|
10760
|
-
status: "
|
|
10756
|
+
status: "error";
|
|
10761
10757
|
thoughtSignature?: string;
|
|
10762
10758
|
time: {
|
|
10763
10759
|
start: number;
|
|
@@ -10783,7 +10779,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10783
10779
|
details?: any;
|
|
10784
10780
|
isError: true;
|
|
10785
10781
|
};
|
|
10786
|
-
status: "
|
|
10782
|
+
status: "skipped";
|
|
10787
10783
|
thoughtSignature?: string;
|
|
10788
10784
|
time: {
|
|
10789
10785
|
start: number;
|
|
@@ -10809,21 +10805,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10809
10805
|
details?: any;
|
|
10810
10806
|
isError: true;
|
|
10811
10807
|
};
|
|
10812
|
-
status: "
|
|
10808
|
+
status: "aborted";
|
|
10813
10809
|
thoughtSignature?: string;
|
|
10814
10810
|
time: {
|
|
10815
10811
|
start: number;
|
|
10816
10812
|
end: number;
|
|
10817
10813
|
};
|
|
10818
10814
|
type: "toolCall";
|
|
10815
|
+
} | {
|
|
10816
|
+
type: "thinking";
|
|
10817
|
+
thinking: string;
|
|
10818
|
+
thinkingSignature?: string;
|
|
10819
|
+
redacted?: boolean;
|
|
10819
10820
|
} | {
|
|
10820
10821
|
addedToolNames?: string[];
|
|
10821
10822
|
arguments: Record<string, any>;
|
|
10822
10823
|
callID: string;
|
|
10823
10824
|
name: string;
|
|
10824
10825
|
namespace?: string;
|
|
10825
|
-
|
|
10826
|
-
content
|
|
10826
|
+
partial?: {
|
|
10827
|
+
content?: ({
|
|
10827
10828
|
type: "text";
|
|
10828
10829
|
text: string;
|
|
10829
10830
|
textSignature?: string;
|
|
@@ -10833,9 +10834,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10833
10834
|
mimeType: string;
|
|
10834
10835
|
})[];
|
|
10835
10836
|
details?: any;
|
|
10836
|
-
isError: true;
|
|
10837
10837
|
};
|
|
10838
|
-
status: "
|
|
10838
|
+
status: "running";
|
|
10839
10839
|
thoughtSignature?: string;
|
|
10840
10840
|
time: {
|
|
10841
10841
|
start: number;
|
|
@@ -11028,19 +11028,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11028
11028
|
type: "image";
|
|
11029
11029
|
data: string;
|
|
11030
11030
|
mimeType: string;
|
|
11031
|
-
} | {
|
|
11032
|
-
type: "thinking";
|
|
11033
|
-
thinking: string;
|
|
11034
|
-
thinkingSignature?: string;
|
|
11035
|
-
redacted?: boolean;
|
|
11036
11031
|
} | {
|
|
11037
11032
|
addedToolNames?: string[];
|
|
11038
11033
|
arguments: Record<string, any>;
|
|
11039
11034
|
callID: string;
|
|
11040
11035
|
name: string;
|
|
11041
11036
|
namespace?: string;
|
|
11042
|
-
|
|
11043
|
-
content
|
|
11037
|
+
result: {
|
|
11038
|
+
content: ({
|
|
11044
11039
|
type: "text";
|
|
11045
11040
|
text: string;
|
|
11046
11041
|
textSignature?: string;
|
|
@@ -11050,8 +11045,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11050
11045
|
mimeType: string;
|
|
11051
11046
|
})[];
|
|
11052
11047
|
details?: any;
|
|
11048
|
+
isError: false;
|
|
11053
11049
|
};
|
|
11054
|
-
status: "
|
|
11050
|
+
status: "completed";
|
|
11055
11051
|
thoughtSignature?: string;
|
|
11056
11052
|
time: {
|
|
11057
11053
|
start: number;
|
|
@@ -11075,9 +11071,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11075
11071
|
mimeType: string;
|
|
11076
11072
|
})[];
|
|
11077
11073
|
details?: any;
|
|
11078
|
-
isError:
|
|
11074
|
+
isError: true;
|
|
11079
11075
|
};
|
|
11080
|
-
status: "
|
|
11076
|
+
status: "error";
|
|
11081
11077
|
thoughtSignature?: string;
|
|
11082
11078
|
time: {
|
|
11083
11079
|
start: number;
|
|
@@ -11103,7 +11099,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11103
11099
|
details?: any;
|
|
11104
11100
|
isError: true;
|
|
11105
11101
|
};
|
|
11106
|
-
status: "
|
|
11102
|
+
status: "skipped";
|
|
11107
11103
|
thoughtSignature?: string;
|
|
11108
11104
|
time: {
|
|
11109
11105
|
start: number;
|
|
@@ -11129,21 +11125,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11129
11125
|
details?: any;
|
|
11130
11126
|
isError: true;
|
|
11131
11127
|
};
|
|
11132
|
-
status: "
|
|
11128
|
+
status: "aborted";
|
|
11133
11129
|
thoughtSignature?: string;
|
|
11134
11130
|
time: {
|
|
11135
11131
|
start: number;
|
|
11136
11132
|
end: number;
|
|
11137
11133
|
};
|
|
11138
11134
|
type: "toolCall";
|
|
11135
|
+
} | {
|
|
11136
|
+
type: "thinking";
|
|
11137
|
+
thinking: string;
|
|
11138
|
+
thinkingSignature?: string;
|
|
11139
|
+
redacted?: boolean;
|
|
11139
11140
|
} | {
|
|
11140
11141
|
addedToolNames?: string[];
|
|
11141
11142
|
arguments: Record<string, any>;
|
|
11142
11143
|
callID: string;
|
|
11143
11144
|
name: string;
|
|
11144
11145
|
namespace?: string;
|
|
11145
|
-
|
|
11146
|
-
content
|
|
11146
|
+
partial?: {
|
|
11147
|
+
content?: ({
|
|
11147
11148
|
type: "text";
|
|
11148
11149
|
text: string;
|
|
11149
11150
|
textSignature?: string;
|
|
@@ -11153,9 +11154,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11153
11154
|
mimeType: string;
|
|
11154
11155
|
})[];
|
|
11155
11156
|
details?: any;
|
|
11156
|
-
isError: true;
|
|
11157
11157
|
};
|
|
11158
|
-
status: "
|
|
11158
|
+
status: "running";
|
|
11159
11159
|
thoughtSignature?: string;
|
|
11160
11160
|
time: {
|
|
11161
11161
|
start: number;
|
|
@@ -11330,19 +11330,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11330
11330
|
type: "image";
|
|
11331
11331
|
data: string;
|
|
11332
11332
|
mimeType: string;
|
|
11333
|
-
} | {
|
|
11334
|
-
type: "thinking";
|
|
11335
|
-
thinking: string;
|
|
11336
|
-
thinkingSignature?: string;
|
|
11337
|
-
redacted?: boolean;
|
|
11338
11333
|
} | {
|
|
11339
11334
|
addedToolNames?: string[];
|
|
11340
11335
|
arguments: Record<string, any>;
|
|
11341
11336
|
callID: string;
|
|
11342
11337
|
name: string;
|
|
11343
11338
|
namespace?: string;
|
|
11344
|
-
|
|
11345
|
-
content
|
|
11339
|
+
result: {
|
|
11340
|
+
content: ({
|
|
11346
11341
|
type: "text";
|
|
11347
11342
|
text: string;
|
|
11348
11343
|
textSignature?: string;
|
|
@@ -11352,8 +11347,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11352
11347
|
mimeType: string;
|
|
11353
11348
|
})[];
|
|
11354
11349
|
details?: any;
|
|
11350
|
+
isError: false;
|
|
11355
11351
|
};
|
|
11356
|
-
status: "
|
|
11352
|
+
status: "completed";
|
|
11357
11353
|
thoughtSignature?: string;
|
|
11358
11354
|
time: {
|
|
11359
11355
|
start: number;
|
|
@@ -11377,9 +11373,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11377
11373
|
mimeType: string;
|
|
11378
11374
|
})[];
|
|
11379
11375
|
details?: any;
|
|
11380
|
-
isError:
|
|
11376
|
+
isError: true;
|
|
11381
11377
|
};
|
|
11382
|
-
status: "
|
|
11378
|
+
status: "error";
|
|
11383
11379
|
thoughtSignature?: string;
|
|
11384
11380
|
time: {
|
|
11385
11381
|
start: number;
|
|
@@ -11405,7 +11401,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11405
11401
|
details?: any;
|
|
11406
11402
|
isError: true;
|
|
11407
11403
|
};
|
|
11408
|
-
status: "
|
|
11404
|
+
status: "skipped";
|
|
11409
11405
|
thoughtSignature?: string;
|
|
11410
11406
|
time: {
|
|
11411
11407
|
start: number;
|
|
@@ -11431,21 +11427,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11431
11427
|
details?: any;
|
|
11432
11428
|
isError: true;
|
|
11433
11429
|
};
|
|
11434
|
-
status: "
|
|
11430
|
+
status: "aborted";
|
|
11435
11431
|
thoughtSignature?: string;
|
|
11436
11432
|
time: {
|
|
11437
11433
|
start: number;
|
|
11438
11434
|
end: number;
|
|
11439
11435
|
};
|
|
11440
11436
|
type: "toolCall";
|
|
11437
|
+
} | {
|
|
11438
|
+
type: "thinking";
|
|
11439
|
+
thinking: string;
|
|
11440
|
+
thinkingSignature?: string;
|
|
11441
|
+
redacted?: boolean;
|
|
11441
11442
|
} | {
|
|
11442
11443
|
addedToolNames?: string[];
|
|
11443
11444
|
arguments: Record<string, any>;
|
|
11444
11445
|
callID: string;
|
|
11445
11446
|
name: string;
|
|
11446
11447
|
namespace?: string;
|
|
11447
|
-
|
|
11448
|
-
content
|
|
11448
|
+
partial?: {
|
|
11449
|
+
content?: ({
|
|
11449
11450
|
type: "text";
|
|
11450
11451
|
text: string;
|
|
11451
11452
|
textSignature?: string;
|
|
@@ -11455,9 +11456,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11455
11456
|
mimeType: string;
|
|
11456
11457
|
})[];
|
|
11457
11458
|
details?: any;
|
|
11458
|
-
isError: true;
|
|
11459
11459
|
};
|
|
11460
|
-
status: "
|
|
11460
|
+
status: "running";
|
|
11461
11461
|
thoughtSignature?: string;
|
|
11462
11462
|
time: {
|
|
11463
11463
|
start: number;
|
|
@@ -11938,19 +11938,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11938
11938
|
type: "image";
|
|
11939
11939
|
data: string;
|
|
11940
11940
|
mimeType: string;
|
|
11941
|
-
} | {
|
|
11942
|
-
type: "thinking";
|
|
11943
|
-
thinking: string;
|
|
11944
|
-
thinkingSignature?: string;
|
|
11945
|
-
redacted?: boolean;
|
|
11946
11941
|
} | {
|
|
11947
11942
|
addedToolNames?: string[];
|
|
11948
11943
|
arguments: Record<string, any>;
|
|
11949
11944
|
callID: string;
|
|
11950
11945
|
name: string;
|
|
11951
11946
|
namespace?: string;
|
|
11952
|
-
|
|
11953
|
-
content
|
|
11947
|
+
result: {
|
|
11948
|
+
content: ({
|
|
11954
11949
|
type: "text";
|
|
11955
11950
|
text: string;
|
|
11956
11951
|
textSignature?: string;
|
|
@@ -11960,8 +11955,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11960
11955
|
mimeType: string;
|
|
11961
11956
|
})[];
|
|
11962
11957
|
details?: any;
|
|
11958
|
+
isError: false;
|
|
11963
11959
|
};
|
|
11964
|
-
status: "
|
|
11960
|
+
status: "completed";
|
|
11965
11961
|
thoughtSignature?: string;
|
|
11966
11962
|
time: {
|
|
11967
11963
|
start: number;
|
|
@@ -11985,9 +11981,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11985
11981
|
mimeType: string;
|
|
11986
11982
|
})[];
|
|
11987
11983
|
details?: any;
|
|
11988
|
-
isError:
|
|
11984
|
+
isError: true;
|
|
11989
11985
|
};
|
|
11990
|
-
status: "
|
|
11986
|
+
status: "error";
|
|
11991
11987
|
thoughtSignature?: string;
|
|
11992
11988
|
time: {
|
|
11993
11989
|
start: number;
|
|
@@ -12013,7 +12009,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12013
12009
|
details?: any;
|
|
12014
12010
|
isError: true;
|
|
12015
12011
|
};
|
|
12016
|
-
status: "
|
|
12012
|
+
status: "skipped";
|
|
12017
12013
|
thoughtSignature?: string;
|
|
12018
12014
|
time: {
|
|
12019
12015
|
start: number;
|
|
@@ -12039,21 +12035,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12039
12035
|
details?: any;
|
|
12040
12036
|
isError: true;
|
|
12041
12037
|
};
|
|
12042
|
-
status: "
|
|
12038
|
+
status: "aborted";
|
|
12043
12039
|
thoughtSignature?: string;
|
|
12044
12040
|
time: {
|
|
12045
12041
|
start: number;
|
|
12046
12042
|
end: number;
|
|
12047
12043
|
};
|
|
12048
12044
|
type: "toolCall";
|
|
12045
|
+
} | {
|
|
12046
|
+
type: "thinking";
|
|
12047
|
+
thinking: string;
|
|
12048
|
+
thinkingSignature?: string;
|
|
12049
|
+
redacted?: boolean;
|
|
12049
12050
|
} | {
|
|
12050
12051
|
addedToolNames?: string[];
|
|
12051
12052
|
arguments: Record<string, any>;
|
|
12052
12053
|
callID: string;
|
|
12053
12054
|
name: string;
|
|
12054
12055
|
namespace?: string;
|
|
12055
|
-
|
|
12056
|
-
content
|
|
12056
|
+
partial?: {
|
|
12057
|
+
content?: ({
|
|
12057
12058
|
type: "text";
|
|
12058
12059
|
text: string;
|
|
12059
12060
|
textSignature?: string;
|
|
@@ -12063,9 +12064,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12063
12064
|
mimeType: string;
|
|
12064
12065
|
})[];
|
|
12065
12066
|
details?: any;
|
|
12066
|
-
isError: true;
|
|
12067
12067
|
};
|
|
12068
|
-
status: "
|
|
12068
|
+
status: "running";
|
|
12069
12069
|
thoughtSignature?: string;
|
|
12070
12070
|
time: {
|
|
12071
12071
|
start: number;
|
|
@@ -12240,19 +12240,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12240
12240
|
type: "image";
|
|
12241
12241
|
data: string;
|
|
12242
12242
|
mimeType: string;
|
|
12243
|
-
} | {
|
|
12244
|
-
type: "thinking";
|
|
12245
|
-
thinking: string;
|
|
12246
|
-
thinkingSignature?: string;
|
|
12247
|
-
redacted?: boolean;
|
|
12248
12243
|
} | {
|
|
12249
12244
|
addedToolNames?: string[];
|
|
12250
12245
|
arguments: Record<string, any>;
|
|
12251
12246
|
callID: string;
|
|
12252
12247
|
name: string;
|
|
12253
12248
|
namespace?: string;
|
|
12254
|
-
|
|
12255
|
-
content
|
|
12249
|
+
result: {
|
|
12250
|
+
content: ({
|
|
12256
12251
|
type: "text";
|
|
12257
12252
|
text: string;
|
|
12258
12253
|
textSignature?: string;
|
|
@@ -12262,8 +12257,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12262
12257
|
mimeType: string;
|
|
12263
12258
|
})[];
|
|
12264
12259
|
details?: any;
|
|
12260
|
+
isError: false;
|
|
12265
12261
|
};
|
|
12266
|
-
status: "
|
|
12262
|
+
status: "completed";
|
|
12267
12263
|
thoughtSignature?: string;
|
|
12268
12264
|
time: {
|
|
12269
12265
|
start: number;
|
|
@@ -12287,9 +12283,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12287
12283
|
mimeType: string;
|
|
12288
12284
|
})[];
|
|
12289
12285
|
details?: any;
|
|
12290
|
-
isError:
|
|
12286
|
+
isError: true;
|
|
12291
12287
|
};
|
|
12292
|
-
status: "
|
|
12288
|
+
status: "error";
|
|
12293
12289
|
thoughtSignature?: string;
|
|
12294
12290
|
time: {
|
|
12295
12291
|
start: number;
|
|
@@ -12315,7 +12311,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12315
12311
|
details?: any;
|
|
12316
12312
|
isError: true;
|
|
12317
12313
|
};
|
|
12318
|
-
status: "
|
|
12314
|
+
status: "skipped";
|
|
12319
12315
|
thoughtSignature?: string;
|
|
12320
12316
|
time: {
|
|
12321
12317
|
start: number;
|
|
@@ -12341,21 +12337,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12341
12337
|
details?: any;
|
|
12342
12338
|
isError: true;
|
|
12343
12339
|
};
|
|
12344
|
-
status: "
|
|
12340
|
+
status: "aborted";
|
|
12345
12341
|
thoughtSignature?: string;
|
|
12346
12342
|
time: {
|
|
12347
12343
|
start: number;
|
|
12348
12344
|
end: number;
|
|
12349
12345
|
};
|
|
12350
12346
|
type: "toolCall";
|
|
12347
|
+
} | {
|
|
12348
|
+
type: "thinking";
|
|
12349
|
+
thinking: string;
|
|
12350
|
+
thinkingSignature?: string;
|
|
12351
|
+
redacted?: boolean;
|
|
12351
12352
|
} | {
|
|
12352
12353
|
addedToolNames?: string[];
|
|
12353
12354
|
arguments: Record<string, any>;
|
|
12354
12355
|
callID: string;
|
|
12355
12356
|
name: string;
|
|
12356
12357
|
namespace?: string;
|
|
12357
|
-
|
|
12358
|
-
content
|
|
12358
|
+
partial?: {
|
|
12359
|
+
content?: ({
|
|
12359
12360
|
type: "text";
|
|
12360
12361
|
text: string;
|
|
12361
12362
|
textSignature?: string;
|
|
@@ -12365,9 +12366,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12365
12366
|
mimeType: string;
|
|
12366
12367
|
})[];
|
|
12367
12368
|
details?: any;
|
|
12368
|
-
isError: true;
|
|
12369
12369
|
};
|
|
12370
|
-
status: "
|
|
12370
|
+
status: "running";
|
|
12371
12371
|
thoughtSignature?: string;
|
|
12372
12372
|
time: {
|
|
12373
12373
|
start: number;
|
|
@@ -12561,19 +12561,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12561
12561
|
type: "image";
|
|
12562
12562
|
data: string;
|
|
12563
12563
|
mimeType: string;
|
|
12564
|
-
} | {
|
|
12565
|
-
type: "thinking";
|
|
12566
|
-
thinking: string;
|
|
12567
|
-
thinkingSignature?: string;
|
|
12568
|
-
redacted?: boolean;
|
|
12569
12564
|
} | {
|
|
12570
12565
|
addedToolNames?: string[];
|
|
12571
12566
|
arguments: Record<string, any>;
|
|
12572
12567
|
callID: string;
|
|
12573
12568
|
name: string;
|
|
12574
12569
|
namespace?: string;
|
|
12575
|
-
|
|
12576
|
-
content
|
|
12570
|
+
result: {
|
|
12571
|
+
content: ({
|
|
12577
12572
|
type: "text";
|
|
12578
12573
|
text: string;
|
|
12579
12574
|
textSignature?: string;
|
|
@@ -12583,8 +12578,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12583
12578
|
mimeType: string;
|
|
12584
12579
|
})[];
|
|
12585
12580
|
details?: any;
|
|
12581
|
+
isError: false;
|
|
12586
12582
|
};
|
|
12587
|
-
status: "
|
|
12583
|
+
status: "completed";
|
|
12588
12584
|
thoughtSignature?: string;
|
|
12589
12585
|
time: {
|
|
12590
12586
|
start: number;
|
|
@@ -12608,9 +12604,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12608
12604
|
mimeType: string;
|
|
12609
12605
|
})[];
|
|
12610
12606
|
details?: any;
|
|
12611
|
-
isError:
|
|
12607
|
+
isError: true;
|
|
12612
12608
|
};
|
|
12613
|
-
status: "
|
|
12609
|
+
status: "error";
|
|
12614
12610
|
thoughtSignature?: string;
|
|
12615
12611
|
time: {
|
|
12616
12612
|
start: number;
|
|
@@ -12636,7 +12632,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12636
12632
|
details?: any;
|
|
12637
12633
|
isError: true;
|
|
12638
12634
|
};
|
|
12639
|
-
status: "
|
|
12635
|
+
status: "skipped";
|
|
12640
12636
|
thoughtSignature?: string;
|
|
12641
12637
|
time: {
|
|
12642
12638
|
start: number;
|
|
@@ -12662,21 +12658,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12662
12658
|
details?: any;
|
|
12663
12659
|
isError: true;
|
|
12664
12660
|
};
|
|
12665
|
-
status: "
|
|
12661
|
+
status: "aborted";
|
|
12666
12662
|
thoughtSignature?: string;
|
|
12667
12663
|
time: {
|
|
12668
12664
|
start: number;
|
|
12669
12665
|
end: number;
|
|
12670
12666
|
};
|
|
12671
12667
|
type: "toolCall";
|
|
12668
|
+
} | {
|
|
12669
|
+
type: "thinking";
|
|
12670
|
+
thinking: string;
|
|
12671
|
+
thinkingSignature?: string;
|
|
12672
|
+
redacted?: boolean;
|
|
12672
12673
|
} | {
|
|
12673
12674
|
addedToolNames?: string[];
|
|
12674
12675
|
arguments: Record<string, any>;
|
|
12675
12676
|
callID: string;
|
|
12676
12677
|
name: string;
|
|
12677
12678
|
namespace?: string;
|
|
12678
|
-
|
|
12679
|
-
content
|
|
12679
|
+
partial?: {
|
|
12680
|
+
content?: ({
|
|
12680
12681
|
type: "text";
|
|
12681
12682
|
text: string;
|
|
12682
12683
|
textSignature?: string;
|
|
@@ -12686,9 +12687,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12686
12687
|
mimeType: string;
|
|
12687
12688
|
})[];
|
|
12688
12689
|
details?: any;
|
|
12689
|
-
isError: true;
|
|
12690
12690
|
};
|
|
12691
|
-
status: "
|
|
12691
|
+
status: "running";
|
|
12692
12692
|
thoughtSignature?: string;
|
|
12693
12693
|
time: {
|
|
12694
12694
|
start: number;
|
|
@@ -12863,19 +12863,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12863
12863
|
type: "image";
|
|
12864
12864
|
data: string;
|
|
12865
12865
|
mimeType: string;
|
|
12866
|
-
} | {
|
|
12867
|
-
type: "thinking";
|
|
12868
|
-
thinking: string;
|
|
12869
|
-
thinkingSignature?: string;
|
|
12870
|
-
redacted?: boolean;
|
|
12871
12866
|
} | {
|
|
12872
12867
|
addedToolNames?: string[];
|
|
12873
12868
|
arguments: Record<string, any>;
|
|
12874
12869
|
callID: string;
|
|
12875
12870
|
name: string;
|
|
12876
12871
|
namespace?: string;
|
|
12877
|
-
|
|
12878
|
-
content
|
|
12872
|
+
result: {
|
|
12873
|
+
content: ({
|
|
12879
12874
|
type: "text";
|
|
12880
12875
|
text: string;
|
|
12881
12876
|
textSignature?: string;
|
|
@@ -12885,8 +12880,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12885
12880
|
mimeType: string;
|
|
12886
12881
|
})[];
|
|
12887
12882
|
details?: any;
|
|
12883
|
+
isError: false;
|
|
12888
12884
|
};
|
|
12889
|
-
status: "
|
|
12885
|
+
status: "completed";
|
|
12890
12886
|
thoughtSignature?: string;
|
|
12891
12887
|
time: {
|
|
12892
12888
|
start: number;
|
|
@@ -12910,9 +12906,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12910
12906
|
mimeType: string;
|
|
12911
12907
|
})[];
|
|
12912
12908
|
details?: any;
|
|
12913
|
-
isError:
|
|
12909
|
+
isError: true;
|
|
12914
12910
|
};
|
|
12915
|
-
status: "
|
|
12911
|
+
status: "error";
|
|
12916
12912
|
thoughtSignature?: string;
|
|
12917
12913
|
time: {
|
|
12918
12914
|
start: number;
|
|
@@ -12938,7 +12934,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12938
12934
|
details?: any;
|
|
12939
12935
|
isError: true;
|
|
12940
12936
|
};
|
|
12941
|
-
status: "
|
|
12937
|
+
status: "skipped";
|
|
12942
12938
|
thoughtSignature?: string;
|
|
12943
12939
|
time: {
|
|
12944
12940
|
start: number;
|
|
@@ -12964,21 +12960,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12964
12960
|
details?: any;
|
|
12965
12961
|
isError: true;
|
|
12966
12962
|
};
|
|
12967
|
-
status: "
|
|
12963
|
+
status: "aborted";
|
|
12968
12964
|
thoughtSignature?: string;
|
|
12969
12965
|
time: {
|
|
12970
12966
|
start: number;
|
|
12971
12967
|
end: number;
|
|
12972
12968
|
};
|
|
12973
12969
|
type: "toolCall";
|
|
12970
|
+
} | {
|
|
12971
|
+
type: "thinking";
|
|
12972
|
+
thinking: string;
|
|
12973
|
+
thinkingSignature?: string;
|
|
12974
|
+
redacted?: boolean;
|
|
12974
12975
|
} | {
|
|
12975
12976
|
addedToolNames?: string[];
|
|
12976
12977
|
arguments: Record<string, any>;
|
|
12977
12978
|
callID: string;
|
|
12978
12979
|
name: string;
|
|
12979
12980
|
namespace?: string;
|
|
12980
|
-
|
|
12981
|
-
content
|
|
12981
|
+
partial?: {
|
|
12982
|
+
content?: ({
|
|
12982
12983
|
type: "text";
|
|
12983
12984
|
text: string;
|
|
12984
12985
|
textSignature?: string;
|
|
@@ -12988,9 +12989,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12988
12989
|
mimeType: string;
|
|
12989
12990
|
})[];
|
|
12990
12991
|
details?: any;
|
|
12991
|
-
isError: true;
|
|
12992
12992
|
};
|
|
12993
|
-
status: "
|
|
12993
|
+
status: "running";
|
|
12994
12994
|
thoughtSignature?: string;
|
|
12995
12995
|
time: {
|
|
12996
12996
|
start: number;
|
|
@@ -13193,19 +13193,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13193
13193
|
type: "image";
|
|
13194
13194
|
data: string;
|
|
13195
13195
|
mimeType: string;
|
|
13196
|
-
} | {
|
|
13197
|
-
type: "thinking";
|
|
13198
|
-
thinking: string;
|
|
13199
|
-
thinkingSignature?: string;
|
|
13200
|
-
redacted?: boolean;
|
|
13201
13196
|
} | {
|
|
13202
13197
|
addedToolNames?: string[];
|
|
13203
13198
|
arguments: Record<string, any>;
|
|
13204
13199
|
callID: string;
|
|
13205
13200
|
name: string;
|
|
13206
13201
|
namespace?: string;
|
|
13207
|
-
|
|
13208
|
-
content
|
|
13202
|
+
result: {
|
|
13203
|
+
content: ({
|
|
13209
13204
|
type: "text";
|
|
13210
13205
|
text: string;
|
|
13211
13206
|
textSignature?: string;
|
|
@@ -13215,8 +13210,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13215
13210
|
mimeType: string;
|
|
13216
13211
|
})[];
|
|
13217
13212
|
details?: any;
|
|
13213
|
+
isError: false;
|
|
13218
13214
|
};
|
|
13219
|
-
status: "
|
|
13215
|
+
status: "completed";
|
|
13220
13216
|
thoughtSignature?: string;
|
|
13221
13217
|
time: {
|
|
13222
13218
|
start: number;
|
|
@@ -13240,9 +13236,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13240
13236
|
mimeType: string;
|
|
13241
13237
|
})[];
|
|
13242
13238
|
details?: any;
|
|
13243
|
-
isError:
|
|
13239
|
+
isError: true;
|
|
13244
13240
|
};
|
|
13245
|
-
status: "
|
|
13241
|
+
status: "error";
|
|
13246
13242
|
thoughtSignature?: string;
|
|
13247
13243
|
time: {
|
|
13248
13244
|
start: number;
|
|
@@ -13268,7 +13264,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13268
13264
|
details?: any;
|
|
13269
13265
|
isError: true;
|
|
13270
13266
|
};
|
|
13271
|
-
status: "
|
|
13267
|
+
status: "skipped";
|
|
13272
13268
|
thoughtSignature?: string;
|
|
13273
13269
|
time: {
|
|
13274
13270
|
start: number;
|
|
@@ -13294,21 +13290,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13294
13290
|
details?: any;
|
|
13295
13291
|
isError: true;
|
|
13296
13292
|
};
|
|
13297
|
-
status: "
|
|
13293
|
+
status: "aborted";
|
|
13298
13294
|
thoughtSignature?: string;
|
|
13299
13295
|
time: {
|
|
13300
13296
|
start: number;
|
|
13301
13297
|
end: number;
|
|
13302
13298
|
};
|
|
13303
13299
|
type: "toolCall";
|
|
13300
|
+
} | {
|
|
13301
|
+
type: "thinking";
|
|
13302
|
+
thinking: string;
|
|
13303
|
+
thinkingSignature?: string;
|
|
13304
|
+
redacted?: boolean;
|
|
13304
13305
|
} | {
|
|
13305
13306
|
addedToolNames?: string[];
|
|
13306
13307
|
arguments: Record<string, any>;
|
|
13307
13308
|
callID: string;
|
|
13308
13309
|
name: string;
|
|
13309
13310
|
namespace?: string;
|
|
13310
|
-
|
|
13311
|
-
content
|
|
13311
|
+
partial?: {
|
|
13312
|
+
content?: ({
|
|
13312
13313
|
type: "text";
|
|
13313
13314
|
text: string;
|
|
13314
13315
|
textSignature?: string;
|
|
@@ -13318,9 +13319,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13318
13319
|
mimeType: string;
|
|
13319
13320
|
})[];
|
|
13320
13321
|
details?: any;
|
|
13321
|
-
isError: true;
|
|
13322
13322
|
};
|
|
13323
|
-
status: "
|
|
13323
|
+
status: "running";
|
|
13324
13324
|
thoughtSignature?: string;
|
|
13325
13325
|
time: {
|
|
13326
13326
|
start: number;
|
|
@@ -13495,19 +13495,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13495
13495
|
type: "image";
|
|
13496
13496
|
data: string;
|
|
13497
13497
|
mimeType: string;
|
|
13498
|
-
} | {
|
|
13499
|
-
type: "thinking";
|
|
13500
|
-
thinking: string;
|
|
13501
|
-
thinkingSignature?: string;
|
|
13502
|
-
redacted?: boolean;
|
|
13503
13498
|
} | {
|
|
13504
13499
|
addedToolNames?: string[];
|
|
13505
13500
|
arguments: Record<string, any>;
|
|
13506
13501
|
callID: string;
|
|
13507
13502
|
name: string;
|
|
13508
13503
|
namespace?: string;
|
|
13509
|
-
|
|
13510
|
-
content
|
|
13504
|
+
result: {
|
|
13505
|
+
content: ({
|
|
13511
13506
|
type: "text";
|
|
13512
13507
|
text: string;
|
|
13513
13508
|
textSignature?: string;
|
|
@@ -13517,8 +13512,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13517
13512
|
mimeType: string;
|
|
13518
13513
|
})[];
|
|
13519
13514
|
details?: any;
|
|
13515
|
+
isError: false;
|
|
13520
13516
|
};
|
|
13521
|
-
status: "
|
|
13517
|
+
status: "completed";
|
|
13522
13518
|
thoughtSignature?: string;
|
|
13523
13519
|
time: {
|
|
13524
13520
|
start: number;
|
|
@@ -13542,9 +13538,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13542
13538
|
mimeType: string;
|
|
13543
13539
|
})[];
|
|
13544
13540
|
details?: any;
|
|
13545
|
-
isError:
|
|
13541
|
+
isError: true;
|
|
13546
13542
|
};
|
|
13547
|
-
status: "
|
|
13543
|
+
status: "error";
|
|
13548
13544
|
thoughtSignature?: string;
|
|
13549
13545
|
time: {
|
|
13550
13546
|
start: number;
|
|
@@ -13570,7 +13566,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13570
13566
|
details?: any;
|
|
13571
13567
|
isError: true;
|
|
13572
13568
|
};
|
|
13573
|
-
status: "
|
|
13569
|
+
status: "skipped";
|
|
13574
13570
|
thoughtSignature?: string;
|
|
13575
13571
|
time: {
|
|
13576
13572
|
start: number;
|
|
@@ -13596,21 +13592,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13596
13592
|
details?: any;
|
|
13597
13593
|
isError: true;
|
|
13598
13594
|
};
|
|
13599
|
-
status: "
|
|
13595
|
+
status: "aborted";
|
|
13600
13596
|
thoughtSignature?: string;
|
|
13601
13597
|
time: {
|
|
13602
13598
|
start: number;
|
|
13603
13599
|
end: number;
|
|
13604
13600
|
};
|
|
13605
13601
|
type: "toolCall";
|
|
13602
|
+
} | {
|
|
13603
|
+
type: "thinking";
|
|
13604
|
+
thinking: string;
|
|
13605
|
+
thinkingSignature?: string;
|
|
13606
|
+
redacted?: boolean;
|
|
13606
13607
|
} | {
|
|
13607
13608
|
addedToolNames?: string[];
|
|
13608
13609
|
arguments: Record<string, any>;
|
|
13609
13610
|
callID: string;
|
|
13610
13611
|
name: string;
|
|
13611
13612
|
namespace?: string;
|
|
13612
|
-
|
|
13613
|
-
content
|
|
13613
|
+
partial?: {
|
|
13614
|
+
content?: ({
|
|
13614
13615
|
type: "text";
|
|
13615
13616
|
text: string;
|
|
13616
13617
|
textSignature?: string;
|
|
@@ -13620,9 +13621,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13620
13621
|
mimeType: string;
|
|
13621
13622
|
})[];
|
|
13622
13623
|
details?: any;
|
|
13623
|
-
isError: true;
|
|
13624
13624
|
};
|
|
13625
|
-
status: "
|
|
13625
|
+
status: "running";
|
|
13626
13626
|
thoughtSignature?: string;
|
|
13627
13627
|
time: {
|
|
13628
13628
|
start: number;
|
|
@@ -13816,19 +13816,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13816
13816
|
type: "image";
|
|
13817
13817
|
data: string;
|
|
13818
13818
|
mimeType: string;
|
|
13819
|
-
} | {
|
|
13820
|
-
type: "thinking";
|
|
13821
|
-
thinking: string;
|
|
13822
|
-
thinkingSignature?: string;
|
|
13823
|
-
redacted?: boolean;
|
|
13824
13819
|
} | {
|
|
13825
13820
|
addedToolNames?: string[];
|
|
13826
13821
|
arguments: Record<string, any>;
|
|
13827
13822
|
callID: string;
|
|
13828
13823
|
name: string;
|
|
13829
13824
|
namespace?: string;
|
|
13830
|
-
|
|
13831
|
-
content
|
|
13825
|
+
result: {
|
|
13826
|
+
content: ({
|
|
13832
13827
|
type: "text";
|
|
13833
13828
|
text: string;
|
|
13834
13829
|
textSignature?: string;
|
|
@@ -13838,8 +13833,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13838
13833
|
mimeType: string;
|
|
13839
13834
|
})[];
|
|
13840
13835
|
details?: any;
|
|
13836
|
+
isError: false;
|
|
13841
13837
|
};
|
|
13842
|
-
status: "
|
|
13838
|
+
status: "completed";
|
|
13843
13839
|
thoughtSignature?: string;
|
|
13844
13840
|
time: {
|
|
13845
13841
|
start: number;
|
|
@@ -13863,9 +13859,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13863
13859
|
mimeType: string;
|
|
13864
13860
|
})[];
|
|
13865
13861
|
details?: any;
|
|
13866
|
-
isError:
|
|
13862
|
+
isError: true;
|
|
13867
13863
|
};
|
|
13868
|
-
status: "
|
|
13864
|
+
status: "error";
|
|
13869
13865
|
thoughtSignature?: string;
|
|
13870
13866
|
time: {
|
|
13871
13867
|
start: number;
|
|
@@ -13891,7 +13887,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13891
13887
|
details?: any;
|
|
13892
13888
|
isError: true;
|
|
13893
13889
|
};
|
|
13894
|
-
status: "
|
|
13890
|
+
status: "skipped";
|
|
13895
13891
|
thoughtSignature?: string;
|
|
13896
13892
|
time: {
|
|
13897
13893
|
start: number;
|
|
@@ -13917,21 +13913,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13917
13913
|
details?: any;
|
|
13918
13914
|
isError: true;
|
|
13919
13915
|
};
|
|
13920
|
-
status: "
|
|
13916
|
+
status: "aborted";
|
|
13921
13917
|
thoughtSignature?: string;
|
|
13922
13918
|
time: {
|
|
13923
13919
|
start: number;
|
|
13924
13920
|
end: number;
|
|
13925
13921
|
};
|
|
13926
13922
|
type: "toolCall";
|
|
13923
|
+
} | {
|
|
13924
|
+
type: "thinking";
|
|
13925
|
+
thinking: string;
|
|
13926
|
+
thinkingSignature?: string;
|
|
13927
|
+
redacted?: boolean;
|
|
13927
13928
|
} | {
|
|
13928
13929
|
addedToolNames?: string[];
|
|
13929
13930
|
arguments: Record<string, any>;
|
|
13930
13931
|
callID: string;
|
|
13931
13932
|
name: string;
|
|
13932
13933
|
namespace?: string;
|
|
13933
|
-
|
|
13934
|
-
content
|
|
13934
|
+
partial?: {
|
|
13935
|
+
content?: ({
|
|
13935
13936
|
type: "text";
|
|
13936
13937
|
text: string;
|
|
13937
13938
|
textSignature?: string;
|
|
@@ -13941,9 +13942,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13941
13942
|
mimeType: string;
|
|
13942
13943
|
})[];
|
|
13943
13944
|
details?: any;
|
|
13944
|
-
isError: true;
|
|
13945
13945
|
};
|
|
13946
|
-
status: "
|
|
13946
|
+
status: "running";
|
|
13947
13947
|
thoughtSignature?: string;
|
|
13948
13948
|
time: {
|
|
13949
13949
|
start: number;
|
|
@@ -14118,19 +14118,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14118
14118
|
type: "image";
|
|
14119
14119
|
data: string;
|
|
14120
14120
|
mimeType: string;
|
|
14121
|
-
} | {
|
|
14122
|
-
type: "thinking";
|
|
14123
|
-
thinking: string;
|
|
14124
|
-
thinkingSignature?: string;
|
|
14125
|
-
redacted?: boolean;
|
|
14126
14121
|
} | {
|
|
14127
14122
|
addedToolNames?: string[];
|
|
14128
14123
|
arguments: Record<string, any>;
|
|
14129
14124
|
callID: string;
|
|
14130
14125
|
name: string;
|
|
14131
14126
|
namespace?: string;
|
|
14132
|
-
|
|
14133
|
-
content
|
|
14127
|
+
result: {
|
|
14128
|
+
content: ({
|
|
14134
14129
|
type: "text";
|
|
14135
14130
|
text: string;
|
|
14136
14131
|
textSignature?: string;
|
|
@@ -14140,8 +14135,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14140
14135
|
mimeType: string;
|
|
14141
14136
|
})[];
|
|
14142
14137
|
details?: any;
|
|
14138
|
+
isError: false;
|
|
14143
14139
|
};
|
|
14144
|
-
status: "
|
|
14140
|
+
status: "completed";
|
|
14145
14141
|
thoughtSignature?: string;
|
|
14146
14142
|
time: {
|
|
14147
14143
|
start: number;
|
|
@@ -14165,9 +14161,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14165
14161
|
mimeType: string;
|
|
14166
14162
|
})[];
|
|
14167
14163
|
details?: any;
|
|
14168
|
-
isError:
|
|
14164
|
+
isError: true;
|
|
14169
14165
|
};
|
|
14170
|
-
status: "
|
|
14166
|
+
status: "error";
|
|
14171
14167
|
thoughtSignature?: string;
|
|
14172
14168
|
time: {
|
|
14173
14169
|
start: number;
|
|
@@ -14193,7 +14189,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14193
14189
|
details?: any;
|
|
14194
14190
|
isError: true;
|
|
14195
14191
|
};
|
|
14196
|
-
status: "
|
|
14192
|
+
status: "skipped";
|
|
14197
14193
|
thoughtSignature?: string;
|
|
14198
14194
|
time: {
|
|
14199
14195
|
start: number;
|
|
@@ -14219,21 +14215,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14219
14215
|
details?: any;
|
|
14220
14216
|
isError: true;
|
|
14221
14217
|
};
|
|
14222
|
-
status: "
|
|
14218
|
+
status: "aborted";
|
|
14223
14219
|
thoughtSignature?: string;
|
|
14224
14220
|
time: {
|
|
14225
14221
|
start: number;
|
|
14226
14222
|
end: number;
|
|
14227
14223
|
};
|
|
14228
14224
|
type: "toolCall";
|
|
14225
|
+
} | {
|
|
14226
|
+
type: "thinking";
|
|
14227
|
+
thinking: string;
|
|
14228
|
+
thinkingSignature?: string;
|
|
14229
|
+
redacted?: boolean;
|
|
14229
14230
|
} | {
|
|
14230
14231
|
addedToolNames?: string[];
|
|
14231
14232
|
arguments: Record<string, any>;
|
|
14232
14233
|
callID: string;
|
|
14233
14234
|
name: string;
|
|
14234
14235
|
namespace?: string;
|
|
14235
|
-
|
|
14236
|
-
content
|
|
14236
|
+
partial?: {
|
|
14237
|
+
content?: ({
|
|
14237
14238
|
type: "text";
|
|
14238
14239
|
text: string;
|
|
14239
14240
|
textSignature?: string;
|
|
@@ -14243,9 +14244,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14243
14244
|
mimeType: string;
|
|
14244
14245
|
})[];
|
|
14245
14246
|
details?: any;
|
|
14246
|
-
isError: true;
|
|
14247
14247
|
};
|
|
14248
|
-
status: "
|
|
14248
|
+
status: "running";
|
|
14249
14249
|
thoughtSignature?: string;
|
|
14250
14250
|
time: {
|
|
14251
14251
|
start: number;
|
|
@@ -15754,19 +15754,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15754
15754
|
type: "image";
|
|
15755
15755
|
data: string;
|
|
15756
15756
|
mimeType: string;
|
|
15757
|
-
} | {
|
|
15758
|
-
type: "thinking";
|
|
15759
|
-
thinking: string;
|
|
15760
|
-
thinkingSignature?: string;
|
|
15761
|
-
redacted?: boolean;
|
|
15762
15757
|
} | {
|
|
15763
15758
|
addedToolNames?: string[];
|
|
15764
15759
|
arguments: Record<string, any>;
|
|
15765
15760
|
callID: string;
|
|
15766
15761
|
name: string;
|
|
15767
15762
|
namespace?: string;
|
|
15768
|
-
|
|
15769
|
-
content
|
|
15763
|
+
result: {
|
|
15764
|
+
content: ({
|
|
15770
15765
|
type: "text";
|
|
15771
15766
|
text: string;
|
|
15772
15767
|
textSignature?: string;
|
|
@@ -15776,8 +15771,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15776
15771
|
mimeType: string;
|
|
15777
15772
|
})[];
|
|
15778
15773
|
details?: any;
|
|
15774
|
+
isError: false;
|
|
15779
15775
|
};
|
|
15780
|
-
status: "
|
|
15776
|
+
status: "completed";
|
|
15781
15777
|
thoughtSignature?: string;
|
|
15782
15778
|
time: {
|
|
15783
15779
|
start: number;
|
|
@@ -15801,9 +15797,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15801
15797
|
mimeType: string;
|
|
15802
15798
|
})[];
|
|
15803
15799
|
details?: any;
|
|
15804
|
-
isError:
|
|
15800
|
+
isError: true;
|
|
15805
15801
|
};
|
|
15806
|
-
status: "
|
|
15802
|
+
status: "error";
|
|
15807
15803
|
thoughtSignature?: string;
|
|
15808
15804
|
time: {
|
|
15809
15805
|
start: number;
|
|
@@ -15829,7 +15825,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15829
15825
|
details?: any;
|
|
15830
15826
|
isError: true;
|
|
15831
15827
|
};
|
|
15832
|
-
status: "
|
|
15828
|
+
status: "skipped";
|
|
15833
15829
|
thoughtSignature?: string;
|
|
15834
15830
|
time: {
|
|
15835
15831
|
start: number;
|
|
@@ -15855,21 +15851,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15855
15851
|
details?: any;
|
|
15856
15852
|
isError: true;
|
|
15857
15853
|
};
|
|
15858
|
-
status: "
|
|
15854
|
+
status: "aborted";
|
|
15859
15855
|
thoughtSignature?: string;
|
|
15860
15856
|
time: {
|
|
15861
15857
|
start: number;
|
|
15862
15858
|
end: number;
|
|
15863
15859
|
};
|
|
15864
15860
|
type: "toolCall";
|
|
15861
|
+
} | {
|
|
15862
|
+
type: "thinking";
|
|
15863
|
+
thinking: string;
|
|
15864
|
+
thinkingSignature?: string;
|
|
15865
|
+
redacted?: boolean;
|
|
15865
15866
|
} | {
|
|
15866
15867
|
addedToolNames?: string[];
|
|
15867
15868
|
arguments: Record<string, any>;
|
|
15868
15869
|
callID: string;
|
|
15869
15870
|
name: string;
|
|
15870
15871
|
namespace?: string;
|
|
15871
|
-
|
|
15872
|
-
content
|
|
15872
|
+
partial?: {
|
|
15873
|
+
content?: ({
|
|
15873
15874
|
type: "text";
|
|
15874
15875
|
text: string;
|
|
15875
15876
|
textSignature?: string;
|
|
@@ -15879,9 +15880,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15879
15880
|
mimeType: string;
|
|
15880
15881
|
})[];
|
|
15881
15882
|
details?: any;
|
|
15882
|
-
isError: true;
|
|
15883
15883
|
};
|
|
15884
|
-
status: "
|
|
15884
|
+
status: "running";
|
|
15885
15885
|
thoughtSignature?: string;
|
|
15886
15886
|
time: {
|
|
15887
15887
|
start: number;
|
|
@@ -16056,19 +16056,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16056
16056
|
type: "image";
|
|
16057
16057
|
data: string;
|
|
16058
16058
|
mimeType: string;
|
|
16059
|
-
} | {
|
|
16060
|
-
type: "thinking";
|
|
16061
|
-
thinking: string;
|
|
16062
|
-
thinkingSignature?: string;
|
|
16063
|
-
redacted?: boolean;
|
|
16064
16059
|
} | {
|
|
16065
16060
|
addedToolNames?: string[];
|
|
16066
16061
|
arguments: Record<string, any>;
|
|
16067
16062
|
callID: string;
|
|
16068
16063
|
name: string;
|
|
16069
16064
|
namespace?: string;
|
|
16070
|
-
|
|
16071
|
-
content
|
|
16065
|
+
result: {
|
|
16066
|
+
content: ({
|
|
16072
16067
|
type: "text";
|
|
16073
16068
|
text: string;
|
|
16074
16069
|
textSignature?: string;
|
|
@@ -16078,8 +16073,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16078
16073
|
mimeType: string;
|
|
16079
16074
|
})[];
|
|
16080
16075
|
details?: any;
|
|
16076
|
+
isError: false;
|
|
16081
16077
|
};
|
|
16082
|
-
status: "
|
|
16078
|
+
status: "completed";
|
|
16083
16079
|
thoughtSignature?: string;
|
|
16084
16080
|
time: {
|
|
16085
16081
|
start: number;
|
|
@@ -16103,9 +16099,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16103
16099
|
mimeType: string;
|
|
16104
16100
|
})[];
|
|
16105
16101
|
details?: any;
|
|
16106
|
-
isError:
|
|
16102
|
+
isError: true;
|
|
16107
16103
|
};
|
|
16108
|
-
status: "
|
|
16104
|
+
status: "error";
|
|
16109
16105
|
thoughtSignature?: string;
|
|
16110
16106
|
time: {
|
|
16111
16107
|
start: number;
|
|
@@ -16131,7 +16127,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16131
16127
|
details?: any;
|
|
16132
16128
|
isError: true;
|
|
16133
16129
|
};
|
|
16134
|
-
status: "
|
|
16130
|
+
status: "skipped";
|
|
16135
16131
|
thoughtSignature?: string;
|
|
16136
16132
|
time: {
|
|
16137
16133
|
start: number;
|
|
@@ -16157,21 +16153,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16157
16153
|
details?: any;
|
|
16158
16154
|
isError: true;
|
|
16159
16155
|
};
|
|
16160
|
-
status: "
|
|
16156
|
+
status: "aborted";
|
|
16161
16157
|
thoughtSignature?: string;
|
|
16162
16158
|
time: {
|
|
16163
16159
|
start: number;
|
|
16164
16160
|
end: number;
|
|
16165
16161
|
};
|
|
16166
16162
|
type: "toolCall";
|
|
16163
|
+
} | {
|
|
16164
|
+
type: "thinking";
|
|
16165
|
+
thinking: string;
|
|
16166
|
+
thinkingSignature?: string;
|
|
16167
|
+
redacted?: boolean;
|
|
16167
16168
|
} | {
|
|
16168
16169
|
addedToolNames?: string[];
|
|
16169
16170
|
arguments: Record<string, any>;
|
|
16170
16171
|
callID: string;
|
|
16171
16172
|
name: string;
|
|
16172
16173
|
namespace?: string;
|
|
16173
|
-
|
|
16174
|
-
content
|
|
16174
|
+
partial?: {
|
|
16175
|
+
content?: ({
|
|
16175
16176
|
type: "text";
|
|
16176
16177
|
text: string;
|
|
16177
16178
|
textSignature?: string;
|
|
@@ -16181,9 +16182,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16181
16182
|
mimeType: string;
|
|
16182
16183
|
})[];
|
|
16183
16184
|
details?: any;
|
|
16184
|
-
isError: true;
|
|
16185
16185
|
};
|
|
16186
|
-
status: "
|
|
16186
|
+
status: "running";
|
|
16187
16187
|
thoughtSignature?: string;
|
|
16188
16188
|
time: {
|
|
16189
16189
|
start: number;
|
|
@@ -16376,19 +16376,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16376
16376
|
type: "image";
|
|
16377
16377
|
data: string;
|
|
16378
16378
|
mimeType: string;
|
|
16379
|
-
} | {
|
|
16380
|
-
type: "thinking";
|
|
16381
|
-
thinking: string;
|
|
16382
|
-
thinkingSignature?: string;
|
|
16383
|
-
redacted?: boolean;
|
|
16384
16379
|
} | {
|
|
16385
16380
|
addedToolNames?: string[];
|
|
16386
16381
|
arguments: Record<string, any>;
|
|
16387
16382
|
callID: string;
|
|
16388
16383
|
name: string;
|
|
16389
16384
|
namespace?: string;
|
|
16390
|
-
|
|
16391
|
-
content
|
|
16385
|
+
result: {
|
|
16386
|
+
content: ({
|
|
16392
16387
|
type: "text";
|
|
16393
16388
|
text: string;
|
|
16394
16389
|
textSignature?: string;
|
|
@@ -16398,8 +16393,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16398
16393
|
mimeType: string;
|
|
16399
16394
|
})[];
|
|
16400
16395
|
details?: any;
|
|
16396
|
+
isError: false;
|
|
16401
16397
|
};
|
|
16402
|
-
status: "
|
|
16398
|
+
status: "completed";
|
|
16403
16399
|
thoughtSignature?: string;
|
|
16404
16400
|
time: {
|
|
16405
16401
|
start: number;
|
|
@@ -16423,9 +16419,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16423
16419
|
mimeType: string;
|
|
16424
16420
|
})[];
|
|
16425
16421
|
details?: any;
|
|
16426
|
-
isError:
|
|
16422
|
+
isError: true;
|
|
16427
16423
|
};
|
|
16428
|
-
status: "
|
|
16424
|
+
status: "error";
|
|
16429
16425
|
thoughtSignature?: string;
|
|
16430
16426
|
time: {
|
|
16431
16427
|
start: number;
|
|
@@ -16451,7 +16447,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16451
16447
|
details?: any;
|
|
16452
16448
|
isError: true;
|
|
16453
16449
|
};
|
|
16454
|
-
status: "
|
|
16450
|
+
status: "skipped";
|
|
16455
16451
|
thoughtSignature?: string;
|
|
16456
16452
|
time: {
|
|
16457
16453
|
start: number;
|
|
@@ -16477,21 +16473,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16477
16473
|
details?: any;
|
|
16478
16474
|
isError: true;
|
|
16479
16475
|
};
|
|
16480
|
-
status: "
|
|
16476
|
+
status: "aborted";
|
|
16481
16477
|
thoughtSignature?: string;
|
|
16482
16478
|
time: {
|
|
16483
16479
|
start: number;
|
|
16484
16480
|
end: number;
|
|
16485
16481
|
};
|
|
16486
16482
|
type: "toolCall";
|
|
16483
|
+
} | {
|
|
16484
|
+
type: "thinking";
|
|
16485
|
+
thinking: string;
|
|
16486
|
+
thinkingSignature?: string;
|
|
16487
|
+
redacted?: boolean;
|
|
16487
16488
|
} | {
|
|
16488
16489
|
addedToolNames?: string[];
|
|
16489
16490
|
arguments: Record<string, any>;
|
|
16490
16491
|
callID: string;
|
|
16491
16492
|
name: string;
|
|
16492
16493
|
namespace?: string;
|
|
16493
|
-
|
|
16494
|
-
content
|
|
16494
|
+
partial?: {
|
|
16495
|
+
content?: ({
|
|
16495
16496
|
type: "text";
|
|
16496
16497
|
text: string;
|
|
16497
16498
|
textSignature?: string;
|
|
@@ -16501,9 +16502,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16501
16502
|
mimeType: string;
|
|
16502
16503
|
})[];
|
|
16503
16504
|
details?: any;
|
|
16504
|
-
isError: true;
|
|
16505
16505
|
};
|
|
16506
|
-
status: "
|
|
16506
|
+
status: "running";
|
|
16507
16507
|
thoughtSignature?: string;
|
|
16508
16508
|
time: {
|
|
16509
16509
|
start: number;
|
|
@@ -16678,19 +16678,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16678
16678
|
type: "image";
|
|
16679
16679
|
data: string;
|
|
16680
16680
|
mimeType: string;
|
|
16681
|
-
} | {
|
|
16682
|
-
type: "thinking";
|
|
16683
|
-
thinking: string;
|
|
16684
|
-
thinkingSignature?: string;
|
|
16685
|
-
redacted?: boolean;
|
|
16686
16681
|
} | {
|
|
16687
16682
|
addedToolNames?: string[];
|
|
16688
16683
|
arguments: Record<string, any>;
|
|
16689
16684
|
callID: string;
|
|
16690
16685
|
name: string;
|
|
16691
16686
|
namespace?: string;
|
|
16692
|
-
|
|
16693
|
-
content
|
|
16687
|
+
result: {
|
|
16688
|
+
content: ({
|
|
16694
16689
|
type: "text";
|
|
16695
16690
|
text: string;
|
|
16696
16691
|
textSignature?: string;
|
|
@@ -16700,8 +16695,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16700
16695
|
mimeType: string;
|
|
16701
16696
|
})[];
|
|
16702
16697
|
details?: any;
|
|
16698
|
+
isError: false;
|
|
16703
16699
|
};
|
|
16704
|
-
status: "
|
|
16700
|
+
status: "completed";
|
|
16705
16701
|
thoughtSignature?: string;
|
|
16706
16702
|
time: {
|
|
16707
16703
|
start: number;
|
|
@@ -16725,9 +16721,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16725
16721
|
mimeType: string;
|
|
16726
16722
|
})[];
|
|
16727
16723
|
details?: any;
|
|
16728
|
-
isError:
|
|
16724
|
+
isError: true;
|
|
16729
16725
|
};
|
|
16730
|
-
status: "
|
|
16726
|
+
status: "error";
|
|
16731
16727
|
thoughtSignature?: string;
|
|
16732
16728
|
time: {
|
|
16733
16729
|
start: number;
|
|
@@ -16753,7 +16749,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16753
16749
|
details?: any;
|
|
16754
16750
|
isError: true;
|
|
16755
16751
|
};
|
|
16756
|
-
status: "
|
|
16752
|
+
status: "skipped";
|
|
16757
16753
|
thoughtSignature?: string;
|
|
16758
16754
|
time: {
|
|
16759
16755
|
start: number;
|
|
@@ -16779,21 +16775,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16779
16775
|
details?: any;
|
|
16780
16776
|
isError: true;
|
|
16781
16777
|
};
|
|
16782
|
-
status: "
|
|
16778
|
+
status: "aborted";
|
|
16783
16779
|
thoughtSignature?: string;
|
|
16784
16780
|
time: {
|
|
16785
16781
|
start: number;
|
|
16786
16782
|
end: number;
|
|
16787
16783
|
};
|
|
16788
16784
|
type: "toolCall";
|
|
16785
|
+
} | {
|
|
16786
|
+
type: "thinking";
|
|
16787
|
+
thinking: string;
|
|
16788
|
+
thinkingSignature?: string;
|
|
16789
|
+
redacted?: boolean;
|
|
16789
16790
|
} | {
|
|
16790
16791
|
addedToolNames?: string[];
|
|
16791
16792
|
arguments: Record<string, any>;
|
|
16792
16793
|
callID: string;
|
|
16793
16794
|
name: string;
|
|
16794
16795
|
namespace?: string;
|
|
16795
|
-
|
|
16796
|
-
content
|
|
16796
|
+
partial?: {
|
|
16797
|
+
content?: ({
|
|
16797
16798
|
type: "text";
|
|
16798
16799
|
text: string;
|
|
16799
16800
|
textSignature?: string;
|
|
@@ -16803,9 +16804,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16803
16804
|
mimeType: string;
|
|
16804
16805
|
})[];
|
|
16805
16806
|
details?: any;
|
|
16806
|
-
isError: true;
|
|
16807
16807
|
};
|
|
16808
|
-
status: "
|
|
16808
|
+
status: "running";
|
|
16809
16809
|
thoughtSignature?: string;
|
|
16810
16810
|
time: {
|
|
16811
16811
|
start: number;
|
|
@@ -17286,19 +17286,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17286
17286
|
type: "image";
|
|
17287
17287
|
data: string;
|
|
17288
17288
|
mimeType: string;
|
|
17289
|
-
} | {
|
|
17290
|
-
type: "thinking";
|
|
17291
|
-
thinking: string;
|
|
17292
|
-
thinkingSignature?: string;
|
|
17293
|
-
redacted?: boolean;
|
|
17294
17289
|
} | {
|
|
17295
17290
|
addedToolNames?: string[];
|
|
17296
17291
|
arguments: Record<string, any>;
|
|
17297
17292
|
callID: string;
|
|
17298
17293
|
name: string;
|
|
17299
17294
|
namespace?: string;
|
|
17300
|
-
|
|
17301
|
-
content
|
|
17295
|
+
result: {
|
|
17296
|
+
content: ({
|
|
17302
17297
|
type: "text";
|
|
17303
17298
|
text: string;
|
|
17304
17299
|
textSignature?: string;
|
|
@@ -17308,8 +17303,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17308
17303
|
mimeType: string;
|
|
17309
17304
|
})[];
|
|
17310
17305
|
details?: any;
|
|
17306
|
+
isError: false;
|
|
17311
17307
|
};
|
|
17312
|
-
status: "
|
|
17308
|
+
status: "completed";
|
|
17313
17309
|
thoughtSignature?: string;
|
|
17314
17310
|
time: {
|
|
17315
17311
|
start: number;
|
|
@@ -17333,9 +17329,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17333
17329
|
mimeType: string;
|
|
17334
17330
|
})[];
|
|
17335
17331
|
details?: any;
|
|
17336
|
-
isError:
|
|
17332
|
+
isError: true;
|
|
17337
17333
|
};
|
|
17338
|
-
status: "
|
|
17334
|
+
status: "error";
|
|
17339
17335
|
thoughtSignature?: string;
|
|
17340
17336
|
time: {
|
|
17341
17337
|
start: number;
|
|
@@ -17361,7 +17357,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17361
17357
|
details?: any;
|
|
17362
17358
|
isError: true;
|
|
17363
17359
|
};
|
|
17364
|
-
status: "
|
|
17360
|
+
status: "skipped";
|
|
17365
17361
|
thoughtSignature?: string;
|
|
17366
17362
|
time: {
|
|
17367
17363
|
start: number;
|
|
@@ -17387,21 +17383,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17387
17383
|
details?: any;
|
|
17388
17384
|
isError: true;
|
|
17389
17385
|
};
|
|
17390
|
-
status: "
|
|
17386
|
+
status: "aborted";
|
|
17391
17387
|
thoughtSignature?: string;
|
|
17392
17388
|
time: {
|
|
17393
17389
|
start: number;
|
|
17394
17390
|
end: number;
|
|
17395
17391
|
};
|
|
17396
17392
|
type: "toolCall";
|
|
17393
|
+
} | {
|
|
17394
|
+
type: "thinking";
|
|
17395
|
+
thinking: string;
|
|
17396
|
+
thinkingSignature?: string;
|
|
17397
|
+
redacted?: boolean;
|
|
17397
17398
|
} | {
|
|
17398
17399
|
addedToolNames?: string[];
|
|
17399
17400
|
arguments: Record<string, any>;
|
|
17400
17401
|
callID: string;
|
|
17401
17402
|
name: string;
|
|
17402
17403
|
namespace?: string;
|
|
17403
|
-
|
|
17404
|
-
content
|
|
17404
|
+
partial?: {
|
|
17405
|
+
content?: ({
|
|
17405
17406
|
type: "text";
|
|
17406
17407
|
text: string;
|
|
17407
17408
|
textSignature?: string;
|
|
@@ -17411,9 +17412,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17411
17412
|
mimeType: string;
|
|
17412
17413
|
})[];
|
|
17413
17414
|
details?: any;
|
|
17414
|
-
isError: true;
|
|
17415
17415
|
};
|
|
17416
|
-
status: "
|
|
17416
|
+
status: "running";
|
|
17417
17417
|
thoughtSignature?: string;
|
|
17418
17418
|
time: {
|
|
17419
17419
|
start: number;
|
|
@@ -17588,19 +17588,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17588
17588
|
type: "image";
|
|
17589
17589
|
data: string;
|
|
17590
17590
|
mimeType: string;
|
|
17591
|
-
} | {
|
|
17592
|
-
type: "thinking";
|
|
17593
|
-
thinking: string;
|
|
17594
|
-
thinkingSignature?: string;
|
|
17595
|
-
redacted?: boolean;
|
|
17596
17591
|
} | {
|
|
17597
17592
|
addedToolNames?: string[];
|
|
17598
17593
|
arguments: Record<string, any>;
|
|
17599
17594
|
callID: string;
|
|
17600
17595
|
name: string;
|
|
17601
17596
|
namespace?: string;
|
|
17602
|
-
|
|
17603
|
-
content
|
|
17597
|
+
result: {
|
|
17598
|
+
content: ({
|
|
17604
17599
|
type: "text";
|
|
17605
17600
|
text: string;
|
|
17606
17601
|
textSignature?: string;
|
|
@@ -17610,8 +17605,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17610
17605
|
mimeType: string;
|
|
17611
17606
|
})[];
|
|
17612
17607
|
details?: any;
|
|
17608
|
+
isError: false;
|
|
17613
17609
|
};
|
|
17614
|
-
status: "
|
|
17610
|
+
status: "completed";
|
|
17615
17611
|
thoughtSignature?: string;
|
|
17616
17612
|
time: {
|
|
17617
17613
|
start: number;
|
|
@@ -17635,9 +17631,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17635
17631
|
mimeType: string;
|
|
17636
17632
|
})[];
|
|
17637
17633
|
details?: any;
|
|
17638
|
-
isError:
|
|
17634
|
+
isError: true;
|
|
17639
17635
|
};
|
|
17640
|
-
status: "
|
|
17636
|
+
status: "error";
|
|
17641
17637
|
thoughtSignature?: string;
|
|
17642
17638
|
time: {
|
|
17643
17639
|
start: number;
|
|
@@ -17663,7 +17659,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17663
17659
|
details?: any;
|
|
17664
17660
|
isError: true;
|
|
17665
17661
|
};
|
|
17666
|
-
status: "
|
|
17662
|
+
status: "skipped";
|
|
17667
17663
|
thoughtSignature?: string;
|
|
17668
17664
|
time: {
|
|
17669
17665
|
start: number;
|
|
@@ -17689,21 +17685,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17689
17685
|
details?: any;
|
|
17690
17686
|
isError: true;
|
|
17691
17687
|
};
|
|
17692
|
-
status: "
|
|
17688
|
+
status: "aborted";
|
|
17693
17689
|
thoughtSignature?: string;
|
|
17694
17690
|
time: {
|
|
17695
17691
|
start: number;
|
|
17696
17692
|
end: number;
|
|
17697
17693
|
};
|
|
17698
17694
|
type: "toolCall";
|
|
17695
|
+
} | {
|
|
17696
|
+
type: "thinking";
|
|
17697
|
+
thinking: string;
|
|
17698
|
+
thinkingSignature?: string;
|
|
17699
|
+
redacted?: boolean;
|
|
17699
17700
|
} | {
|
|
17700
17701
|
addedToolNames?: string[];
|
|
17701
17702
|
arguments: Record<string, any>;
|
|
17702
17703
|
callID: string;
|
|
17703
17704
|
name: string;
|
|
17704
17705
|
namespace?: string;
|
|
17705
|
-
|
|
17706
|
-
content
|
|
17706
|
+
partial?: {
|
|
17707
|
+
content?: ({
|
|
17707
17708
|
type: "text";
|
|
17708
17709
|
text: string;
|
|
17709
17710
|
textSignature?: string;
|
|
@@ -17713,9 +17714,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17713
17714
|
mimeType: string;
|
|
17714
17715
|
})[];
|
|
17715
17716
|
details?: any;
|
|
17716
|
-
isError: true;
|
|
17717
17717
|
};
|
|
17718
|
-
status: "
|
|
17718
|
+
status: "running";
|
|
17719
17719
|
thoughtSignature?: string;
|
|
17720
17720
|
time: {
|
|
17721
17721
|
start: number;
|
|
@@ -17909,19 +17909,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17909
17909
|
type: "image";
|
|
17910
17910
|
data: string;
|
|
17911
17911
|
mimeType: string;
|
|
17912
|
-
} | {
|
|
17913
|
-
type: "thinking";
|
|
17914
|
-
thinking: string;
|
|
17915
|
-
thinkingSignature?: string;
|
|
17916
|
-
redacted?: boolean;
|
|
17917
17912
|
} | {
|
|
17918
17913
|
addedToolNames?: string[];
|
|
17919
17914
|
arguments: Record<string, any>;
|
|
17920
17915
|
callID: string;
|
|
17921
17916
|
name: string;
|
|
17922
17917
|
namespace?: string;
|
|
17923
|
-
|
|
17924
|
-
content
|
|
17918
|
+
result: {
|
|
17919
|
+
content: ({
|
|
17925
17920
|
type: "text";
|
|
17926
17921
|
text: string;
|
|
17927
17922
|
textSignature?: string;
|
|
@@ -17931,8 +17926,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17931
17926
|
mimeType: string;
|
|
17932
17927
|
})[];
|
|
17933
17928
|
details?: any;
|
|
17929
|
+
isError: false;
|
|
17934
17930
|
};
|
|
17935
|
-
status: "
|
|
17931
|
+
status: "completed";
|
|
17936
17932
|
thoughtSignature?: string;
|
|
17937
17933
|
time: {
|
|
17938
17934
|
start: number;
|
|
@@ -17956,9 +17952,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17956
17952
|
mimeType: string;
|
|
17957
17953
|
})[];
|
|
17958
17954
|
details?: any;
|
|
17959
|
-
isError:
|
|
17955
|
+
isError: true;
|
|
17960
17956
|
};
|
|
17961
|
-
status: "
|
|
17957
|
+
status: "error";
|
|
17962
17958
|
thoughtSignature?: string;
|
|
17963
17959
|
time: {
|
|
17964
17960
|
start: number;
|
|
@@ -17984,7 +17980,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17984
17980
|
details?: any;
|
|
17985
17981
|
isError: true;
|
|
17986
17982
|
};
|
|
17987
|
-
status: "
|
|
17983
|
+
status: "skipped";
|
|
17988
17984
|
thoughtSignature?: string;
|
|
17989
17985
|
time: {
|
|
17990
17986
|
start: number;
|
|
@@ -18010,21 +18006,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18010
18006
|
details?: any;
|
|
18011
18007
|
isError: true;
|
|
18012
18008
|
};
|
|
18013
|
-
status: "
|
|
18009
|
+
status: "aborted";
|
|
18014
18010
|
thoughtSignature?: string;
|
|
18015
18011
|
time: {
|
|
18016
18012
|
start: number;
|
|
18017
18013
|
end: number;
|
|
18018
18014
|
};
|
|
18019
18015
|
type: "toolCall";
|
|
18016
|
+
} | {
|
|
18017
|
+
type: "thinking";
|
|
18018
|
+
thinking: string;
|
|
18019
|
+
thinkingSignature?: string;
|
|
18020
|
+
redacted?: boolean;
|
|
18020
18021
|
} | {
|
|
18021
18022
|
addedToolNames?: string[];
|
|
18022
18023
|
arguments: Record<string, any>;
|
|
18023
18024
|
callID: string;
|
|
18024
18025
|
name: string;
|
|
18025
18026
|
namespace?: string;
|
|
18026
|
-
|
|
18027
|
-
content
|
|
18027
|
+
partial?: {
|
|
18028
|
+
content?: ({
|
|
18028
18029
|
type: "text";
|
|
18029
18030
|
text: string;
|
|
18030
18031
|
textSignature?: string;
|
|
@@ -18034,9 +18035,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18034
18035
|
mimeType: string;
|
|
18035
18036
|
})[];
|
|
18036
18037
|
details?: any;
|
|
18037
|
-
isError: true;
|
|
18038
18038
|
};
|
|
18039
|
-
status: "
|
|
18039
|
+
status: "running";
|
|
18040
18040
|
thoughtSignature?: string;
|
|
18041
18041
|
time: {
|
|
18042
18042
|
start: number;
|
|
@@ -18211,19 +18211,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18211
18211
|
type: "image";
|
|
18212
18212
|
data: string;
|
|
18213
18213
|
mimeType: string;
|
|
18214
|
-
} | {
|
|
18215
|
-
type: "thinking";
|
|
18216
|
-
thinking: string;
|
|
18217
|
-
thinkingSignature?: string;
|
|
18218
|
-
redacted?: boolean;
|
|
18219
18214
|
} | {
|
|
18220
18215
|
addedToolNames?: string[];
|
|
18221
18216
|
arguments: Record<string, any>;
|
|
18222
18217
|
callID: string;
|
|
18223
18218
|
name: string;
|
|
18224
18219
|
namespace?: string;
|
|
18225
|
-
|
|
18226
|
-
content
|
|
18220
|
+
result: {
|
|
18221
|
+
content: ({
|
|
18227
18222
|
type: "text";
|
|
18228
18223
|
text: string;
|
|
18229
18224
|
textSignature?: string;
|
|
@@ -18233,8 +18228,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18233
18228
|
mimeType: string;
|
|
18234
18229
|
})[];
|
|
18235
18230
|
details?: any;
|
|
18231
|
+
isError: false;
|
|
18236
18232
|
};
|
|
18237
|
-
status: "
|
|
18233
|
+
status: "completed";
|
|
18238
18234
|
thoughtSignature?: string;
|
|
18239
18235
|
time: {
|
|
18240
18236
|
start: number;
|
|
@@ -18258,9 +18254,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18258
18254
|
mimeType: string;
|
|
18259
18255
|
})[];
|
|
18260
18256
|
details?: any;
|
|
18261
|
-
isError:
|
|
18257
|
+
isError: true;
|
|
18262
18258
|
};
|
|
18263
|
-
status: "
|
|
18259
|
+
status: "error";
|
|
18264
18260
|
thoughtSignature?: string;
|
|
18265
18261
|
time: {
|
|
18266
18262
|
start: number;
|
|
@@ -18286,7 +18282,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18286
18282
|
details?: any;
|
|
18287
18283
|
isError: true;
|
|
18288
18284
|
};
|
|
18289
|
-
status: "
|
|
18285
|
+
status: "skipped";
|
|
18290
18286
|
thoughtSignature?: string;
|
|
18291
18287
|
time: {
|
|
18292
18288
|
start: number;
|
|
@@ -18312,21 +18308,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18312
18308
|
details?: any;
|
|
18313
18309
|
isError: true;
|
|
18314
18310
|
};
|
|
18315
|
-
status: "
|
|
18311
|
+
status: "aborted";
|
|
18316
18312
|
thoughtSignature?: string;
|
|
18317
18313
|
time: {
|
|
18318
18314
|
start: number;
|
|
18319
18315
|
end: number;
|
|
18320
18316
|
};
|
|
18321
18317
|
type: "toolCall";
|
|
18318
|
+
} | {
|
|
18319
|
+
type: "thinking";
|
|
18320
|
+
thinking: string;
|
|
18321
|
+
thinkingSignature?: string;
|
|
18322
|
+
redacted?: boolean;
|
|
18322
18323
|
} | {
|
|
18323
18324
|
addedToolNames?: string[];
|
|
18324
18325
|
arguments: Record<string, any>;
|
|
18325
18326
|
callID: string;
|
|
18326
18327
|
name: string;
|
|
18327
18328
|
namespace?: string;
|
|
18328
|
-
|
|
18329
|
-
content
|
|
18329
|
+
partial?: {
|
|
18330
|
+
content?: ({
|
|
18330
18331
|
type: "text";
|
|
18331
18332
|
text: string;
|
|
18332
18333
|
textSignature?: string;
|
|
@@ -18336,9 +18337,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18336
18337
|
mimeType: string;
|
|
18337
18338
|
})[];
|
|
18338
18339
|
details?: any;
|
|
18339
|
-
isError: true;
|
|
18340
18340
|
};
|
|
18341
|
-
status: "
|
|
18341
|
+
status: "running";
|
|
18342
18342
|
thoughtSignature?: string;
|
|
18343
18343
|
time: {
|
|
18344
18344
|
start: number;
|
|
@@ -18541,19 +18541,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18541
18541
|
type: "image";
|
|
18542
18542
|
data: string;
|
|
18543
18543
|
mimeType: string;
|
|
18544
|
-
} | {
|
|
18545
|
-
type: "thinking";
|
|
18546
|
-
thinking: string;
|
|
18547
|
-
thinkingSignature?: string;
|
|
18548
|
-
redacted?: boolean;
|
|
18549
18544
|
} | {
|
|
18550
18545
|
addedToolNames?: string[];
|
|
18551
18546
|
arguments: Record<string, any>;
|
|
18552
18547
|
callID: string;
|
|
18553
18548
|
name: string;
|
|
18554
18549
|
namespace?: string;
|
|
18555
|
-
|
|
18556
|
-
content
|
|
18550
|
+
result: {
|
|
18551
|
+
content: ({
|
|
18557
18552
|
type: "text";
|
|
18558
18553
|
text: string;
|
|
18559
18554
|
textSignature?: string;
|
|
@@ -18563,8 +18558,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18563
18558
|
mimeType: string;
|
|
18564
18559
|
})[];
|
|
18565
18560
|
details?: any;
|
|
18561
|
+
isError: false;
|
|
18566
18562
|
};
|
|
18567
|
-
status: "
|
|
18563
|
+
status: "completed";
|
|
18568
18564
|
thoughtSignature?: string;
|
|
18569
18565
|
time: {
|
|
18570
18566
|
start: number;
|
|
@@ -18588,9 +18584,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18588
18584
|
mimeType: string;
|
|
18589
18585
|
})[];
|
|
18590
18586
|
details?: any;
|
|
18591
|
-
isError:
|
|
18587
|
+
isError: true;
|
|
18592
18588
|
};
|
|
18593
|
-
status: "
|
|
18589
|
+
status: "error";
|
|
18594
18590
|
thoughtSignature?: string;
|
|
18595
18591
|
time: {
|
|
18596
18592
|
start: number;
|
|
@@ -18616,7 +18612,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18616
18612
|
details?: any;
|
|
18617
18613
|
isError: true;
|
|
18618
18614
|
};
|
|
18619
|
-
status: "
|
|
18615
|
+
status: "skipped";
|
|
18620
18616
|
thoughtSignature?: string;
|
|
18621
18617
|
time: {
|
|
18622
18618
|
start: number;
|
|
@@ -18642,21 +18638,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18642
18638
|
details?: any;
|
|
18643
18639
|
isError: true;
|
|
18644
18640
|
};
|
|
18645
|
-
status: "
|
|
18641
|
+
status: "aborted";
|
|
18646
18642
|
thoughtSignature?: string;
|
|
18647
18643
|
time: {
|
|
18648
18644
|
start: number;
|
|
18649
18645
|
end: number;
|
|
18650
18646
|
};
|
|
18651
18647
|
type: "toolCall";
|
|
18648
|
+
} | {
|
|
18649
|
+
type: "thinking";
|
|
18650
|
+
thinking: string;
|
|
18651
|
+
thinkingSignature?: string;
|
|
18652
|
+
redacted?: boolean;
|
|
18652
18653
|
} | {
|
|
18653
18654
|
addedToolNames?: string[];
|
|
18654
18655
|
arguments: Record<string, any>;
|
|
18655
18656
|
callID: string;
|
|
18656
18657
|
name: string;
|
|
18657
18658
|
namespace?: string;
|
|
18658
|
-
|
|
18659
|
-
content
|
|
18659
|
+
partial?: {
|
|
18660
|
+
content?: ({
|
|
18660
18661
|
type: "text";
|
|
18661
18662
|
text: string;
|
|
18662
18663
|
textSignature?: string;
|
|
@@ -18666,9 +18667,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18666
18667
|
mimeType: string;
|
|
18667
18668
|
})[];
|
|
18668
18669
|
details?: any;
|
|
18669
|
-
isError: true;
|
|
18670
18670
|
};
|
|
18671
|
-
status: "
|
|
18671
|
+
status: "running";
|
|
18672
18672
|
thoughtSignature?: string;
|
|
18673
18673
|
time: {
|
|
18674
18674
|
start: number;
|
|
@@ -18843,19 +18843,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18843
18843
|
type: "image";
|
|
18844
18844
|
data: string;
|
|
18845
18845
|
mimeType: string;
|
|
18846
|
-
} | {
|
|
18847
|
-
type: "thinking";
|
|
18848
|
-
thinking: string;
|
|
18849
|
-
thinkingSignature?: string;
|
|
18850
|
-
redacted?: boolean;
|
|
18851
18846
|
} | {
|
|
18852
18847
|
addedToolNames?: string[];
|
|
18853
18848
|
arguments: Record<string, any>;
|
|
18854
18849
|
callID: string;
|
|
18855
18850
|
name: string;
|
|
18856
18851
|
namespace?: string;
|
|
18857
|
-
|
|
18858
|
-
content
|
|
18852
|
+
result: {
|
|
18853
|
+
content: ({
|
|
18859
18854
|
type: "text";
|
|
18860
18855
|
text: string;
|
|
18861
18856
|
textSignature?: string;
|
|
@@ -18865,8 +18860,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18865
18860
|
mimeType: string;
|
|
18866
18861
|
})[];
|
|
18867
18862
|
details?: any;
|
|
18863
|
+
isError: false;
|
|
18868
18864
|
};
|
|
18869
|
-
status: "
|
|
18865
|
+
status: "completed";
|
|
18870
18866
|
thoughtSignature?: string;
|
|
18871
18867
|
time: {
|
|
18872
18868
|
start: number;
|
|
@@ -18890,9 +18886,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18890
18886
|
mimeType: string;
|
|
18891
18887
|
})[];
|
|
18892
18888
|
details?: any;
|
|
18893
|
-
isError:
|
|
18889
|
+
isError: true;
|
|
18894
18890
|
};
|
|
18895
|
-
status: "
|
|
18891
|
+
status: "error";
|
|
18896
18892
|
thoughtSignature?: string;
|
|
18897
18893
|
time: {
|
|
18898
18894
|
start: number;
|
|
@@ -18918,7 +18914,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18918
18914
|
details?: any;
|
|
18919
18915
|
isError: true;
|
|
18920
18916
|
};
|
|
18921
|
-
status: "
|
|
18917
|
+
status: "skipped";
|
|
18922
18918
|
thoughtSignature?: string;
|
|
18923
18919
|
time: {
|
|
18924
18920
|
start: number;
|
|
@@ -18944,21 +18940,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18944
18940
|
details?: any;
|
|
18945
18941
|
isError: true;
|
|
18946
18942
|
};
|
|
18947
|
-
status: "
|
|
18943
|
+
status: "aborted";
|
|
18948
18944
|
thoughtSignature?: string;
|
|
18949
18945
|
time: {
|
|
18950
18946
|
start: number;
|
|
18951
18947
|
end: number;
|
|
18952
18948
|
};
|
|
18953
18949
|
type: "toolCall";
|
|
18950
|
+
} | {
|
|
18951
|
+
type: "thinking";
|
|
18952
|
+
thinking: string;
|
|
18953
|
+
thinkingSignature?: string;
|
|
18954
|
+
redacted?: boolean;
|
|
18954
18955
|
} | {
|
|
18955
18956
|
addedToolNames?: string[];
|
|
18956
18957
|
arguments: Record<string, any>;
|
|
18957
18958
|
callID: string;
|
|
18958
18959
|
name: string;
|
|
18959
18960
|
namespace?: string;
|
|
18960
|
-
|
|
18961
|
-
content
|
|
18961
|
+
partial?: {
|
|
18962
|
+
content?: ({
|
|
18962
18963
|
type: "text";
|
|
18963
18964
|
text: string;
|
|
18964
18965
|
textSignature?: string;
|
|
@@ -18968,9 +18969,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18968
18969
|
mimeType: string;
|
|
18969
18970
|
})[];
|
|
18970
18971
|
details?: any;
|
|
18971
|
-
isError: true;
|
|
18972
18972
|
};
|
|
18973
|
-
status: "
|
|
18973
|
+
status: "running";
|
|
18974
18974
|
thoughtSignature?: string;
|
|
18975
18975
|
time: {
|
|
18976
18976
|
start: number;
|
|
@@ -19164,19 +19164,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19164
19164
|
type: "image";
|
|
19165
19165
|
data: string;
|
|
19166
19166
|
mimeType: string;
|
|
19167
|
-
} | {
|
|
19168
|
-
type: "thinking";
|
|
19169
|
-
thinking: string;
|
|
19170
|
-
thinkingSignature?: string;
|
|
19171
|
-
redacted?: boolean;
|
|
19172
19167
|
} | {
|
|
19173
19168
|
addedToolNames?: string[];
|
|
19174
19169
|
arguments: Record<string, any>;
|
|
19175
19170
|
callID: string;
|
|
19176
19171
|
name: string;
|
|
19177
19172
|
namespace?: string;
|
|
19178
|
-
|
|
19179
|
-
content
|
|
19173
|
+
result: {
|
|
19174
|
+
content: ({
|
|
19180
19175
|
type: "text";
|
|
19181
19176
|
text: string;
|
|
19182
19177
|
textSignature?: string;
|
|
@@ -19186,8 +19181,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19186
19181
|
mimeType: string;
|
|
19187
19182
|
})[];
|
|
19188
19183
|
details?: any;
|
|
19184
|
+
isError: false;
|
|
19189
19185
|
};
|
|
19190
|
-
status: "
|
|
19186
|
+
status: "completed";
|
|
19191
19187
|
thoughtSignature?: string;
|
|
19192
19188
|
time: {
|
|
19193
19189
|
start: number;
|
|
@@ -19211,9 +19207,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19211
19207
|
mimeType: string;
|
|
19212
19208
|
})[];
|
|
19213
19209
|
details?: any;
|
|
19214
|
-
isError:
|
|
19210
|
+
isError: true;
|
|
19215
19211
|
};
|
|
19216
|
-
status: "
|
|
19212
|
+
status: "error";
|
|
19217
19213
|
thoughtSignature?: string;
|
|
19218
19214
|
time: {
|
|
19219
19215
|
start: number;
|
|
@@ -19239,7 +19235,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19239
19235
|
details?: any;
|
|
19240
19236
|
isError: true;
|
|
19241
19237
|
};
|
|
19242
|
-
status: "
|
|
19238
|
+
status: "skipped";
|
|
19243
19239
|
thoughtSignature?: string;
|
|
19244
19240
|
time: {
|
|
19245
19241
|
start: number;
|
|
@@ -19265,21 +19261,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19265
19261
|
details?: any;
|
|
19266
19262
|
isError: true;
|
|
19267
19263
|
};
|
|
19268
|
-
status: "
|
|
19264
|
+
status: "aborted";
|
|
19269
19265
|
thoughtSignature?: string;
|
|
19270
19266
|
time: {
|
|
19271
19267
|
start: number;
|
|
19272
19268
|
end: number;
|
|
19273
19269
|
};
|
|
19274
19270
|
type: "toolCall";
|
|
19271
|
+
} | {
|
|
19272
|
+
type: "thinking";
|
|
19273
|
+
thinking: string;
|
|
19274
|
+
thinkingSignature?: string;
|
|
19275
|
+
redacted?: boolean;
|
|
19275
19276
|
} | {
|
|
19276
19277
|
addedToolNames?: string[];
|
|
19277
19278
|
arguments: Record<string, any>;
|
|
19278
19279
|
callID: string;
|
|
19279
19280
|
name: string;
|
|
19280
19281
|
namespace?: string;
|
|
19281
|
-
|
|
19282
|
-
content
|
|
19282
|
+
partial?: {
|
|
19283
|
+
content?: ({
|
|
19283
19284
|
type: "text";
|
|
19284
19285
|
text: string;
|
|
19285
19286
|
textSignature?: string;
|
|
@@ -19289,9 +19290,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19289
19290
|
mimeType: string;
|
|
19290
19291
|
})[];
|
|
19291
19292
|
details?: any;
|
|
19292
|
-
isError: true;
|
|
19293
19293
|
};
|
|
19294
|
-
status: "
|
|
19294
|
+
status: "running";
|
|
19295
19295
|
thoughtSignature?: string;
|
|
19296
19296
|
time: {
|
|
19297
19297
|
start: number;
|
|
@@ -19466,19 +19466,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19466
19466
|
type: "image";
|
|
19467
19467
|
data: string;
|
|
19468
19468
|
mimeType: string;
|
|
19469
|
-
} | {
|
|
19470
|
-
type: "thinking";
|
|
19471
|
-
thinking: string;
|
|
19472
|
-
thinkingSignature?: string;
|
|
19473
|
-
redacted?: boolean;
|
|
19474
19469
|
} | {
|
|
19475
19470
|
addedToolNames?: string[];
|
|
19476
19471
|
arguments: Record<string, any>;
|
|
19477
19472
|
callID: string;
|
|
19478
19473
|
name: string;
|
|
19479
19474
|
namespace?: string;
|
|
19480
|
-
|
|
19481
|
-
content
|
|
19475
|
+
result: {
|
|
19476
|
+
content: ({
|
|
19482
19477
|
type: "text";
|
|
19483
19478
|
text: string;
|
|
19484
19479
|
textSignature?: string;
|
|
@@ -19488,8 +19483,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19488
19483
|
mimeType: string;
|
|
19489
19484
|
})[];
|
|
19490
19485
|
details?: any;
|
|
19486
|
+
isError: false;
|
|
19491
19487
|
};
|
|
19492
|
-
status: "
|
|
19488
|
+
status: "completed";
|
|
19493
19489
|
thoughtSignature?: string;
|
|
19494
19490
|
time: {
|
|
19495
19491
|
start: number;
|
|
@@ -19513,9 +19509,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19513
19509
|
mimeType: string;
|
|
19514
19510
|
})[];
|
|
19515
19511
|
details?: any;
|
|
19516
|
-
isError:
|
|
19512
|
+
isError: true;
|
|
19517
19513
|
};
|
|
19518
|
-
status: "
|
|
19514
|
+
status: "error";
|
|
19519
19515
|
thoughtSignature?: string;
|
|
19520
19516
|
time: {
|
|
19521
19517
|
start: number;
|
|
@@ -19541,7 +19537,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19541
19537
|
details?: any;
|
|
19542
19538
|
isError: true;
|
|
19543
19539
|
};
|
|
19544
|
-
status: "
|
|
19540
|
+
status: "skipped";
|
|
19545
19541
|
thoughtSignature?: string;
|
|
19546
19542
|
time: {
|
|
19547
19543
|
start: number;
|
|
@@ -19567,21 +19563,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19567
19563
|
details?: any;
|
|
19568
19564
|
isError: true;
|
|
19569
19565
|
};
|
|
19570
|
-
status: "
|
|
19566
|
+
status: "aborted";
|
|
19571
19567
|
thoughtSignature?: string;
|
|
19572
19568
|
time: {
|
|
19573
19569
|
start: number;
|
|
19574
19570
|
end: number;
|
|
19575
19571
|
};
|
|
19576
19572
|
type: "toolCall";
|
|
19573
|
+
} | {
|
|
19574
|
+
type: "thinking";
|
|
19575
|
+
thinking: string;
|
|
19576
|
+
thinkingSignature?: string;
|
|
19577
|
+
redacted?: boolean;
|
|
19577
19578
|
} | {
|
|
19578
19579
|
addedToolNames?: string[];
|
|
19579
19580
|
arguments: Record<string, any>;
|
|
19580
19581
|
callID: string;
|
|
19581
19582
|
name: string;
|
|
19582
19583
|
namespace?: string;
|
|
19583
|
-
|
|
19584
|
-
content
|
|
19584
|
+
partial?: {
|
|
19585
|
+
content?: ({
|
|
19585
19586
|
type: "text";
|
|
19586
19587
|
text: string;
|
|
19587
19588
|
textSignature?: string;
|
|
@@ -19591,9 +19592,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19591
19592
|
mimeType: string;
|
|
19592
19593
|
})[];
|
|
19593
19594
|
details?: any;
|
|
19594
|
-
isError: true;
|
|
19595
19595
|
};
|
|
19596
|
-
status: "
|
|
19596
|
+
status: "running";
|
|
19597
19597
|
thoughtSignature?: string;
|
|
19598
19598
|
time: {
|
|
19599
19599
|
start: number;
|
|
@@ -20781,19 +20781,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20781
20781
|
type: "image";
|
|
20782
20782
|
data: string;
|
|
20783
20783
|
mimeType: string;
|
|
20784
|
-
} | {
|
|
20785
|
-
type: "thinking";
|
|
20786
|
-
thinking: string;
|
|
20787
|
-
thinkingSignature?: string;
|
|
20788
|
-
redacted?: boolean;
|
|
20789
20784
|
} | {
|
|
20790
20785
|
addedToolNames?: string[];
|
|
20791
20786
|
arguments: Record<string, any>;
|
|
20792
20787
|
callID: string;
|
|
20793
20788
|
name: string;
|
|
20794
20789
|
namespace?: string;
|
|
20795
|
-
|
|
20796
|
-
content
|
|
20790
|
+
result: {
|
|
20791
|
+
content: ({
|
|
20797
20792
|
type: "text";
|
|
20798
20793
|
text: string;
|
|
20799
20794
|
textSignature?: string;
|
|
@@ -20803,8 +20798,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20803
20798
|
mimeType: string;
|
|
20804
20799
|
})[];
|
|
20805
20800
|
details?: any;
|
|
20801
|
+
isError: false;
|
|
20806
20802
|
};
|
|
20807
|
-
status: "
|
|
20803
|
+
status: "completed";
|
|
20808
20804
|
thoughtSignature?: string;
|
|
20809
20805
|
time: {
|
|
20810
20806
|
start: number;
|
|
@@ -20828,9 +20824,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20828
20824
|
mimeType: string;
|
|
20829
20825
|
})[];
|
|
20830
20826
|
details?: any;
|
|
20831
|
-
isError:
|
|
20827
|
+
isError: true;
|
|
20832
20828
|
};
|
|
20833
|
-
status: "
|
|
20829
|
+
status: "error";
|
|
20834
20830
|
thoughtSignature?: string;
|
|
20835
20831
|
time: {
|
|
20836
20832
|
start: number;
|
|
@@ -20856,7 +20852,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20856
20852
|
details?: any;
|
|
20857
20853
|
isError: true;
|
|
20858
20854
|
};
|
|
20859
|
-
status: "
|
|
20855
|
+
status: "skipped";
|
|
20860
20856
|
thoughtSignature?: string;
|
|
20861
20857
|
time: {
|
|
20862
20858
|
start: number;
|
|
@@ -20882,21 +20878,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20882
20878
|
details?: any;
|
|
20883
20879
|
isError: true;
|
|
20884
20880
|
};
|
|
20885
|
-
status: "
|
|
20881
|
+
status: "aborted";
|
|
20886
20882
|
thoughtSignature?: string;
|
|
20887
20883
|
time: {
|
|
20888
20884
|
start: number;
|
|
20889
20885
|
end: number;
|
|
20890
20886
|
};
|
|
20891
20887
|
type: "toolCall";
|
|
20888
|
+
} | {
|
|
20889
|
+
type: "thinking";
|
|
20890
|
+
thinking: string;
|
|
20891
|
+
thinkingSignature?: string;
|
|
20892
|
+
redacted?: boolean;
|
|
20892
20893
|
} | {
|
|
20893
20894
|
addedToolNames?: string[];
|
|
20894
20895
|
arguments: Record<string, any>;
|
|
20895
20896
|
callID: string;
|
|
20896
20897
|
name: string;
|
|
20897
20898
|
namespace?: string;
|
|
20898
|
-
|
|
20899
|
-
content
|
|
20899
|
+
partial?: {
|
|
20900
|
+
content?: ({
|
|
20900
20901
|
type: "text";
|
|
20901
20902
|
text: string;
|
|
20902
20903
|
textSignature?: string;
|
|
@@ -20906,9 +20907,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20906
20907
|
mimeType: string;
|
|
20907
20908
|
})[];
|
|
20908
20909
|
details?: any;
|
|
20909
|
-
isError: true;
|
|
20910
20910
|
};
|
|
20911
|
-
status: "
|
|
20911
|
+
status: "running";
|
|
20912
20912
|
thoughtSignature?: string;
|
|
20913
20913
|
time: {
|
|
20914
20914
|
start: number;
|
|
@@ -21083,19 +21083,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21083
21083
|
type: "image";
|
|
21084
21084
|
data: string;
|
|
21085
21085
|
mimeType: string;
|
|
21086
|
-
} | {
|
|
21087
|
-
type: "thinking";
|
|
21088
|
-
thinking: string;
|
|
21089
|
-
thinkingSignature?: string;
|
|
21090
|
-
redacted?: boolean;
|
|
21091
21086
|
} | {
|
|
21092
21087
|
addedToolNames?: string[];
|
|
21093
21088
|
arguments: Record<string, any>;
|
|
21094
21089
|
callID: string;
|
|
21095
21090
|
name: string;
|
|
21096
21091
|
namespace?: string;
|
|
21097
|
-
|
|
21098
|
-
content
|
|
21092
|
+
result: {
|
|
21093
|
+
content: ({
|
|
21099
21094
|
type: "text";
|
|
21100
21095
|
text: string;
|
|
21101
21096
|
textSignature?: string;
|
|
@@ -21105,8 +21100,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21105
21100
|
mimeType: string;
|
|
21106
21101
|
})[];
|
|
21107
21102
|
details?: any;
|
|
21103
|
+
isError: false;
|
|
21108
21104
|
};
|
|
21109
|
-
status: "
|
|
21105
|
+
status: "completed";
|
|
21110
21106
|
thoughtSignature?: string;
|
|
21111
21107
|
time: {
|
|
21112
21108
|
start: number;
|
|
@@ -21130,9 +21126,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21130
21126
|
mimeType: string;
|
|
21131
21127
|
})[];
|
|
21132
21128
|
details?: any;
|
|
21133
|
-
isError:
|
|
21129
|
+
isError: true;
|
|
21134
21130
|
};
|
|
21135
|
-
status: "
|
|
21131
|
+
status: "error";
|
|
21136
21132
|
thoughtSignature?: string;
|
|
21137
21133
|
time: {
|
|
21138
21134
|
start: number;
|
|
@@ -21158,7 +21154,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21158
21154
|
details?: any;
|
|
21159
21155
|
isError: true;
|
|
21160
21156
|
};
|
|
21161
|
-
status: "
|
|
21157
|
+
status: "skipped";
|
|
21162
21158
|
thoughtSignature?: string;
|
|
21163
21159
|
time: {
|
|
21164
21160
|
start: number;
|
|
@@ -21184,21 +21180,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21184
21180
|
details?: any;
|
|
21185
21181
|
isError: true;
|
|
21186
21182
|
};
|
|
21187
|
-
status: "
|
|
21183
|
+
status: "aborted";
|
|
21188
21184
|
thoughtSignature?: string;
|
|
21189
21185
|
time: {
|
|
21190
21186
|
start: number;
|
|
21191
21187
|
end: number;
|
|
21192
21188
|
};
|
|
21193
21189
|
type: "toolCall";
|
|
21190
|
+
} | {
|
|
21191
|
+
type: "thinking";
|
|
21192
|
+
thinking: string;
|
|
21193
|
+
thinkingSignature?: string;
|
|
21194
|
+
redacted?: boolean;
|
|
21194
21195
|
} | {
|
|
21195
21196
|
addedToolNames?: string[];
|
|
21196
21197
|
arguments: Record<string, any>;
|
|
21197
21198
|
callID: string;
|
|
21198
21199
|
name: string;
|
|
21199
21200
|
namespace?: string;
|
|
21200
|
-
|
|
21201
|
-
content
|
|
21201
|
+
partial?: {
|
|
21202
|
+
content?: ({
|
|
21202
21203
|
type: "text";
|
|
21203
21204
|
text: string;
|
|
21204
21205
|
textSignature?: string;
|
|
@@ -21208,9 +21209,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21208
21209
|
mimeType: string;
|
|
21209
21210
|
})[];
|
|
21210
21211
|
details?: any;
|
|
21211
|
-
isError: true;
|
|
21212
21212
|
};
|
|
21213
|
-
status: "
|
|
21213
|
+
status: "running";
|
|
21214
21214
|
thoughtSignature?: string;
|
|
21215
21215
|
time: {
|
|
21216
21216
|
start: number;
|
|
@@ -21403,19 +21403,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21403
21403
|
type: "image";
|
|
21404
21404
|
data: string;
|
|
21405
21405
|
mimeType: string;
|
|
21406
|
-
} | {
|
|
21407
|
-
type: "thinking";
|
|
21408
|
-
thinking: string;
|
|
21409
|
-
thinkingSignature?: string;
|
|
21410
|
-
redacted?: boolean;
|
|
21411
21406
|
} | {
|
|
21412
21407
|
addedToolNames?: string[];
|
|
21413
21408
|
arguments: Record<string, any>;
|
|
21414
21409
|
callID: string;
|
|
21415
21410
|
name: string;
|
|
21416
21411
|
namespace?: string;
|
|
21417
|
-
|
|
21418
|
-
content
|
|
21412
|
+
result: {
|
|
21413
|
+
content: ({
|
|
21419
21414
|
type: "text";
|
|
21420
21415
|
text: string;
|
|
21421
21416
|
textSignature?: string;
|
|
@@ -21425,8 +21420,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21425
21420
|
mimeType: string;
|
|
21426
21421
|
})[];
|
|
21427
21422
|
details?: any;
|
|
21423
|
+
isError: false;
|
|
21428
21424
|
};
|
|
21429
|
-
status: "
|
|
21425
|
+
status: "completed";
|
|
21430
21426
|
thoughtSignature?: string;
|
|
21431
21427
|
time: {
|
|
21432
21428
|
start: number;
|
|
@@ -21450,9 +21446,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21450
21446
|
mimeType: string;
|
|
21451
21447
|
})[];
|
|
21452
21448
|
details?: any;
|
|
21453
|
-
isError:
|
|
21449
|
+
isError: true;
|
|
21454
21450
|
};
|
|
21455
|
-
status: "
|
|
21451
|
+
status: "error";
|
|
21456
21452
|
thoughtSignature?: string;
|
|
21457
21453
|
time: {
|
|
21458
21454
|
start: number;
|
|
@@ -21478,7 +21474,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21478
21474
|
details?: any;
|
|
21479
21475
|
isError: true;
|
|
21480
21476
|
};
|
|
21481
|
-
status: "
|
|
21477
|
+
status: "skipped";
|
|
21482
21478
|
thoughtSignature?: string;
|
|
21483
21479
|
time: {
|
|
21484
21480
|
start: number;
|
|
@@ -21504,21 +21500,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21504
21500
|
details?: any;
|
|
21505
21501
|
isError: true;
|
|
21506
21502
|
};
|
|
21507
|
-
status: "
|
|
21503
|
+
status: "aborted";
|
|
21508
21504
|
thoughtSignature?: string;
|
|
21509
21505
|
time: {
|
|
21510
21506
|
start: number;
|
|
21511
21507
|
end: number;
|
|
21512
21508
|
};
|
|
21513
21509
|
type: "toolCall";
|
|
21510
|
+
} | {
|
|
21511
|
+
type: "thinking";
|
|
21512
|
+
thinking: string;
|
|
21513
|
+
thinkingSignature?: string;
|
|
21514
|
+
redacted?: boolean;
|
|
21514
21515
|
} | {
|
|
21515
21516
|
addedToolNames?: string[];
|
|
21516
21517
|
arguments: Record<string, any>;
|
|
21517
21518
|
callID: string;
|
|
21518
21519
|
name: string;
|
|
21519
21520
|
namespace?: string;
|
|
21520
|
-
|
|
21521
|
-
content
|
|
21521
|
+
partial?: {
|
|
21522
|
+
content?: ({
|
|
21522
21523
|
type: "text";
|
|
21523
21524
|
text: string;
|
|
21524
21525
|
textSignature?: string;
|
|
@@ -21528,9 +21529,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21528
21529
|
mimeType: string;
|
|
21529
21530
|
})[];
|
|
21530
21531
|
details?: any;
|
|
21531
|
-
isError: true;
|
|
21532
21532
|
};
|
|
21533
|
-
status: "
|
|
21533
|
+
status: "running";
|
|
21534
21534
|
thoughtSignature?: string;
|
|
21535
21535
|
time: {
|
|
21536
21536
|
start: number;
|
|
@@ -21705,19 +21705,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21705
21705
|
type: "image";
|
|
21706
21706
|
data: string;
|
|
21707
21707
|
mimeType: string;
|
|
21708
|
-
} | {
|
|
21709
|
-
type: "thinking";
|
|
21710
|
-
thinking: string;
|
|
21711
|
-
thinkingSignature?: string;
|
|
21712
|
-
redacted?: boolean;
|
|
21713
21708
|
} | {
|
|
21714
21709
|
addedToolNames?: string[];
|
|
21715
21710
|
arguments: Record<string, any>;
|
|
21716
21711
|
callID: string;
|
|
21717
21712
|
name: string;
|
|
21718
21713
|
namespace?: string;
|
|
21719
|
-
|
|
21720
|
-
content
|
|
21714
|
+
result: {
|
|
21715
|
+
content: ({
|
|
21721
21716
|
type: "text";
|
|
21722
21717
|
text: string;
|
|
21723
21718
|
textSignature?: string;
|
|
@@ -21727,8 +21722,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21727
21722
|
mimeType: string;
|
|
21728
21723
|
})[];
|
|
21729
21724
|
details?: any;
|
|
21725
|
+
isError: false;
|
|
21730
21726
|
};
|
|
21731
|
-
status: "
|
|
21727
|
+
status: "completed";
|
|
21732
21728
|
thoughtSignature?: string;
|
|
21733
21729
|
time: {
|
|
21734
21730
|
start: number;
|
|
@@ -21752,9 +21748,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21752
21748
|
mimeType: string;
|
|
21753
21749
|
})[];
|
|
21754
21750
|
details?: any;
|
|
21755
|
-
isError:
|
|
21751
|
+
isError: true;
|
|
21756
21752
|
};
|
|
21757
|
-
status: "
|
|
21753
|
+
status: "error";
|
|
21758
21754
|
thoughtSignature?: string;
|
|
21759
21755
|
time: {
|
|
21760
21756
|
start: number;
|
|
@@ -21780,7 +21776,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21780
21776
|
details?: any;
|
|
21781
21777
|
isError: true;
|
|
21782
21778
|
};
|
|
21783
|
-
status: "
|
|
21779
|
+
status: "skipped";
|
|
21784
21780
|
thoughtSignature?: string;
|
|
21785
21781
|
time: {
|
|
21786
21782
|
start: number;
|
|
@@ -21806,21 +21802,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21806
21802
|
details?: any;
|
|
21807
21803
|
isError: true;
|
|
21808
21804
|
};
|
|
21809
|
-
status: "
|
|
21805
|
+
status: "aborted";
|
|
21810
21806
|
thoughtSignature?: string;
|
|
21811
21807
|
time: {
|
|
21812
21808
|
start: number;
|
|
21813
21809
|
end: number;
|
|
21814
21810
|
};
|
|
21815
21811
|
type: "toolCall";
|
|
21812
|
+
} | {
|
|
21813
|
+
type: "thinking";
|
|
21814
|
+
thinking: string;
|
|
21815
|
+
thinkingSignature?: string;
|
|
21816
|
+
redacted?: boolean;
|
|
21816
21817
|
} | {
|
|
21817
21818
|
addedToolNames?: string[];
|
|
21818
21819
|
arguments: Record<string, any>;
|
|
21819
21820
|
callID: string;
|
|
21820
21821
|
name: string;
|
|
21821
21822
|
namespace?: string;
|
|
21822
|
-
|
|
21823
|
-
content
|
|
21823
|
+
partial?: {
|
|
21824
|
+
content?: ({
|
|
21824
21825
|
type: "text";
|
|
21825
21826
|
text: string;
|
|
21826
21827
|
textSignature?: string;
|
|
@@ -21830,9 +21831,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21830
21831
|
mimeType: string;
|
|
21831
21832
|
})[];
|
|
21832
21833
|
details?: any;
|
|
21833
|
-
isError: true;
|
|
21834
21834
|
};
|
|
21835
|
-
status: "
|
|
21835
|
+
status: "running";
|
|
21836
21836
|
thoughtSignature?: string;
|
|
21837
21837
|
time: {
|
|
21838
21838
|
start: number;
|
|
@@ -22035,19 +22035,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22035
22035
|
type: "image";
|
|
22036
22036
|
data: string;
|
|
22037
22037
|
mimeType: string;
|
|
22038
|
-
} | {
|
|
22039
|
-
type: "thinking";
|
|
22040
|
-
thinking: string;
|
|
22041
|
-
thinkingSignature?: string;
|
|
22042
|
-
redacted?: boolean;
|
|
22043
22038
|
} | {
|
|
22044
22039
|
addedToolNames?: string[];
|
|
22045
22040
|
arguments: Record<string, any>;
|
|
22046
22041
|
callID: string;
|
|
22047
22042
|
name: string;
|
|
22048
22043
|
namespace?: string;
|
|
22049
|
-
|
|
22050
|
-
content
|
|
22044
|
+
result: {
|
|
22045
|
+
content: ({
|
|
22051
22046
|
type: "text";
|
|
22052
22047
|
text: string;
|
|
22053
22048
|
textSignature?: string;
|
|
@@ -22057,8 +22052,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22057
22052
|
mimeType: string;
|
|
22058
22053
|
})[];
|
|
22059
22054
|
details?: any;
|
|
22055
|
+
isError: false;
|
|
22060
22056
|
};
|
|
22061
|
-
status: "
|
|
22057
|
+
status: "completed";
|
|
22062
22058
|
thoughtSignature?: string;
|
|
22063
22059
|
time: {
|
|
22064
22060
|
start: number;
|
|
@@ -22082,9 +22078,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22082
22078
|
mimeType: string;
|
|
22083
22079
|
})[];
|
|
22084
22080
|
details?: any;
|
|
22085
|
-
isError:
|
|
22081
|
+
isError: true;
|
|
22086
22082
|
};
|
|
22087
|
-
status: "
|
|
22083
|
+
status: "error";
|
|
22088
22084
|
thoughtSignature?: string;
|
|
22089
22085
|
time: {
|
|
22090
22086
|
start: number;
|
|
@@ -22110,7 +22106,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22110
22106
|
details?: any;
|
|
22111
22107
|
isError: true;
|
|
22112
22108
|
};
|
|
22113
|
-
status: "
|
|
22109
|
+
status: "skipped";
|
|
22114
22110
|
thoughtSignature?: string;
|
|
22115
22111
|
time: {
|
|
22116
22112
|
start: number;
|
|
@@ -22136,21 +22132,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22136
22132
|
details?: any;
|
|
22137
22133
|
isError: true;
|
|
22138
22134
|
};
|
|
22139
|
-
status: "
|
|
22135
|
+
status: "aborted";
|
|
22140
22136
|
thoughtSignature?: string;
|
|
22141
22137
|
time: {
|
|
22142
22138
|
start: number;
|
|
22143
22139
|
end: number;
|
|
22144
22140
|
};
|
|
22145
22141
|
type: "toolCall";
|
|
22142
|
+
} | {
|
|
22143
|
+
type: "thinking";
|
|
22144
|
+
thinking: string;
|
|
22145
|
+
thinkingSignature?: string;
|
|
22146
|
+
redacted?: boolean;
|
|
22146
22147
|
} | {
|
|
22147
22148
|
addedToolNames?: string[];
|
|
22148
22149
|
arguments: Record<string, any>;
|
|
22149
22150
|
callID: string;
|
|
22150
22151
|
name: string;
|
|
22151
22152
|
namespace?: string;
|
|
22152
|
-
|
|
22153
|
-
content
|
|
22153
|
+
partial?: {
|
|
22154
|
+
content?: ({
|
|
22154
22155
|
type: "text";
|
|
22155
22156
|
text: string;
|
|
22156
22157
|
textSignature?: string;
|
|
@@ -22160,9 +22161,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22160
22161
|
mimeType: string;
|
|
22161
22162
|
})[];
|
|
22162
22163
|
details?: any;
|
|
22163
|
-
isError: true;
|
|
22164
22164
|
};
|
|
22165
|
-
status: "
|
|
22165
|
+
status: "running";
|
|
22166
22166
|
thoughtSignature?: string;
|
|
22167
22167
|
time: {
|
|
22168
22168
|
start: number;
|
|
@@ -22337,19 +22337,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22337
22337
|
type: "image";
|
|
22338
22338
|
data: string;
|
|
22339
22339
|
mimeType: string;
|
|
22340
|
-
} | {
|
|
22341
|
-
type: "thinking";
|
|
22342
|
-
thinking: string;
|
|
22343
|
-
thinkingSignature?: string;
|
|
22344
|
-
redacted?: boolean;
|
|
22345
22340
|
} | {
|
|
22346
22341
|
addedToolNames?: string[];
|
|
22347
22342
|
arguments: Record<string, any>;
|
|
22348
22343
|
callID: string;
|
|
22349
22344
|
name: string;
|
|
22350
22345
|
namespace?: string;
|
|
22351
|
-
|
|
22352
|
-
content
|
|
22346
|
+
result: {
|
|
22347
|
+
content: ({
|
|
22353
22348
|
type: "text";
|
|
22354
22349
|
text: string;
|
|
22355
22350
|
textSignature?: string;
|
|
@@ -22359,8 +22354,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22359
22354
|
mimeType: string;
|
|
22360
22355
|
})[];
|
|
22361
22356
|
details?: any;
|
|
22357
|
+
isError: false;
|
|
22362
22358
|
};
|
|
22363
|
-
status: "
|
|
22359
|
+
status: "completed";
|
|
22364
22360
|
thoughtSignature?: string;
|
|
22365
22361
|
time: {
|
|
22366
22362
|
start: number;
|
|
@@ -22384,9 +22380,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22384
22380
|
mimeType: string;
|
|
22385
22381
|
})[];
|
|
22386
22382
|
details?: any;
|
|
22387
|
-
isError:
|
|
22383
|
+
isError: true;
|
|
22388
22384
|
};
|
|
22389
|
-
status: "
|
|
22385
|
+
status: "error";
|
|
22390
22386
|
thoughtSignature?: string;
|
|
22391
22387
|
time: {
|
|
22392
22388
|
start: number;
|
|
@@ -22412,7 +22408,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22412
22408
|
details?: any;
|
|
22413
22409
|
isError: true;
|
|
22414
22410
|
};
|
|
22415
|
-
status: "
|
|
22411
|
+
status: "skipped";
|
|
22416
22412
|
thoughtSignature?: string;
|
|
22417
22413
|
time: {
|
|
22418
22414
|
start: number;
|
|
@@ -22438,21 +22434,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22438
22434
|
details?: any;
|
|
22439
22435
|
isError: true;
|
|
22440
22436
|
};
|
|
22441
|
-
status: "
|
|
22437
|
+
status: "aborted";
|
|
22442
22438
|
thoughtSignature?: string;
|
|
22443
22439
|
time: {
|
|
22444
22440
|
start: number;
|
|
22445
22441
|
end: number;
|
|
22446
22442
|
};
|
|
22447
22443
|
type: "toolCall";
|
|
22444
|
+
} | {
|
|
22445
|
+
type: "thinking";
|
|
22446
|
+
thinking: string;
|
|
22447
|
+
thinkingSignature?: string;
|
|
22448
|
+
redacted?: boolean;
|
|
22448
22449
|
} | {
|
|
22449
22450
|
addedToolNames?: string[];
|
|
22450
22451
|
arguments: Record<string, any>;
|
|
22451
22452
|
callID: string;
|
|
22452
22453
|
name: string;
|
|
22453
22454
|
namespace?: string;
|
|
22454
|
-
|
|
22455
|
-
content
|
|
22455
|
+
partial?: {
|
|
22456
|
+
content?: ({
|
|
22456
22457
|
type: "text";
|
|
22457
22458
|
text: string;
|
|
22458
22459
|
textSignature?: string;
|
|
@@ -22462,9 +22463,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22462
22463
|
mimeType: string;
|
|
22463
22464
|
})[];
|
|
22464
22465
|
details?: any;
|
|
22465
|
-
isError: true;
|
|
22466
22466
|
};
|
|
22467
|
-
status: "
|
|
22467
|
+
status: "running";
|
|
22468
22468
|
thoughtSignature?: string;
|
|
22469
22469
|
time: {
|
|
22470
22470
|
start: number;
|
|
@@ -22658,19 +22658,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22658
22658
|
type: "image";
|
|
22659
22659
|
data: string;
|
|
22660
22660
|
mimeType: string;
|
|
22661
|
-
} | {
|
|
22662
|
-
type: "thinking";
|
|
22663
|
-
thinking: string;
|
|
22664
|
-
thinkingSignature?: string;
|
|
22665
|
-
redacted?: boolean;
|
|
22666
22661
|
} | {
|
|
22667
22662
|
addedToolNames?: string[];
|
|
22668
22663
|
arguments: Record<string, any>;
|
|
22669
22664
|
callID: string;
|
|
22670
22665
|
name: string;
|
|
22671
22666
|
namespace?: string;
|
|
22672
|
-
|
|
22673
|
-
content
|
|
22667
|
+
result: {
|
|
22668
|
+
content: ({
|
|
22674
22669
|
type: "text";
|
|
22675
22670
|
text: string;
|
|
22676
22671
|
textSignature?: string;
|
|
@@ -22680,8 +22675,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22680
22675
|
mimeType: string;
|
|
22681
22676
|
})[];
|
|
22682
22677
|
details?: any;
|
|
22678
|
+
isError: false;
|
|
22683
22679
|
};
|
|
22684
|
-
status: "
|
|
22680
|
+
status: "completed";
|
|
22685
22681
|
thoughtSignature?: string;
|
|
22686
22682
|
time: {
|
|
22687
22683
|
start: number;
|
|
@@ -22705,9 +22701,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22705
22701
|
mimeType: string;
|
|
22706
22702
|
})[];
|
|
22707
22703
|
details?: any;
|
|
22708
|
-
isError:
|
|
22704
|
+
isError: true;
|
|
22709
22705
|
};
|
|
22710
|
-
status: "
|
|
22706
|
+
status: "error";
|
|
22711
22707
|
thoughtSignature?: string;
|
|
22712
22708
|
time: {
|
|
22713
22709
|
start: number;
|
|
@@ -22733,7 +22729,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22733
22729
|
details?: any;
|
|
22734
22730
|
isError: true;
|
|
22735
22731
|
};
|
|
22736
|
-
status: "
|
|
22732
|
+
status: "skipped";
|
|
22737
22733
|
thoughtSignature?: string;
|
|
22738
22734
|
time: {
|
|
22739
22735
|
start: number;
|
|
@@ -22759,21 +22755,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22759
22755
|
details?: any;
|
|
22760
22756
|
isError: true;
|
|
22761
22757
|
};
|
|
22762
|
-
status: "
|
|
22758
|
+
status: "aborted";
|
|
22763
22759
|
thoughtSignature?: string;
|
|
22764
22760
|
time: {
|
|
22765
22761
|
start: number;
|
|
22766
22762
|
end: number;
|
|
22767
22763
|
};
|
|
22768
22764
|
type: "toolCall";
|
|
22765
|
+
} | {
|
|
22766
|
+
type: "thinking";
|
|
22767
|
+
thinking: string;
|
|
22768
|
+
thinkingSignature?: string;
|
|
22769
|
+
redacted?: boolean;
|
|
22769
22770
|
} | {
|
|
22770
22771
|
addedToolNames?: string[];
|
|
22771
22772
|
arguments: Record<string, any>;
|
|
22772
22773
|
callID: string;
|
|
22773
22774
|
name: string;
|
|
22774
22775
|
namespace?: string;
|
|
22775
|
-
|
|
22776
|
-
content
|
|
22776
|
+
partial?: {
|
|
22777
|
+
content?: ({
|
|
22777
22778
|
type: "text";
|
|
22778
22779
|
text: string;
|
|
22779
22780
|
textSignature?: string;
|
|
@@ -22783,9 +22784,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22783
22784
|
mimeType: string;
|
|
22784
22785
|
})[];
|
|
22785
22786
|
details?: any;
|
|
22786
|
-
isError: true;
|
|
22787
22787
|
};
|
|
22788
|
-
status: "
|
|
22788
|
+
status: "running";
|
|
22789
22789
|
thoughtSignature?: string;
|
|
22790
22790
|
time: {
|
|
22791
22791
|
start: number;
|
|
@@ -22960,19 +22960,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22960
22960
|
type: "image";
|
|
22961
22961
|
data: string;
|
|
22962
22962
|
mimeType: string;
|
|
22963
|
-
} | {
|
|
22964
|
-
type: "thinking";
|
|
22965
|
-
thinking: string;
|
|
22966
|
-
thinkingSignature?: string;
|
|
22967
|
-
redacted?: boolean;
|
|
22968
22963
|
} | {
|
|
22969
22964
|
addedToolNames?: string[];
|
|
22970
22965
|
arguments: Record<string, any>;
|
|
22971
22966
|
callID: string;
|
|
22972
22967
|
name: string;
|
|
22973
22968
|
namespace?: string;
|
|
22974
|
-
|
|
22975
|
-
content
|
|
22969
|
+
result: {
|
|
22970
|
+
content: ({
|
|
22976
22971
|
type: "text";
|
|
22977
22972
|
text: string;
|
|
22978
22973
|
textSignature?: string;
|
|
@@ -22982,8 +22977,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22982
22977
|
mimeType: string;
|
|
22983
22978
|
})[];
|
|
22984
22979
|
details?: any;
|
|
22980
|
+
isError: false;
|
|
22985
22981
|
};
|
|
22986
|
-
status: "
|
|
22982
|
+
status: "completed";
|
|
22987
22983
|
thoughtSignature?: string;
|
|
22988
22984
|
time: {
|
|
22989
22985
|
start: number;
|
|
@@ -23007,9 +23003,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23007
23003
|
mimeType: string;
|
|
23008
23004
|
})[];
|
|
23009
23005
|
details?: any;
|
|
23010
|
-
isError:
|
|
23006
|
+
isError: true;
|
|
23011
23007
|
};
|
|
23012
|
-
status: "
|
|
23008
|
+
status: "error";
|
|
23013
23009
|
thoughtSignature?: string;
|
|
23014
23010
|
time: {
|
|
23015
23011
|
start: number;
|
|
@@ -23035,7 +23031,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23035
23031
|
details?: any;
|
|
23036
23032
|
isError: true;
|
|
23037
23033
|
};
|
|
23038
|
-
status: "
|
|
23034
|
+
status: "skipped";
|
|
23039
23035
|
thoughtSignature?: string;
|
|
23040
23036
|
time: {
|
|
23041
23037
|
start: number;
|
|
@@ -23061,21 +23057,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23061
23057
|
details?: any;
|
|
23062
23058
|
isError: true;
|
|
23063
23059
|
};
|
|
23064
|
-
status: "
|
|
23060
|
+
status: "aborted";
|
|
23065
23061
|
thoughtSignature?: string;
|
|
23066
23062
|
time: {
|
|
23067
23063
|
start: number;
|
|
23068
23064
|
end: number;
|
|
23069
23065
|
};
|
|
23070
23066
|
type: "toolCall";
|
|
23067
|
+
} | {
|
|
23068
|
+
type: "thinking";
|
|
23069
|
+
thinking: string;
|
|
23070
|
+
thinkingSignature?: string;
|
|
23071
|
+
redacted?: boolean;
|
|
23071
23072
|
} | {
|
|
23072
23073
|
addedToolNames?: string[];
|
|
23073
23074
|
arguments: Record<string, any>;
|
|
23074
23075
|
callID: string;
|
|
23075
23076
|
name: string;
|
|
23076
23077
|
namespace?: string;
|
|
23077
|
-
|
|
23078
|
-
content
|
|
23078
|
+
partial?: {
|
|
23079
|
+
content?: ({
|
|
23079
23080
|
type: "text";
|
|
23080
23081
|
text: string;
|
|
23081
23082
|
textSignature?: string;
|
|
@@ -23085,9 +23086,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23085
23086
|
mimeType: string;
|
|
23086
23087
|
})[];
|
|
23087
23088
|
details?: any;
|
|
23088
|
-
isError: true;
|
|
23089
23089
|
};
|
|
23090
|
-
status: "
|
|
23090
|
+
status: "running";
|
|
23091
23091
|
thoughtSignature?: string;
|
|
23092
23092
|
time: {
|
|
23093
23093
|
start: number;
|
|
@@ -23290,19 +23290,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23290
23290
|
type: "image";
|
|
23291
23291
|
data: string;
|
|
23292
23292
|
mimeType: string;
|
|
23293
|
-
} | {
|
|
23294
|
-
type: "thinking";
|
|
23295
|
-
thinking: string;
|
|
23296
|
-
thinkingSignature?: string;
|
|
23297
|
-
redacted?: boolean;
|
|
23298
23293
|
} | {
|
|
23299
23294
|
addedToolNames?: string[];
|
|
23300
23295
|
arguments: Record<string, any>;
|
|
23301
23296
|
callID: string;
|
|
23302
23297
|
name: string;
|
|
23303
23298
|
namespace?: string;
|
|
23304
|
-
|
|
23305
|
-
content
|
|
23299
|
+
result: {
|
|
23300
|
+
content: ({
|
|
23306
23301
|
type: "text";
|
|
23307
23302
|
text: string;
|
|
23308
23303
|
textSignature?: string;
|
|
@@ -23312,8 +23307,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23312
23307
|
mimeType: string;
|
|
23313
23308
|
})[];
|
|
23314
23309
|
details?: any;
|
|
23310
|
+
isError: false;
|
|
23315
23311
|
};
|
|
23316
|
-
status: "
|
|
23312
|
+
status: "completed";
|
|
23317
23313
|
thoughtSignature?: string;
|
|
23318
23314
|
time: {
|
|
23319
23315
|
start: number;
|
|
@@ -23337,9 +23333,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23337
23333
|
mimeType: string;
|
|
23338
23334
|
})[];
|
|
23339
23335
|
details?: any;
|
|
23340
|
-
isError:
|
|
23336
|
+
isError: true;
|
|
23341
23337
|
};
|
|
23342
|
-
status: "
|
|
23338
|
+
status: "error";
|
|
23343
23339
|
thoughtSignature?: string;
|
|
23344
23340
|
time: {
|
|
23345
23341
|
start: number;
|
|
@@ -23365,7 +23361,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23365
23361
|
details?: any;
|
|
23366
23362
|
isError: true;
|
|
23367
23363
|
};
|
|
23368
|
-
status: "
|
|
23364
|
+
status: "skipped";
|
|
23369
23365
|
thoughtSignature?: string;
|
|
23370
23366
|
time: {
|
|
23371
23367
|
start: number;
|
|
@@ -23391,21 +23387,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23391
23387
|
details?: any;
|
|
23392
23388
|
isError: true;
|
|
23393
23389
|
};
|
|
23394
|
-
status: "
|
|
23390
|
+
status: "aborted";
|
|
23395
23391
|
thoughtSignature?: string;
|
|
23396
23392
|
time: {
|
|
23397
23393
|
start: number;
|
|
23398
23394
|
end: number;
|
|
23399
23395
|
};
|
|
23400
23396
|
type: "toolCall";
|
|
23397
|
+
} | {
|
|
23398
|
+
type: "thinking";
|
|
23399
|
+
thinking: string;
|
|
23400
|
+
thinkingSignature?: string;
|
|
23401
|
+
redacted?: boolean;
|
|
23401
23402
|
} | {
|
|
23402
23403
|
addedToolNames?: string[];
|
|
23403
23404
|
arguments: Record<string, any>;
|
|
23404
23405
|
callID: string;
|
|
23405
23406
|
name: string;
|
|
23406
23407
|
namespace?: string;
|
|
23407
|
-
|
|
23408
|
-
content
|
|
23408
|
+
partial?: {
|
|
23409
|
+
content?: ({
|
|
23409
23410
|
type: "text";
|
|
23410
23411
|
text: string;
|
|
23411
23412
|
textSignature?: string;
|
|
@@ -23415,9 +23416,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23415
23416
|
mimeType: string;
|
|
23416
23417
|
})[];
|
|
23417
23418
|
details?: any;
|
|
23418
|
-
isError: true;
|
|
23419
23419
|
};
|
|
23420
|
-
status: "
|
|
23420
|
+
status: "running";
|
|
23421
23421
|
thoughtSignature?: string;
|
|
23422
23422
|
time: {
|
|
23423
23423
|
start: number;
|
|
@@ -23592,19 +23592,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23592
23592
|
type: "image";
|
|
23593
23593
|
data: string;
|
|
23594
23594
|
mimeType: string;
|
|
23595
|
-
} | {
|
|
23596
|
-
type: "thinking";
|
|
23597
|
-
thinking: string;
|
|
23598
|
-
thinkingSignature?: string;
|
|
23599
|
-
redacted?: boolean;
|
|
23600
23595
|
} | {
|
|
23601
23596
|
addedToolNames?: string[];
|
|
23602
23597
|
arguments: Record<string, any>;
|
|
23603
23598
|
callID: string;
|
|
23604
23599
|
name: string;
|
|
23605
23600
|
namespace?: string;
|
|
23606
|
-
|
|
23607
|
-
content
|
|
23601
|
+
result: {
|
|
23602
|
+
content: ({
|
|
23608
23603
|
type: "text";
|
|
23609
23604
|
text: string;
|
|
23610
23605
|
textSignature?: string;
|
|
@@ -23614,8 +23609,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23614
23609
|
mimeType: string;
|
|
23615
23610
|
})[];
|
|
23616
23611
|
details?: any;
|
|
23612
|
+
isError: false;
|
|
23617
23613
|
};
|
|
23618
|
-
status: "
|
|
23614
|
+
status: "completed";
|
|
23619
23615
|
thoughtSignature?: string;
|
|
23620
23616
|
time: {
|
|
23621
23617
|
start: number;
|
|
@@ -23639,9 +23635,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23639
23635
|
mimeType: string;
|
|
23640
23636
|
})[];
|
|
23641
23637
|
details?: any;
|
|
23642
|
-
isError:
|
|
23638
|
+
isError: true;
|
|
23643
23639
|
};
|
|
23644
|
-
status: "
|
|
23640
|
+
status: "error";
|
|
23645
23641
|
thoughtSignature?: string;
|
|
23646
23642
|
time: {
|
|
23647
23643
|
start: number;
|
|
@@ -23667,7 +23663,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23667
23663
|
details?: any;
|
|
23668
23664
|
isError: true;
|
|
23669
23665
|
};
|
|
23670
|
-
status: "
|
|
23666
|
+
status: "skipped";
|
|
23671
23667
|
thoughtSignature?: string;
|
|
23672
23668
|
time: {
|
|
23673
23669
|
start: number;
|
|
@@ -23693,21 +23689,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23693
23689
|
details?: any;
|
|
23694
23690
|
isError: true;
|
|
23695
23691
|
};
|
|
23696
|
-
status: "
|
|
23692
|
+
status: "aborted";
|
|
23697
23693
|
thoughtSignature?: string;
|
|
23698
23694
|
time: {
|
|
23699
23695
|
start: number;
|
|
23700
23696
|
end: number;
|
|
23701
23697
|
};
|
|
23702
23698
|
type: "toolCall";
|
|
23699
|
+
} | {
|
|
23700
|
+
type: "thinking";
|
|
23701
|
+
thinking: string;
|
|
23702
|
+
thinkingSignature?: string;
|
|
23703
|
+
redacted?: boolean;
|
|
23703
23704
|
} | {
|
|
23704
23705
|
addedToolNames?: string[];
|
|
23705
23706
|
arguments: Record<string, any>;
|
|
23706
23707
|
callID: string;
|
|
23707
23708
|
name: string;
|
|
23708
23709
|
namespace?: string;
|
|
23709
|
-
|
|
23710
|
-
content
|
|
23710
|
+
partial?: {
|
|
23711
|
+
content?: ({
|
|
23711
23712
|
type: "text";
|
|
23712
23713
|
text: string;
|
|
23713
23714
|
textSignature?: string;
|
|
@@ -23717,9 +23718,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23717
23718
|
mimeType: string;
|
|
23718
23719
|
})[];
|
|
23719
23720
|
details?: any;
|
|
23720
|
-
isError: true;
|
|
23721
23721
|
};
|
|
23722
|
-
status: "
|
|
23722
|
+
status: "running";
|
|
23723
23723
|
thoughtSignature?: string;
|
|
23724
23724
|
time: {
|
|
23725
23725
|
start: number;
|
|
@@ -23913,19 +23913,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23913
23913
|
type: "image";
|
|
23914
23914
|
data: string;
|
|
23915
23915
|
mimeType: string;
|
|
23916
|
-
} | {
|
|
23917
|
-
type: "thinking";
|
|
23918
|
-
thinking: string;
|
|
23919
|
-
thinkingSignature?: string;
|
|
23920
|
-
redacted?: boolean;
|
|
23921
23916
|
} | {
|
|
23922
23917
|
addedToolNames?: string[];
|
|
23923
23918
|
arguments: Record<string, any>;
|
|
23924
23919
|
callID: string;
|
|
23925
23920
|
name: string;
|
|
23926
23921
|
namespace?: string;
|
|
23927
|
-
|
|
23928
|
-
content
|
|
23922
|
+
result: {
|
|
23923
|
+
content: ({
|
|
23929
23924
|
type: "text";
|
|
23930
23925
|
text: string;
|
|
23931
23926
|
textSignature?: string;
|
|
@@ -23935,8 +23930,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23935
23930
|
mimeType: string;
|
|
23936
23931
|
})[];
|
|
23937
23932
|
details?: any;
|
|
23933
|
+
isError: false;
|
|
23938
23934
|
};
|
|
23939
|
-
status: "
|
|
23935
|
+
status: "completed";
|
|
23940
23936
|
thoughtSignature?: string;
|
|
23941
23937
|
time: {
|
|
23942
23938
|
start: number;
|
|
@@ -23960,9 +23956,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23960
23956
|
mimeType: string;
|
|
23961
23957
|
})[];
|
|
23962
23958
|
details?: any;
|
|
23963
|
-
isError:
|
|
23959
|
+
isError: true;
|
|
23964
23960
|
};
|
|
23965
|
-
status: "
|
|
23961
|
+
status: "error";
|
|
23966
23962
|
thoughtSignature?: string;
|
|
23967
23963
|
time: {
|
|
23968
23964
|
start: number;
|
|
@@ -23988,7 +23984,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23988
23984
|
details?: any;
|
|
23989
23985
|
isError: true;
|
|
23990
23986
|
};
|
|
23991
|
-
status: "
|
|
23987
|
+
status: "skipped";
|
|
23992
23988
|
thoughtSignature?: string;
|
|
23993
23989
|
time: {
|
|
23994
23990
|
start: number;
|
|
@@ -24014,21 +24010,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24014
24010
|
details?: any;
|
|
24015
24011
|
isError: true;
|
|
24016
24012
|
};
|
|
24017
|
-
status: "
|
|
24013
|
+
status: "aborted";
|
|
24018
24014
|
thoughtSignature?: string;
|
|
24019
24015
|
time: {
|
|
24020
24016
|
start: number;
|
|
24021
24017
|
end: number;
|
|
24022
24018
|
};
|
|
24023
24019
|
type: "toolCall";
|
|
24020
|
+
} | {
|
|
24021
|
+
type: "thinking";
|
|
24022
|
+
thinking: string;
|
|
24023
|
+
thinkingSignature?: string;
|
|
24024
|
+
redacted?: boolean;
|
|
24024
24025
|
} | {
|
|
24025
24026
|
addedToolNames?: string[];
|
|
24026
24027
|
arguments: Record<string, any>;
|
|
24027
24028
|
callID: string;
|
|
24028
24029
|
name: string;
|
|
24029
24030
|
namespace?: string;
|
|
24030
|
-
|
|
24031
|
-
content
|
|
24031
|
+
partial?: {
|
|
24032
|
+
content?: ({
|
|
24032
24033
|
type: "text";
|
|
24033
24034
|
text: string;
|
|
24034
24035
|
textSignature?: string;
|
|
@@ -24038,9 +24039,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24038
24039
|
mimeType: string;
|
|
24039
24040
|
})[];
|
|
24040
24041
|
details?: any;
|
|
24041
|
-
isError: true;
|
|
24042
24042
|
};
|
|
24043
|
-
status: "
|
|
24043
|
+
status: "running";
|
|
24044
24044
|
thoughtSignature?: string;
|
|
24045
24045
|
time: {
|
|
24046
24046
|
start: number;
|
|
@@ -24215,19 +24215,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24215
24215
|
type: "image";
|
|
24216
24216
|
data: string;
|
|
24217
24217
|
mimeType: string;
|
|
24218
|
-
} | {
|
|
24219
|
-
type: "thinking";
|
|
24220
|
-
thinking: string;
|
|
24221
|
-
thinkingSignature?: string;
|
|
24222
|
-
redacted?: boolean;
|
|
24223
24218
|
} | {
|
|
24224
24219
|
addedToolNames?: string[];
|
|
24225
24220
|
arguments: Record<string, any>;
|
|
24226
24221
|
callID: string;
|
|
24227
24222
|
name: string;
|
|
24228
24223
|
namespace?: string;
|
|
24229
|
-
|
|
24230
|
-
content
|
|
24224
|
+
result: {
|
|
24225
|
+
content: ({
|
|
24231
24226
|
type: "text";
|
|
24232
24227
|
text: string;
|
|
24233
24228
|
textSignature?: string;
|
|
@@ -24237,8 +24232,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24237
24232
|
mimeType: string;
|
|
24238
24233
|
})[];
|
|
24239
24234
|
details?: any;
|
|
24235
|
+
isError: false;
|
|
24240
24236
|
};
|
|
24241
|
-
status: "
|
|
24237
|
+
status: "completed";
|
|
24242
24238
|
thoughtSignature?: string;
|
|
24243
24239
|
time: {
|
|
24244
24240
|
start: number;
|
|
@@ -24262,9 +24258,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24262
24258
|
mimeType: string;
|
|
24263
24259
|
})[];
|
|
24264
24260
|
details?: any;
|
|
24265
|
-
isError:
|
|
24261
|
+
isError: true;
|
|
24266
24262
|
};
|
|
24267
|
-
status: "
|
|
24263
|
+
status: "error";
|
|
24268
24264
|
thoughtSignature?: string;
|
|
24269
24265
|
time: {
|
|
24270
24266
|
start: number;
|
|
@@ -24290,7 +24286,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24290
24286
|
details?: any;
|
|
24291
24287
|
isError: true;
|
|
24292
24288
|
};
|
|
24293
|
-
status: "
|
|
24289
|
+
status: "skipped";
|
|
24294
24290
|
thoughtSignature?: string;
|
|
24295
24291
|
time: {
|
|
24296
24292
|
start: number;
|
|
@@ -24316,21 +24312,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24316
24312
|
details?: any;
|
|
24317
24313
|
isError: true;
|
|
24318
24314
|
};
|
|
24319
|
-
status: "
|
|
24315
|
+
status: "aborted";
|
|
24320
24316
|
thoughtSignature?: string;
|
|
24321
24317
|
time: {
|
|
24322
24318
|
start: number;
|
|
24323
24319
|
end: number;
|
|
24324
24320
|
};
|
|
24325
24321
|
type: "toolCall";
|
|
24322
|
+
} | {
|
|
24323
|
+
type: "thinking";
|
|
24324
|
+
thinking: string;
|
|
24325
|
+
thinkingSignature?: string;
|
|
24326
|
+
redacted?: boolean;
|
|
24326
24327
|
} | {
|
|
24327
24328
|
addedToolNames?: string[];
|
|
24328
24329
|
arguments: Record<string, any>;
|
|
24329
24330
|
callID: string;
|
|
24330
24331
|
name: string;
|
|
24331
24332
|
namespace?: string;
|
|
24332
|
-
|
|
24333
|
-
content
|
|
24333
|
+
partial?: {
|
|
24334
|
+
content?: ({
|
|
24334
24335
|
type: "text";
|
|
24335
24336
|
text: string;
|
|
24336
24337
|
textSignature?: string;
|
|
@@ -24340,9 +24341,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24340
24341
|
mimeType: string;
|
|
24341
24342
|
})[];
|
|
24342
24343
|
details?: any;
|
|
24343
|
-
isError: true;
|
|
24344
24344
|
};
|
|
24345
|
-
status: "
|
|
24345
|
+
status: "running";
|
|
24346
24346
|
thoughtSignature?: string;
|
|
24347
24347
|
time: {
|
|
24348
24348
|
start: number;
|