@codeworksh/harness 0.3.0-dev.20261019181702 → 0.4.0-dev.20261019193730
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/effect.mjs +19 -11
- package/effect.mjs.map +1 -1
- package/package.json +4 -3
package/effect.d.mts
CHANGED
|
@@ -2734,6 +2734,21 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
|
|
|
2734
2734
|
declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
|
|
2735
2735
|
declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
|
|
2736
2736
|
declare const encodeMessage: (message: {
|
|
2737
|
+
messageId: string;
|
|
2738
|
+
role: "user";
|
|
2739
|
+
time: {
|
|
2740
|
+
created: number;
|
|
2741
|
+
};
|
|
2742
|
+
parts: ({
|
|
2743
|
+
type: "text";
|
|
2744
|
+
text: string;
|
|
2745
|
+
textSignature?: string;
|
|
2746
|
+
} | {
|
|
2747
|
+
type: "image";
|
|
2748
|
+
data: string;
|
|
2749
|
+
mimeType: string;
|
|
2750
|
+
})[];
|
|
2751
|
+
} | {
|
|
2737
2752
|
role: "assistant";
|
|
2738
2753
|
protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
|
|
2739
2754
|
provider: {
|
|
@@ -2883,19 +2898,14 @@ declare const encodeMessage: (message: {
|
|
|
2883
2898
|
type: "image";
|
|
2884
2899
|
data: string;
|
|
2885
2900
|
mimeType: string;
|
|
2886
|
-
} | {
|
|
2887
|
-
type: "thinking";
|
|
2888
|
-
thinking: string;
|
|
2889
|
-
thinkingSignature?: string;
|
|
2890
|
-
redacted?: boolean;
|
|
2891
2901
|
} | {
|
|
2892
2902
|
addedToolNames?: string[];
|
|
2893
2903
|
arguments: Record<string, any>;
|
|
2894
2904
|
callID: string;
|
|
2895
2905
|
name: string;
|
|
2896
2906
|
namespace?: string;
|
|
2897
|
-
|
|
2898
|
-
content
|
|
2907
|
+
result: {
|
|
2908
|
+
content: ({
|
|
2899
2909
|
type: "text";
|
|
2900
2910
|
text: string;
|
|
2901
2911
|
textSignature?: string;
|
|
@@ -2905,8 +2915,9 @@ declare const encodeMessage: (message: {
|
|
|
2905
2915
|
mimeType: string;
|
|
2906
2916
|
})[];
|
|
2907
2917
|
details?: any;
|
|
2918
|
+
isError: false;
|
|
2908
2919
|
};
|
|
2909
|
-
status: "
|
|
2920
|
+
status: "completed";
|
|
2910
2921
|
thoughtSignature?: string;
|
|
2911
2922
|
time: {
|
|
2912
2923
|
start: number;
|
|
@@ -2930,9 +2941,9 @@ declare const encodeMessage: (message: {
|
|
|
2930
2941
|
mimeType: string;
|
|
2931
2942
|
})[];
|
|
2932
2943
|
details?: any;
|
|
2933
|
-
isError:
|
|
2944
|
+
isError: true;
|
|
2934
2945
|
};
|
|
2935
|
-
status: "
|
|
2946
|
+
status: "error";
|
|
2936
2947
|
thoughtSignature?: string;
|
|
2937
2948
|
time: {
|
|
2938
2949
|
start: number;
|
|
@@ -2958,7 +2969,7 @@ declare const encodeMessage: (message: {
|
|
|
2958
2969
|
details?: any;
|
|
2959
2970
|
isError: true;
|
|
2960
2971
|
};
|
|
2961
|
-
status: "
|
|
2972
|
+
status: "skipped";
|
|
2962
2973
|
thoughtSignature?: string;
|
|
2963
2974
|
time: {
|
|
2964
2975
|
start: number;
|
|
@@ -2984,21 +2995,26 @@ declare const encodeMessage: (message: {
|
|
|
2984
2995
|
details?: any;
|
|
2985
2996
|
isError: true;
|
|
2986
2997
|
};
|
|
2987
|
-
status: "
|
|
2998
|
+
status: "aborted";
|
|
2988
2999
|
thoughtSignature?: string;
|
|
2989
3000
|
time: {
|
|
2990
3001
|
start: number;
|
|
2991
3002
|
end: number;
|
|
2992
3003
|
};
|
|
2993
3004
|
type: "toolCall";
|
|
3005
|
+
} | {
|
|
3006
|
+
type: "thinking";
|
|
3007
|
+
thinking: string;
|
|
3008
|
+
thinkingSignature?: string;
|
|
3009
|
+
redacted?: boolean;
|
|
2994
3010
|
} | {
|
|
2995
3011
|
addedToolNames?: string[];
|
|
2996
3012
|
arguments: Record<string, any>;
|
|
2997
3013
|
callID: string;
|
|
2998
3014
|
name: string;
|
|
2999
3015
|
namespace?: string;
|
|
3000
|
-
|
|
3001
|
-
content
|
|
3016
|
+
partial?: {
|
|
3017
|
+
content?: ({
|
|
3002
3018
|
type: "text";
|
|
3003
3019
|
text: string;
|
|
3004
3020
|
textSignature?: string;
|
|
@@ -3008,9 +3024,8 @@ declare const encodeMessage: (message: {
|
|
|
3008
3024
|
mimeType: string;
|
|
3009
3025
|
})[];
|
|
3010
3026
|
details?: any;
|
|
3011
|
-
isError: true;
|
|
3012
3027
|
};
|
|
3013
|
-
status: "
|
|
3028
|
+
status: "running";
|
|
3014
3029
|
thoughtSignature?: string;
|
|
3015
3030
|
time: {
|
|
3016
3031
|
start: number;
|
|
@@ -3035,7 +3050,8 @@ declare const encodeMessage: (message: {
|
|
|
3035
3050
|
responseId?: string;
|
|
3036
3051
|
responseModel?: string;
|
|
3037
3052
|
messageId: string;
|
|
3038
|
-
}
|
|
3053
|
+
}) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
|
|
3054
|
+
declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3039
3055
|
messageId: string;
|
|
3040
3056
|
role: "user";
|
|
3041
3057
|
time: {
|
|
@@ -3050,8 +3066,8 @@ declare const encodeMessage: (message: {
|
|
|
3050
3066
|
data: string;
|
|
3051
3067
|
mimeType: string;
|
|
3052
3068
|
})[];
|
|
3053
|
-
}
|
|
3054
|
-
declare const
|
|
3069
|
+
}, ContextDecodeError, never>;
|
|
3070
|
+
declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3055
3071
|
messageId: string;
|
|
3056
3072
|
role: "user";
|
|
3057
3073
|
time: {
|
|
@@ -3066,8 +3082,7 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
|
|
|
3066
3082
|
data: string;
|
|
3067
3083
|
mimeType: string;
|
|
3068
3084
|
})[];
|
|
3069
|
-
}
|
|
3070
|
-
declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3085
|
+
} | {
|
|
3071
3086
|
role: "assistant";
|
|
3072
3087
|
protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
|
|
3073
3088
|
provider: {
|
|
@@ -3217,19 +3232,14 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3217
3232
|
type: "image";
|
|
3218
3233
|
data: string;
|
|
3219
3234
|
mimeType: string;
|
|
3220
|
-
} | {
|
|
3221
|
-
type: "thinking";
|
|
3222
|
-
thinking: string;
|
|
3223
|
-
thinkingSignature?: string;
|
|
3224
|
-
redacted?: boolean;
|
|
3225
3235
|
} | {
|
|
3226
3236
|
addedToolNames?: string[];
|
|
3227
3237
|
arguments: Record<string, any>;
|
|
3228
3238
|
callID: string;
|
|
3229
3239
|
name: string;
|
|
3230
3240
|
namespace?: string;
|
|
3231
|
-
|
|
3232
|
-
content
|
|
3241
|
+
result: {
|
|
3242
|
+
content: ({
|
|
3233
3243
|
type: "text";
|
|
3234
3244
|
text: string;
|
|
3235
3245
|
textSignature?: string;
|
|
@@ -3239,8 +3249,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3239
3249
|
mimeType: string;
|
|
3240
3250
|
})[];
|
|
3241
3251
|
details?: any;
|
|
3252
|
+
isError: false;
|
|
3242
3253
|
};
|
|
3243
|
-
status: "
|
|
3254
|
+
status: "completed";
|
|
3244
3255
|
thoughtSignature?: string;
|
|
3245
3256
|
time: {
|
|
3246
3257
|
start: number;
|
|
@@ -3264,9 +3275,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3264
3275
|
mimeType: string;
|
|
3265
3276
|
})[];
|
|
3266
3277
|
details?: any;
|
|
3267
|
-
isError:
|
|
3278
|
+
isError: true;
|
|
3268
3279
|
};
|
|
3269
|
-
status: "
|
|
3280
|
+
status: "error";
|
|
3270
3281
|
thoughtSignature?: string;
|
|
3271
3282
|
time: {
|
|
3272
3283
|
start: number;
|
|
@@ -3292,7 +3303,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3292
3303
|
details?: any;
|
|
3293
3304
|
isError: true;
|
|
3294
3305
|
};
|
|
3295
|
-
status: "
|
|
3306
|
+
status: "skipped";
|
|
3296
3307
|
thoughtSignature?: string;
|
|
3297
3308
|
time: {
|
|
3298
3309
|
start: number;
|
|
@@ -3318,21 +3329,26 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3318
3329
|
details?: any;
|
|
3319
3330
|
isError: true;
|
|
3320
3331
|
};
|
|
3321
|
-
status: "
|
|
3332
|
+
status: "aborted";
|
|
3322
3333
|
thoughtSignature?: string;
|
|
3323
3334
|
time: {
|
|
3324
3335
|
start: number;
|
|
3325
3336
|
end: number;
|
|
3326
3337
|
};
|
|
3327
3338
|
type: "toolCall";
|
|
3339
|
+
} | {
|
|
3340
|
+
type: "thinking";
|
|
3341
|
+
thinking: string;
|
|
3342
|
+
thinkingSignature?: string;
|
|
3343
|
+
redacted?: boolean;
|
|
3328
3344
|
} | {
|
|
3329
3345
|
addedToolNames?: string[];
|
|
3330
3346
|
arguments: Record<string, any>;
|
|
3331
3347
|
callID: string;
|
|
3332
3348
|
name: string;
|
|
3333
3349
|
namespace?: string;
|
|
3334
|
-
|
|
3335
|
-
content
|
|
3350
|
+
partial?: {
|
|
3351
|
+
content?: ({
|
|
3336
3352
|
type: "text";
|
|
3337
3353
|
text: string;
|
|
3338
3354
|
textSignature?: string;
|
|
@@ -3342,9 +3358,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3342
3358
|
mimeType: string;
|
|
3343
3359
|
})[];
|
|
3344
3360
|
details?: any;
|
|
3345
|
-
isError: true;
|
|
3346
3361
|
};
|
|
3347
|
-
status: "
|
|
3362
|
+
status: "running";
|
|
3348
3363
|
thoughtSignature?: string;
|
|
3349
3364
|
time: {
|
|
3350
3365
|
start: number;
|
|
@@ -3369,21 +3384,6 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3369
3384
|
responseId?: string;
|
|
3370
3385
|
responseModel?: string;
|
|
3371
3386
|
messageId: string;
|
|
3372
|
-
} | {
|
|
3373
|
-
messageId: string;
|
|
3374
|
-
role: "user";
|
|
3375
|
-
time: {
|
|
3376
|
-
created: number;
|
|
3377
|
-
};
|
|
3378
|
-
parts: ({
|
|
3379
|
-
type: "text";
|
|
3380
|
-
text: string;
|
|
3381
|
-
textSignature?: string;
|
|
3382
|
-
} | {
|
|
3383
|
-
type: "image";
|
|
3384
|
-
data: string;
|
|
3385
|
-
mimeType: string;
|
|
3386
|
-
})[];
|
|
3387
3387
|
}, ContextDecodeError, never>;
|
|
3388
3388
|
declare namespace context_d_exports {
|
|
3389
3389
|
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 };
|
|
@@ -4876,19 +4876,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4876
4876
|
type: "image";
|
|
4877
4877
|
data: string;
|
|
4878
4878
|
mimeType: string;
|
|
4879
|
-
} | {
|
|
4880
|
-
type: "thinking";
|
|
4881
|
-
thinking: string;
|
|
4882
|
-
thinkingSignature?: string;
|
|
4883
|
-
redacted?: boolean;
|
|
4884
4879
|
} | {
|
|
4885
4880
|
addedToolNames?: string[];
|
|
4886
4881
|
arguments: Record<string, any>;
|
|
4887
4882
|
callID: string;
|
|
4888
4883
|
name: string;
|
|
4889
4884
|
namespace?: string;
|
|
4890
|
-
|
|
4891
|
-
content
|
|
4885
|
+
result: {
|
|
4886
|
+
content: ({
|
|
4892
4887
|
type: "text";
|
|
4893
4888
|
text: string;
|
|
4894
4889
|
textSignature?: string;
|
|
@@ -4898,8 +4893,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4898
4893
|
mimeType: string;
|
|
4899
4894
|
})[];
|
|
4900
4895
|
details?: any;
|
|
4896
|
+
isError: false;
|
|
4901
4897
|
};
|
|
4902
|
-
status: "
|
|
4898
|
+
status: "completed";
|
|
4903
4899
|
thoughtSignature?: string;
|
|
4904
4900
|
time: {
|
|
4905
4901
|
start: number;
|
|
@@ -4923,9 +4919,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4923
4919
|
mimeType: string;
|
|
4924
4920
|
})[];
|
|
4925
4921
|
details?: any;
|
|
4926
|
-
isError:
|
|
4922
|
+
isError: true;
|
|
4927
4923
|
};
|
|
4928
|
-
status: "
|
|
4924
|
+
status: "error";
|
|
4929
4925
|
thoughtSignature?: string;
|
|
4930
4926
|
time: {
|
|
4931
4927
|
start: number;
|
|
@@ -4951,7 +4947,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4951
4947
|
details?: any;
|
|
4952
4948
|
isError: true;
|
|
4953
4949
|
};
|
|
4954
|
-
status: "
|
|
4950
|
+
status: "skipped";
|
|
4955
4951
|
thoughtSignature?: string;
|
|
4956
4952
|
time: {
|
|
4957
4953
|
start: number;
|
|
@@ -4977,21 +4973,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4977
4973
|
details?: any;
|
|
4978
4974
|
isError: true;
|
|
4979
4975
|
};
|
|
4980
|
-
status: "
|
|
4976
|
+
status: "aborted";
|
|
4981
4977
|
thoughtSignature?: string;
|
|
4982
4978
|
time: {
|
|
4983
4979
|
start: number;
|
|
4984
4980
|
end: number;
|
|
4985
4981
|
};
|
|
4986
4982
|
type: "toolCall";
|
|
4983
|
+
} | {
|
|
4984
|
+
type: "thinking";
|
|
4985
|
+
thinking: string;
|
|
4986
|
+
thinkingSignature?: string;
|
|
4987
|
+
redacted?: boolean;
|
|
4987
4988
|
} | {
|
|
4988
4989
|
addedToolNames?: string[];
|
|
4989
4990
|
arguments: Record<string, any>;
|
|
4990
4991
|
callID: string;
|
|
4991
4992
|
name: string;
|
|
4992
4993
|
namespace?: string;
|
|
4993
|
-
|
|
4994
|
-
content
|
|
4994
|
+
partial?: {
|
|
4995
|
+
content?: ({
|
|
4995
4996
|
type: "text";
|
|
4996
4997
|
text: string;
|
|
4997
4998
|
textSignature?: string;
|
|
@@ -5001,9 +5002,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5001
5002
|
mimeType: string;
|
|
5002
5003
|
})[];
|
|
5003
5004
|
details?: any;
|
|
5004
|
-
isError: true;
|
|
5005
5005
|
};
|
|
5006
|
-
status: "
|
|
5006
|
+
status: "running";
|
|
5007
5007
|
thoughtSignature?: string;
|
|
5008
5008
|
time: {
|
|
5009
5009
|
start: number;
|
|
@@ -5178,19 +5178,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5178
5178
|
type: "image";
|
|
5179
5179
|
data: string;
|
|
5180
5180
|
mimeType: string;
|
|
5181
|
-
} | {
|
|
5182
|
-
type: "thinking";
|
|
5183
|
-
thinking: string;
|
|
5184
|
-
thinkingSignature?: string;
|
|
5185
|
-
redacted?: boolean;
|
|
5186
5181
|
} | {
|
|
5187
5182
|
addedToolNames?: string[];
|
|
5188
5183
|
arguments: Record<string, any>;
|
|
5189
5184
|
callID: string;
|
|
5190
5185
|
name: string;
|
|
5191
5186
|
namespace?: string;
|
|
5192
|
-
|
|
5193
|
-
content
|
|
5187
|
+
result: {
|
|
5188
|
+
content: ({
|
|
5194
5189
|
type: "text";
|
|
5195
5190
|
text: string;
|
|
5196
5191
|
textSignature?: string;
|
|
@@ -5200,8 +5195,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5200
5195
|
mimeType: string;
|
|
5201
5196
|
})[];
|
|
5202
5197
|
details?: any;
|
|
5198
|
+
isError: false;
|
|
5203
5199
|
};
|
|
5204
|
-
status: "
|
|
5200
|
+
status: "completed";
|
|
5205
5201
|
thoughtSignature?: string;
|
|
5206
5202
|
time: {
|
|
5207
5203
|
start: number;
|
|
@@ -5225,9 +5221,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5225
5221
|
mimeType: string;
|
|
5226
5222
|
})[];
|
|
5227
5223
|
details?: any;
|
|
5228
|
-
isError:
|
|
5224
|
+
isError: true;
|
|
5229
5225
|
};
|
|
5230
|
-
status: "
|
|
5226
|
+
status: "error";
|
|
5231
5227
|
thoughtSignature?: string;
|
|
5232
5228
|
time: {
|
|
5233
5229
|
start: number;
|
|
@@ -5253,7 +5249,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5253
5249
|
details?: any;
|
|
5254
5250
|
isError: true;
|
|
5255
5251
|
};
|
|
5256
|
-
status: "
|
|
5252
|
+
status: "skipped";
|
|
5257
5253
|
thoughtSignature?: string;
|
|
5258
5254
|
time: {
|
|
5259
5255
|
start: number;
|
|
@@ -5279,21 +5275,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5279
5275
|
details?: any;
|
|
5280
5276
|
isError: true;
|
|
5281
5277
|
};
|
|
5282
|
-
status: "
|
|
5278
|
+
status: "aborted";
|
|
5283
5279
|
thoughtSignature?: string;
|
|
5284
5280
|
time: {
|
|
5285
5281
|
start: number;
|
|
5286
5282
|
end: number;
|
|
5287
5283
|
};
|
|
5288
5284
|
type: "toolCall";
|
|
5285
|
+
} | {
|
|
5286
|
+
type: "thinking";
|
|
5287
|
+
thinking: string;
|
|
5288
|
+
thinkingSignature?: string;
|
|
5289
|
+
redacted?: boolean;
|
|
5289
5290
|
} | {
|
|
5290
5291
|
addedToolNames?: string[];
|
|
5291
5292
|
arguments: Record<string, any>;
|
|
5292
5293
|
callID: string;
|
|
5293
5294
|
name: string;
|
|
5294
5295
|
namespace?: string;
|
|
5295
|
-
|
|
5296
|
-
content
|
|
5296
|
+
partial?: {
|
|
5297
|
+
content?: ({
|
|
5297
5298
|
type: "text";
|
|
5298
5299
|
text: string;
|
|
5299
5300
|
textSignature?: string;
|
|
@@ -5303,9 +5304,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5303
5304
|
mimeType: string;
|
|
5304
5305
|
})[];
|
|
5305
5306
|
details?: any;
|
|
5306
|
-
isError: true;
|
|
5307
5307
|
};
|
|
5308
|
-
status: "
|
|
5308
|
+
status: "running";
|
|
5309
5309
|
thoughtSignature?: string;
|
|
5310
5310
|
time: {
|
|
5311
5311
|
start: number;
|
|
@@ -5498,19 +5498,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5498
5498
|
type: "image";
|
|
5499
5499
|
data: string;
|
|
5500
5500
|
mimeType: string;
|
|
5501
|
-
} | {
|
|
5502
|
-
type: "thinking";
|
|
5503
|
-
thinking: string;
|
|
5504
|
-
thinkingSignature?: string;
|
|
5505
|
-
redacted?: boolean;
|
|
5506
5501
|
} | {
|
|
5507
5502
|
addedToolNames?: string[];
|
|
5508
5503
|
arguments: Record<string, any>;
|
|
5509
5504
|
callID: string;
|
|
5510
5505
|
name: string;
|
|
5511
5506
|
namespace?: string;
|
|
5512
|
-
|
|
5513
|
-
content
|
|
5507
|
+
result: {
|
|
5508
|
+
content: ({
|
|
5514
5509
|
type: "text";
|
|
5515
5510
|
text: string;
|
|
5516
5511
|
textSignature?: string;
|
|
@@ -5520,8 +5515,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5520
5515
|
mimeType: string;
|
|
5521
5516
|
})[];
|
|
5522
5517
|
details?: any;
|
|
5518
|
+
isError: false;
|
|
5523
5519
|
};
|
|
5524
|
-
status: "
|
|
5520
|
+
status: "completed";
|
|
5525
5521
|
thoughtSignature?: string;
|
|
5526
5522
|
time: {
|
|
5527
5523
|
start: number;
|
|
@@ -5545,9 +5541,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5545
5541
|
mimeType: string;
|
|
5546
5542
|
})[];
|
|
5547
5543
|
details?: any;
|
|
5548
|
-
isError:
|
|
5544
|
+
isError: true;
|
|
5549
5545
|
};
|
|
5550
|
-
status: "
|
|
5546
|
+
status: "error";
|
|
5551
5547
|
thoughtSignature?: string;
|
|
5552
5548
|
time: {
|
|
5553
5549
|
start: number;
|
|
@@ -5573,7 +5569,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5573
5569
|
details?: any;
|
|
5574
5570
|
isError: true;
|
|
5575
5571
|
};
|
|
5576
|
-
status: "
|
|
5572
|
+
status: "skipped";
|
|
5577
5573
|
thoughtSignature?: string;
|
|
5578
5574
|
time: {
|
|
5579
5575
|
start: number;
|
|
@@ -5599,21 +5595,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5599
5595
|
details?: any;
|
|
5600
5596
|
isError: true;
|
|
5601
5597
|
};
|
|
5602
|
-
status: "
|
|
5598
|
+
status: "aborted";
|
|
5603
5599
|
thoughtSignature?: string;
|
|
5604
5600
|
time: {
|
|
5605
5601
|
start: number;
|
|
5606
5602
|
end: number;
|
|
5607
5603
|
};
|
|
5608
5604
|
type: "toolCall";
|
|
5605
|
+
} | {
|
|
5606
|
+
type: "thinking";
|
|
5607
|
+
thinking: string;
|
|
5608
|
+
thinkingSignature?: string;
|
|
5609
|
+
redacted?: boolean;
|
|
5609
5610
|
} | {
|
|
5610
5611
|
addedToolNames?: string[];
|
|
5611
5612
|
arguments: Record<string, any>;
|
|
5612
5613
|
callID: string;
|
|
5613
5614
|
name: string;
|
|
5614
5615
|
namespace?: string;
|
|
5615
|
-
|
|
5616
|
-
content
|
|
5616
|
+
partial?: {
|
|
5617
|
+
content?: ({
|
|
5617
5618
|
type: "text";
|
|
5618
5619
|
text: string;
|
|
5619
5620
|
textSignature?: string;
|
|
@@ -5623,9 +5624,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5623
5624
|
mimeType: string;
|
|
5624
5625
|
})[];
|
|
5625
5626
|
details?: any;
|
|
5626
|
-
isError: true;
|
|
5627
5627
|
};
|
|
5628
|
-
status: "
|
|
5628
|
+
status: "running";
|
|
5629
5629
|
thoughtSignature?: string;
|
|
5630
5630
|
time: {
|
|
5631
5631
|
start: number;
|
|
@@ -5800,19 +5800,14 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5800
5800
|
type: "image";
|
|
5801
5801
|
data: string;
|
|
5802
5802
|
mimeType: string;
|
|
5803
|
-
} | {
|
|
5804
|
-
type: "thinking";
|
|
5805
|
-
thinking: string;
|
|
5806
|
-
thinkingSignature?: string;
|
|
5807
|
-
redacted?: boolean;
|
|
5808
5803
|
} | {
|
|
5809
5804
|
addedToolNames?: string[];
|
|
5810
5805
|
arguments: Record<string, any>;
|
|
5811
5806
|
callID: string;
|
|
5812
5807
|
name: string;
|
|
5813
5808
|
namespace?: string;
|
|
5814
|
-
|
|
5815
|
-
content
|
|
5809
|
+
result: {
|
|
5810
|
+
content: ({
|
|
5816
5811
|
type: "text";
|
|
5817
5812
|
text: string;
|
|
5818
5813
|
textSignature?: string;
|
|
@@ -5822,8 +5817,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5822
5817
|
mimeType: string;
|
|
5823
5818
|
})[];
|
|
5824
5819
|
details?: any;
|
|
5820
|
+
isError: false;
|
|
5825
5821
|
};
|
|
5826
|
-
status: "
|
|
5822
|
+
status: "completed";
|
|
5827
5823
|
thoughtSignature?: string;
|
|
5828
5824
|
time: {
|
|
5829
5825
|
start: number;
|
|
@@ -5847,9 +5843,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5847
5843
|
mimeType: string;
|
|
5848
5844
|
})[];
|
|
5849
5845
|
details?: any;
|
|
5850
|
-
isError:
|
|
5846
|
+
isError: true;
|
|
5851
5847
|
};
|
|
5852
|
-
status: "
|
|
5848
|
+
status: "error";
|
|
5853
5849
|
thoughtSignature?: string;
|
|
5854
5850
|
time: {
|
|
5855
5851
|
start: number;
|
|
@@ -5875,7 +5871,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5875
5871
|
details?: any;
|
|
5876
5872
|
isError: true;
|
|
5877
5873
|
};
|
|
5878
|
-
status: "
|
|
5874
|
+
status: "skipped";
|
|
5879
5875
|
thoughtSignature?: string;
|
|
5880
5876
|
time: {
|
|
5881
5877
|
start: number;
|
|
@@ -5901,21 +5897,26 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5901
5897
|
details?: any;
|
|
5902
5898
|
isError: true;
|
|
5903
5899
|
};
|
|
5904
|
-
status: "
|
|
5900
|
+
status: "aborted";
|
|
5905
5901
|
thoughtSignature?: string;
|
|
5906
5902
|
time: {
|
|
5907
5903
|
start: number;
|
|
5908
5904
|
end: number;
|
|
5909
5905
|
};
|
|
5910
5906
|
type: "toolCall";
|
|
5907
|
+
} | {
|
|
5908
|
+
type: "thinking";
|
|
5909
|
+
thinking: string;
|
|
5910
|
+
thinkingSignature?: string;
|
|
5911
|
+
redacted?: boolean;
|
|
5911
5912
|
} | {
|
|
5912
5913
|
addedToolNames?: string[];
|
|
5913
5914
|
arguments: Record<string, any>;
|
|
5914
5915
|
callID: string;
|
|
5915
5916
|
name: string;
|
|
5916
5917
|
namespace?: string;
|
|
5917
|
-
|
|
5918
|
-
content
|
|
5918
|
+
partial?: {
|
|
5919
|
+
content?: ({
|
|
5919
5920
|
type: "text";
|
|
5920
5921
|
text: string;
|
|
5921
5922
|
textSignature?: string;
|
|
@@ -5925,9 +5926,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5925
5926
|
mimeType: string;
|
|
5926
5927
|
})[];
|
|
5927
5928
|
details?: any;
|
|
5928
|
-
isError: true;
|
|
5929
5929
|
};
|
|
5930
|
-
status: "
|
|
5930
|
+
status: "running";
|
|
5931
5931
|
thoughtSignature?: string;
|
|
5932
5932
|
time: {
|
|
5933
5933
|
start: number;
|
|
@@ -6423,19 +6423,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6423
6423
|
type: "image";
|
|
6424
6424
|
data: string;
|
|
6425
6425
|
mimeType: string;
|
|
6426
|
-
} | {
|
|
6427
|
-
type: "thinking";
|
|
6428
|
-
thinking: string;
|
|
6429
|
-
thinkingSignature?: string;
|
|
6430
|
-
redacted?: boolean;
|
|
6431
6426
|
} | {
|
|
6432
6427
|
addedToolNames?: string[];
|
|
6433
6428
|
arguments: Record<string, any>;
|
|
6434
6429
|
callID: string;
|
|
6435
6430
|
name: string;
|
|
6436
6431
|
namespace?: string;
|
|
6437
|
-
|
|
6438
|
-
content
|
|
6432
|
+
result: {
|
|
6433
|
+
content: ({
|
|
6439
6434
|
type: "text";
|
|
6440
6435
|
text: string;
|
|
6441
6436
|
textSignature?: string;
|
|
@@ -6445,8 +6440,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6445
6440
|
mimeType: string;
|
|
6446
6441
|
})[];
|
|
6447
6442
|
details?: any;
|
|
6443
|
+
isError: false;
|
|
6448
6444
|
};
|
|
6449
|
-
status: "
|
|
6445
|
+
status: "completed";
|
|
6450
6446
|
thoughtSignature?: string;
|
|
6451
6447
|
time: {
|
|
6452
6448
|
start: number;
|
|
@@ -6470,9 +6466,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6470
6466
|
mimeType: string;
|
|
6471
6467
|
})[];
|
|
6472
6468
|
details?: any;
|
|
6473
|
-
isError:
|
|
6469
|
+
isError: true;
|
|
6474
6470
|
};
|
|
6475
|
-
status: "
|
|
6471
|
+
status: "error";
|
|
6476
6472
|
thoughtSignature?: string;
|
|
6477
6473
|
time: {
|
|
6478
6474
|
start: number;
|
|
@@ -6498,7 +6494,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6498
6494
|
details?: any;
|
|
6499
6495
|
isError: true;
|
|
6500
6496
|
};
|
|
6501
|
-
status: "
|
|
6497
|
+
status: "skipped";
|
|
6502
6498
|
thoughtSignature?: string;
|
|
6503
6499
|
time: {
|
|
6504
6500
|
start: number;
|
|
@@ -6524,7 +6520,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6524
6520
|
details?: any;
|
|
6525
6521
|
isError: true;
|
|
6526
6522
|
};
|
|
6527
|
-
status: "
|
|
6523
|
+
status: "aborted";
|
|
6528
6524
|
thoughtSignature?: string;
|
|
6529
6525
|
time: {
|
|
6530
6526
|
start: number;
|
|
@@ -6532,13 +6528,18 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6532
6528
|
};
|
|
6533
6529
|
type: "toolCall";
|
|
6534
6530
|
} | {
|
|
6535
|
-
|
|
6536
|
-
|
|
6537
|
-
|
|
6538
|
-
|
|
6531
|
+
type: "thinking";
|
|
6532
|
+
thinking: string;
|
|
6533
|
+
thinkingSignature?: string;
|
|
6534
|
+
redacted?: boolean;
|
|
6535
|
+
} | {
|
|
6536
|
+
addedToolNames?: string[];
|
|
6537
|
+
arguments: Record<string, any>;
|
|
6538
|
+
callID: string;
|
|
6539
|
+
name: string;
|
|
6539
6540
|
namespace?: string;
|
|
6540
|
-
|
|
6541
|
-
content
|
|
6541
|
+
partial?: {
|
|
6542
|
+
content?: ({
|
|
6542
6543
|
type: "text";
|
|
6543
6544
|
text: string;
|
|
6544
6545
|
textSignature?: string;
|
|
@@ -6548,9 +6549,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6548
6549
|
mimeType: string;
|
|
6549
6550
|
})[];
|
|
6550
6551
|
details?: any;
|
|
6551
|
-
isError: true;
|
|
6552
6552
|
};
|
|
6553
|
-
status: "
|
|
6553
|
+
status: "running";
|
|
6554
6554
|
thoughtSignature?: string;
|
|
6555
6555
|
time: {
|
|
6556
6556
|
start: number;
|
|
@@ -6725,19 +6725,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6725
6725
|
type: "image";
|
|
6726
6726
|
data: string;
|
|
6727
6727
|
mimeType: string;
|
|
6728
|
-
} | {
|
|
6729
|
-
type: "thinking";
|
|
6730
|
-
thinking: string;
|
|
6731
|
-
thinkingSignature?: string;
|
|
6732
|
-
redacted?: boolean;
|
|
6733
6728
|
} | {
|
|
6734
6729
|
addedToolNames?: string[];
|
|
6735
6730
|
arguments: Record<string, any>;
|
|
6736
6731
|
callID: string;
|
|
6737
6732
|
name: string;
|
|
6738
6733
|
namespace?: string;
|
|
6739
|
-
|
|
6740
|
-
content
|
|
6734
|
+
result: {
|
|
6735
|
+
content: ({
|
|
6741
6736
|
type: "text";
|
|
6742
6737
|
text: string;
|
|
6743
6738
|
textSignature?: string;
|
|
@@ -6747,8 +6742,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6747
6742
|
mimeType: string;
|
|
6748
6743
|
})[];
|
|
6749
6744
|
details?: any;
|
|
6745
|
+
isError: false;
|
|
6750
6746
|
};
|
|
6751
|
-
status: "
|
|
6747
|
+
status: "completed";
|
|
6752
6748
|
thoughtSignature?: string;
|
|
6753
6749
|
time: {
|
|
6754
6750
|
start: number;
|
|
@@ -6772,9 +6768,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6772
6768
|
mimeType: string;
|
|
6773
6769
|
})[];
|
|
6774
6770
|
details?: any;
|
|
6775
|
-
isError:
|
|
6771
|
+
isError: true;
|
|
6776
6772
|
};
|
|
6777
|
-
status: "
|
|
6773
|
+
status: "error";
|
|
6778
6774
|
thoughtSignature?: string;
|
|
6779
6775
|
time: {
|
|
6780
6776
|
start: number;
|
|
@@ -6800,7 +6796,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6800
6796
|
details?: any;
|
|
6801
6797
|
isError: true;
|
|
6802
6798
|
};
|
|
6803
|
-
status: "
|
|
6799
|
+
status: "skipped";
|
|
6804
6800
|
thoughtSignature?: string;
|
|
6805
6801
|
time: {
|
|
6806
6802
|
start: number;
|
|
@@ -6826,21 +6822,26 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6826
6822
|
details?: any;
|
|
6827
6823
|
isError: true;
|
|
6828
6824
|
};
|
|
6829
|
-
status: "
|
|
6825
|
+
status: "aborted";
|
|
6830
6826
|
thoughtSignature?: string;
|
|
6831
6827
|
time: {
|
|
6832
6828
|
start: number;
|
|
6833
6829
|
end: number;
|
|
6834
6830
|
};
|
|
6835
6831
|
type: "toolCall";
|
|
6832
|
+
} | {
|
|
6833
|
+
type: "thinking";
|
|
6834
|
+
thinking: string;
|
|
6835
|
+
thinkingSignature?: string;
|
|
6836
|
+
redacted?: boolean;
|
|
6836
6837
|
} | {
|
|
6837
6838
|
addedToolNames?: string[];
|
|
6838
6839
|
arguments: Record<string, any>;
|
|
6839
6840
|
callID: string;
|
|
6840
6841
|
name: string;
|
|
6841
6842
|
namespace?: string;
|
|
6842
|
-
|
|
6843
|
-
content
|
|
6843
|
+
partial?: {
|
|
6844
|
+
content?: ({
|
|
6844
6845
|
type: "text";
|
|
6845
6846
|
text: string;
|
|
6846
6847
|
textSignature?: string;
|
|
@@ -6850,9 +6851,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6850
6851
|
mimeType: string;
|
|
6851
6852
|
})[];
|
|
6852
6853
|
details?: any;
|
|
6853
|
-
isError: true;
|
|
6854
6854
|
};
|
|
6855
|
-
status: "
|
|
6855
|
+
status: "running";
|
|
6856
6856
|
thoughtSignature?: string;
|
|
6857
6857
|
time: {
|
|
6858
6858
|
start: number;
|
|
@@ -7046,19 +7046,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7046
7046
|
type: "image";
|
|
7047
7047
|
data: string;
|
|
7048
7048
|
mimeType: string;
|
|
7049
|
-
} | {
|
|
7050
|
-
type: "thinking";
|
|
7051
|
-
thinking: string;
|
|
7052
|
-
thinkingSignature?: string;
|
|
7053
|
-
redacted?: boolean;
|
|
7054
7049
|
} | {
|
|
7055
7050
|
addedToolNames?: string[];
|
|
7056
7051
|
arguments: Record<string, any>;
|
|
7057
7052
|
callID: string;
|
|
7058
7053
|
name: string;
|
|
7059
7054
|
namespace?: string;
|
|
7060
|
-
|
|
7061
|
-
content
|
|
7055
|
+
result: {
|
|
7056
|
+
content: ({
|
|
7062
7057
|
type: "text";
|
|
7063
7058
|
text: string;
|
|
7064
7059
|
textSignature?: string;
|
|
@@ -7068,8 +7063,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7068
7063
|
mimeType: string;
|
|
7069
7064
|
})[];
|
|
7070
7065
|
details?: any;
|
|
7066
|
+
isError: false;
|
|
7071
7067
|
};
|
|
7072
|
-
status: "
|
|
7068
|
+
status: "completed";
|
|
7073
7069
|
thoughtSignature?: string;
|
|
7074
7070
|
time: {
|
|
7075
7071
|
start: number;
|
|
@@ -7093,9 +7089,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7093
7089
|
mimeType: string;
|
|
7094
7090
|
})[];
|
|
7095
7091
|
details?: any;
|
|
7096
|
-
isError:
|
|
7092
|
+
isError: true;
|
|
7097
7093
|
};
|
|
7098
|
-
status: "
|
|
7094
|
+
status: "error";
|
|
7099
7095
|
thoughtSignature?: string;
|
|
7100
7096
|
time: {
|
|
7101
7097
|
start: number;
|
|
@@ -7121,7 +7117,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7121
7117
|
details?: any;
|
|
7122
7118
|
isError: true;
|
|
7123
7119
|
};
|
|
7124
|
-
status: "
|
|
7120
|
+
status: "skipped";
|
|
7125
7121
|
thoughtSignature?: string;
|
|
7126
7122
|
time: {
|
|
7127
7123
|
start: number;
|
|
@@ -7147,21 +7143,26 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7147
7143
|
details?: any;
|
|
7148
7144
|
isError: true;
|
|
7149
7145
|
};
|
|
7150
|
-
status: "
|
|
7146
|
+
status: "aborted";
|
|
7151
7147
|
thoughtSignature?: string;
|
|
7152
7148
|
time: {
|
|
7153
7149
|
start: number;
|
|
7154
7150
|
end: number;
|
|
7155
7151
|
};
|
|
7156
7152
|
type: "toolCall";
|
|
7153
|
+
} | {
|
|
7154
|
+
type: "thinking";
|
|
7155
|
+
thinking: string;
|
|
7156
|
+
thinkingSignature?: string;
|
|
7157
|
+
redacted?: boolean;
|
|
7157
7158
|
} | {
|
|
7158
7159
|
addedToolNames?: string[];
|
|
7159
7160
|
arguments: Record<string, any>;
|
|
7160
7161
|
callID: string;
|
|
7161
7162
|
name: string;
|
|
7162
7163
|
namespace?: string;
|
|
7163
|
-
|
|
7164
|
-
content
|
|
7164
|
+
partial?: {
|
|
7165
|
+
content?: ({
|
|
7165
7166
|
type: "text";
|
|
7166
7167
|
text: string;
|
|
7167
7168
|
textSignature?: string;
|
|
@@ -7171,9 +7172,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7171
7172
|
mimeType: string;
|
|
7172
7173
|
})[];
|
|
7173
7174
|
details?: any;
|
|
7174
|
-
isError: true;
|
|
7175
7175
|
};
|
|
7176
|
-
status: "
|
|
7176
|
+
status: "running";
|
|
7177
7177
|
thoughtSignature?: string;
|
|
7178
7178
|
time: {
|
|
7179
7179
|
start: number;
|
|
@@ -7348,19 +7348,14 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7348
7348
|
type: "image";
|
|
7349
7349
|
data: string;
|
|
7350
7350
|
mimeType: string;
|
|
7351
|
-
} | {
|
|
7352
|
-
type: "thinking";
|
|
7353
|
-
thinking: string;
|
|
7354
|
-
thinkingSignature?: string;
|
|
7355
|
-
redacted?: boolean;
|
|
7356
7351
|
} | {
|
|
7357
7352
|
addedToolNames?: string[];
|
|
7358
7353
|
arguments: Record<string, any>;
|
|
7359
7354
|
callID: string;
|
|
7360
7355
|
name: string;
|
|
7361
7356
|
namespace?: string;
|
|
7362
|
-
|
|
7363
|
-
content
|
|
7357
|
+
result: {
|
|
7358
|
+
content: ({
|
|
7364
7359
|
type: "text";
|
|
7365
7360
|
text: string;
|
|
7366
7361
|
textSignature?: string;
|
|
@@ -7370,8 +7365,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7370
7365
|
mimeType: string;
|
|
7371
7366
|
})[];
|
|
7372
7367
|
details?: any;
|
|
7368
|
+
isError: false;
|
|
7373
7369
|
};
|
|
7374
|
-
status: "
|
|
7370
|
+
status: "completed";
|
|
7375
7371
|
thoughtSignature?: string;
|
|
7376
7372
|
time: {
|
|
7377
7373
|
start: number;
|
|
@@ -7395,9 +7391,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7395
7391
|
mimeType: string;
|
|
7396
7392
|
})[];
|
|
7397
7393
|
details?: any;
|
|
7398
|
-
isError:
|
|
7394
|
+
isError: true;
|
|
7399
7395
|
};
|
|
7400
|
-
status: "
|
|
7396
|
+
status: "error";
|
|
7401
7397
|
thoughtSignature?: string;
|
|
7402
7398
|
time: {
|
|
7403
7399
|
start: number;
|
|
@@ -7423,7 +7419,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7423
7419
|
details?: any;
|
|
7424
7420
|
isError: true;
|
|
7425
7421
|
};
|
|
7426
|
-
status: "
|
|
7422
|
+
status: "skipped";
|
|
7427
7423
|
thoughtSignature?: string;
|
|
7428
7424
|
time: {
|
|
7429
7425
|
start: number;
|
|
@@ -7449,21 +7445,26 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7449
7445
|
details?: any;
|
|
7450
7446
|
isError: true;
|
|
7451
7447
|
};
|
|
7452
|
-
status: "
|
|
7448
|
+
status: "aborted";
|
|
7453
7449
|
thoughtSignature?: string;
|
|
7454
7450
|
time: {
|
|
7455
7451
|
start: number;
|
|
7456
7452
|
end: number;
|
|
7457
7453
|
};
|
|
7458
7454
|
type: "toolCall";
|
|
7455
|
+
} | {
|
|
7456
|
+
type: "thinking";
|
|
7457
|
+
thinking: string;
|
|
7458
|
+
thinkingSignature?: string;
|
|
7459
|
+
redacted?: boolean;
|
|
7459
7460
|
} | {
|
|
7460
7461
|
addedToolNames?: string[];
|
|
7461
7462
|
arguments: Record<string, any>;
|
|
7462
7463
|
callID: string;
|
|
7463
7464
|
name: string;
|
|
7464
7465
|
namespace?: string;
|
|
7465
|
-
|
|
7466
|
-
content
|
|
7466
|
+
partial?: {
|
|
7467
|
+
content?: ({
|
|
7467
7468
|
type: "text";
|
|
7468
7469
|
text: string;
|
|
7469
7470
|
textSignature?: string;
|
|
@@ -7473,9 +7474,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7473
7474
|
mimeType: string;
|
|
7474
7475
|
})[];
|
|
7475
7476
|
details?: any;
|
|
7476
|
-
isError: true;
|
|
7477
7477
|
};
|
|
7478
|
-
status: "
|
|
7478
|
+
status: "running";
|
|
7479
7479
|
thoughtSignature?: string;
|
|
7480
7480
|
time: {
|
|
7481
7481
|
start: number;
|
|
@@ -7681,19 +7681,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7681
7681
|
type: "image";
|
|
7682
7682
|
data: string;
|
|
7683
7683
|
mimeType: string;
|
|
7684
|
-
} | {
|
|
7685
|
-
type: "thinking";
|
|
7686
|
-
thinking: string;
|
|
7687
|
-
thinkingSignature?: string;
|
|
7688
|
-
redacted?: boolean;
|
|
7689
7684
|
} | {
|
|
7690
7685
|
addedToolNames?: string[];
|
|
7691
7686
|
arguments: Record<string, any>;
|
|
7692
7687
|
callID: string;
|
|
7693
7688
|
name: string;
|
|
7694
7689
|
namespace?: string;
|
|
7695
|
-
|
|
7696
|
-
content
|
|
7690
|
+
result: {
|
|
7691
|
+
content: ({
|
|
7697
7692
|
type: "text";
|
|
7698
7693
|
text: string;
|
|
7699
7694
|
textSignature?: string;
|
|
@@ -7703,8 +7698,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7703
7698
|
mimeType: string;
|
|
7704
7699
|
})[];
|
|
7705
7700
|
details?: any;
|
|
7701
|
+
isError: false;
|
|
7706
7702
|
};
|
|
7707
|
-
status: "
|
|
7703
|
+
status: "completed";
|
|
7708
7704
|
thoughtSignature?: string;
|
|
7709
7705
|
time: {
|
|
7710
7706
|
start: number;
|
|
@@ -7728,9 +7724,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7728
7724
|
mimeType: string;
|
|
7729
7725
|
})[];
|
|
7730
7726
|
details?: any;
|
|
7731
|
-
isError:
|
|
7727
|
+
isError: true;
|
|
7732
7728
|
};
|
|
7733
|
-
status: "
|
|
7729
|
+
status: "error";
|
|
7734
7730
|
thoughtSignature?: string;
|
|
7735
7731
|
time: {
|
|
7736
7732
|
start: number;
|
|
@@ -7756,7 +7752,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7756
7752
|
details?: any;
|
|
7757
7753
|
isError: true;
|
|
7758
7754
|
};
|
|
7759
|
-
status: "
|
|
7755
|
+
status: "skipped";
|
|
7760
7756
|
thoughtSignature?: string;
|
|
7761
7757
|
time: {
|
|
7762
7758
|
start: number;
|
|
@@ -7782,21 +7778,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7782
7778
|
details?: any;
|
|
7783
7779
|
isError: true;
|
|
7784
7780
|
};
|
|
7785
|
-
status: "
|
|
7781
|
+
status: "aborted";
|
|
7786
7782
|
thoughtSignature?: string;
|
|
7787
7783
|
time: {
|
|
7788
7784
|
start: number;
|
|
7789
7785
|
end: number;
|
|
7790
7786
|
};
|
|
7791
7787
|
type: "toolCall";
|
|
7788
|
+
} | {
|
|
7789
|
+
type: "thinking";
|
|
7790
|
+
thinking: string;
|
|
7791
|
+
thinkingSignature?: string;
|
|
7792
|
+
redacted?: boolean;
|
|
7792
7793
|
} | {
|
|
7793
7794
|
addedToolNames?: string[];
|
|
7794
7795
|
arguments: Record<string, any>;
|
|
7795
7796
|
callID: string;
|
|
7796
7797
|
name: string;
|
|
7797
7798
|
namespace?: string;
|
|
7798
|
-
|
|
7799
|
-
content
|
|
7799
|
+
partial?: {
|
|
7800
|
+
content?: ({
|
|
7800
7801
|
type: "text";
|
|
7801
7802
|
text: string;
|
|
7802
7803
|
textSignature?: string;
|
|
@@ -7806,9 +7807,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7806
7807
|
mimeType: string;
|
|
7807
7808
|
})[];
|
|
7808
7809
|
details?: any;
|
|
7809
|
-
isError: true;
|
|
7810
7810
|
};
|
|
7811
|
-
status: "
|
|
7811
|
+
status: "running";
|
|
7812
7812
|
thoughtSignature?: string;
|
|
7813
7813
|
time: {
|
|
7814
7814
|
start: number;
|
|
@@ -7983,19 +7983,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7983
7983
|
type: "image";
|
|
7984
7984
|
data: string;
|
|
7985
7985
|
mimeType: string;
|
|
7986
|
-
} | {
|
|
7987
|
-
type: "thinking";
|
|
7988
|
-
thinking: string;
|
|
7989
|
-
thinkingSignature?: string;
|
|
7990
|
-
redacted?: boolean;
|
|
7991
7986
|
} | {
|
|
7992
7987
|
addedToolNames?: string[];
|
|
7993
7988
|
arguments: Record<string, any>;
|
|
7994
7989
|
callID: string;
|
|
7995
7990
|
name: string;
|
|
7996
7991
|
namespace?: string;
|
|
7997
|
-
|
|
7998
|
-
content
|
|
7992
|
+
result: {
|
|
7993
|
+
content: ({
|
|
7999
7994
|
type: "text";
|
|
8000
7995
|
text: string;
|
|
8001
7996
|
textSignature?: string;
|
|
@@ -8005,8 +8000,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8005
8000
|
mimeType: string;
|
|
8006
8001
|
})[];
|
|
8007
8002
|
details?: any;
|
|
8003
|
+
isError: false;
|
|
8008
8004
|
};
|
|
8009
|
-
status: "
|
|
8005
|
+
status: "completed";
|
|
8010
8006
|
thoughtSignature?: string;
|
|
8011
8007
|
time: {
|
|
8012
8008
|
start: number;
|
|
@@ -8030,9 +8026,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8030
8026
|
mimeType: string;
|
|
8031
8027
|
})[];
|
|
8032
8028
|
details?: any;
|
|
8033
|
-
isError:
|
|
8029
|
+
isError: true;
|
|
8034
8030
|
};
|
|
8035
|
-
status: "
|
|
8031
|
+
status: "error";
|
|
8036
8032
|
thoughtSignature?: string;
|
|
8037
8033
|
time: {
|
|
8038
8034
|
start: number;
|
|
@@ -8058,7 +8054,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8058
8054
|
details?: any;
|
|
8059
8055
|
isError: true;
|
|
8060
8056
|
};
|
|
8061
|
-
status: "
|
|
8057
|
+
status: "skipped";
|
|
8062
8058
|
thoughtSignature?: string;
|
|
8063
8059
|
time: {
|
|
8064
8060
|
start: number;
|
|
@@ -8084,21 +8080,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8084
8080
|
details?: any;
|
|
8085
8081
|
isError: true;
|
|
8086
8082
|
};
|
|
8087
|
-
status: "
|
|
8083
|
+
status: "aborted";
|
|
8088
8084
|
thoughtSignature?: string;
|
|
8089
8085
|
time: {
|
|
8090
8086
|
start: number;
|
|
8091
8087
|
end: number;
|
|
8092
8088
|
};
|
|
8093
8089
|
type: "toolCall";
|
|
8090
|
+
} | {
|
|
8091
|
+
type: "thinking";
|
|
8092
|
+
thinking: string;
|
|
8093
|
+
thinkingSignature?: string;
|
|
8094
|
+
redacted?: boolean;
|
|
8094
8095
|
} | {
|
|
8095
8096
|
addedToolNames?: string[];
|
|
8096
8097
|
arguments: Record<string, any>;
|
|
8097
8098
|
callID: string;
|
|
8098
8099
|
name: string;
|
|
8099
8100
|
namespace?: string;
|
|
8100
|
-
|
|
8101
|
-
content
|
|
8101
|
+
partial?: {
|
|
8102
|
+
content?: ({
|
|
8102
8103
|
type: "text";
|
|
8103
8104
|
text: string;
|
|
8104
8105
|
textSignature?: string;
|
|
@@ -8108,9 +8109,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8108
8109
|
mimeType: string;
|
|
8109
8110
|
})[];
|
|
8110
8111
|
details?: any;
|
|
8111
|
-
isError: true;
|
|
8112
8112
|
};
|
|
8113
|
-
status: "
|
|
8113
|
+
status: "running";
|
|
8114
8114
|
thoughtSignature?: string;
|
|
8115
8115
|
time: {
|
|
8116
8116
|
start: number;
|
|
@@ -8304,19 +8304,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8304
8304
|
type: "image";
|
|
8305
8305
|
data: string;
|
|
8306
8306
|
mimeType: string;
|
|
8307
|
-
} | {
|
|
8308
|
-
type: "thinking";
|
|
8309
|
-
thinking: string;
|
|
8310
|
-
thinkingSignature?: string;
|
|
8311
|
-
redacted?: boolean;
|
|
8312
8307
|
} | {
|
|
8313
8308
|
addedToolNames?: string[];
|
|
8314
8309
|
arguments: Record<string, any>;
|
|
8315
8310
|
callID: string;
|
|
8316
8311
|
name: string;
|
|
8317
8312
|
namespace?: string;
|
|
8318
|
-
|
|
8319
|
-
content
|
|
8313
|
+
result: {
|
|
8314
|
+
content: ({
|
|
8320
8315
|
type: "text";
|
|
8321
8316
|
text: string;
|
|
8322
8317
|
textSignature?: string;
|
|
@@ -8326,8 +8321,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8326
8321
|
mimeType: string;
|
|
8327
8322
|
})[];
|
|
8328
8323
|
details?: any;
|
|
8324
|
+
isError: false;
|
|
8329
8325
|
};
|
|
8330
|
-
status: "
|
|
8326
|
+
status: "completed";
|
|
8331
8327
|
thoughtSignature?: string;
|
|
8332
8328
|
time: {
|
|
8333
8329
|
start: number;
|
|
@@ -8351,9 +8347,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8351
8347
|
mimeType: string;
|
|
8352
8348
|
})[];
|
|
8353
8349
|
details?: any;
|
|
8354
|
-
isError:
|
|
8350
|
+
isError: true;
|
|
8355
8351
|
};
|
|
8356
|
-
status: "
|
|
8352
|
+
status: "error";
|
|
8357
8353
|
thoughtSignature?: string;
|
|
8358
8354
|
time: {
|
|
8359
8355
|
start: number;
|
|
@@ -8379,7 +8375,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8379
8375
|
details?: any;
|
|
8380
8376
|
isError: true;
|
|
8381
8377
|
};
|
|
8382
|
-
status: "
|
|
8378
|
+
status: "skipped";
|
|
8383
8379
|
thoughtSignature?: string;
|
|
8384
8380
|
time: {
|
|
8385
8381
|
start: number;
|
|
@@ -8405,21 +8401,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8405
8401
|
details?: any;
|
|
8406
8402
|
isError: true;
|
|
8407
8403
|
};
|
|
8408
|
-
status: "
|
|
8404
|
+
status: "aborted";
|
|
8409
8405
|
thoughtSignature?: string;
|
|
8410
8406
|
time: {
|
|
8411
8407
|
start: number;
|
|
8412
8408
|
end: number;
|
|
8413
8409
|
};
|
|
8414
8410
|
type: "toolCall";
|
|
8411
|
+
} | {
|
|
8412
|
+
type: "thinking";
|
|
8413
|
+
thinking: string;
|
|
8414
|
+
thinkingSignature?: string;
|
|
8415
|
+
redacted?: boolean;
|
|
8415
8416
|
} | {
|
|
8416
8417
|
addedToolNames?: string[];
|
|
8417
8418
|
arguments: Record<string, any>;
|
|
8418
8419
|
callID: string;
|
|
8419
8420
|
name: string;
|
|
8420
8421
|
namespace?: string;
|
|
8421
|
-
|
|
8422
|
-
content
|
|
8422
|
+
partial?: {
|
|
8423
|
+
content?: ({
|
|
8423
8424
|
type: "text";
|
|
8424
8425
|
text: string;
|
|
8425
8426
|
textSignature?: string;
|
|
@@ -8429,9 +8430,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8429
8430
|
mimeType: string;
|
|
8430
8431
|
})[];
|
|
8431
8432
|
details?: any;
|
|
8432
|
-
isError: true;
|
|
8433
8433
|
};
|
|
8434
|
-
status: "
|
|
8434
|
+
status: "running";
|
|
8435
8435
|
thoughtSignature?: string;
|
|
8436
8436
|
time: {
|
|
8437
8437
|
start: number;
|
|
@@ -8606,19 +8606,14 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8606
8606
|
type: "image";
|
|
8607
8607
|
data: string;
|
|
8608
8608
|
mimeType: string;
|
|
8609
|
-
} | {
|
|
8610
|
-
type: "thinking";
|
|
8611
|
-
thinking: string;
|
|
8612
|
-
thinkingSignature?: string;
|
|
8613
|
-
redacted?: boolean;
|
|
8614
8609
|
} | {
|
|
8615
8610
|
addedToolNames?: string[];
|
|
8616
8611
|
arguments: Record<string, any>;
|
|
8617
8612
|
callID: string;
|
|
8618
8613
|
name: string;
|
|
8619
8614
|
namespace?: string;
|
|
8620
|
-
|
|
8621
|
-
content
|
|
8615
|
+
result: {
|
|
8616
|
+
content: ({
|
|
8622
8617
|
type: "text";
|
|
8623
8618
|
text: string;
|
|
8624
8619
|
textSignature?: string;
|
|
@@ -8628,8 +8623,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8628
8623
|
mimeType: string;
|
|
8629
8624
|
})[];
|
|
8630
8625
|
details?: any;
|
|
8626
|
+
isError: false;
|
|
8631
8627
|
};
|
|
8632
|
-
status: "
|
|
8628
|
+
status: "completed";
|
|
8633
8629
|
thoughtSignature?: string;
|
|
8634
8630
|
time: {
|
|
8635
8631
|
start: number;
|
|
@@ -8653,9 +8649,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8653
8649
|
mimeType: string;
|
|
8654
8650
|
})[];
|
|
8655
8651
|
details?: any;
|
|
8656
|
-
isError:
|
|
8652
|
+
isError: true;
|
|
8657
8653
|
};
|
|
8658
|
-
status: "
|
|
8654
|
+
status: "error";
|
|
8659
8655
|
thoughtSignature?: string;
|
|
8660
8656
|
time: {
|
|
8661
8657
|
start: number;
|
|
@@ -8681,7 +8677,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8681
8677
|
details?: any;
|
|
8682
8678
|
isError: true;
|
|
8683
8679
|
};
|
|
8684
|
-
status: "
|
|
8680
|
+
status: "skipped";
|
|
8685
8681
|
thoughtSignature?: string;
|
|
8686
8682
|
time: {
|
|
8687
8683
|
start: number;
|
|
@@ -8707,21 +8703,26 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8707
8703
|
details?: any;
|
|
8708
8704
|
isError: true;
|
|
8709
8705
|
};
|
|
8710
|
-
status: "
|
|
8706
|
+
status: "aborted";
|
|
8711
8707
|
thoughtSignature?: string;
|
|
8712
8708
|
time: {
|
|
8713
8709
|
start: number;
|
|
8714
8710
|
end: number;
|
|
8715
8711
|
};
|
|
8716
8712
|
type: "toolCall";
|
|
8713
|
+
} | {
|
|
8714
|
+
type: "thinking";
|
|
8715
|
+
thinking: string;
|
|
8716
|
+
thinkingSignature?: string;
|
|
8717
|
+
redacted?: boolean;
|
|
8717
8718
|
} | {
|
|
8718
8719
|
addedToolNames?: string[];
|
|
8719
8720
|
arguments: Record<string, any>;
|
|
8720
8721
|
callID: string;
|
|
8721
8722
|
name: string;
|
|
8722
8723
|
namespace?: string;
|
|
8723
|
-
|
|
8724
|
-
content
|
|
8724
|
+
partial?: {
|
|
8725
|
+
content?: ({
|
|
8725
8726
|
type: "text";
|
|
8726
8727
|
text: string;
|
|
8727
8728
|
textSignature?: string;
|
|
@@ -8731,9 +8732,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8731
8732
|
mimeType: string;
|
|
8732
8733
|
})[];
|
|
8733
8734
|
details?: any;
|
|
8734
|
-
isError: true;
|
|
8735
8735
|
};
|
|
8736
|
-
status: "
|
|
8736
|
+
status: "running";
|
|
8737
8737
|
thoughtSignature?: string;
|
|
8738
8738
|
time: {
|
|
8739
8739
|
start: number;
|
|
@@ -10481,19 +10481,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10481
10481
|
type: "image";
|
|
10482
10482
|
data: string;
|
|
10483
10483
|
mimeType: string;
|
|
10484
|
-
} | {
|
|
10485
|
-
type: "thinking";
|
|
10486
|
-
thinking: string;
|
|
10487
|
-
thinkingSignature?: string;
|
|
10488
|
-
redacted?: boolean;
|
|
10489
10484
|
} | {
|
|
10490
10485
|
addedToolNames?: string[];
|
|
10491
10486
|
arguments: Record<string, any>;
|
|
10492
10487
|
callID: string;
|
|
10493
10488
|
name: string;
|
|
10494
10489
|
namespace?: string;
|
|
10495
|
-
|
|
10496
|
-
content
|
|
10490
|
+
result: {
|
|
10491
|
+
content: ({
|
|
10497
10492
|
type: "text";
|
|
10498
10493
|
text: string;
|
|
10499
10494
|
textSignature?: string;
|
|
@@ -10503,8 +10498,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10503
10498
|
mimeType: string;
|
|
10504
10499
|
})[];
|
|
10505
10500
|
details?: any;
|
|
10501
|
+
isError: false;
|
|
10506
10502
|
};
|
|
10507
|
-
status: "
|
|
10503
|
+
status: "completed";
|
|
10508
10504
|
thoughtSignature?: string;
|
|
10509
10505
|
time: {
|
|
10510
10506
|
start: number;
|
|
@@ -10528,9 +10524,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10528
10524
|
mimeType: string;
|
|
10529
10525
|
})[];
|
|
10530
10526
|
details?: any;
|
|
10531
|
-
isError:
|
|
10527
|
+
isError: true;
|
|
10532
10528
|
};
|
|
10533
|
-
status: "
|
|
10529
|
+
status: "error";
|
|
10534
10530
|
thoughtSignature?: string;
|
|
10535
10531
|
time: {
|
|
10536
10532
|
start: number;
|
|
@@ -10556,7 +10552,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10556
10552
|
details?: any;
|
|
10557
10553
|
isError: true;
|
|
10558
10554
|
};
|
|
10559
|
-
status: "
|
|
10555
|
+
status: "skipped";
|
|
10560
10556
|
thoughtSignature?: string;
|
|
10561
10557
|
time: {
|
|
10562
10558
|
start: number;
|
|
@@ -10582,21 +10578,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10582
10578
|
details?: any;
|
|
10583
10579
|
isError: true;
|
|
10584
10580
|
};
|
|
10585
|
-
status: "
|
|
10581
|
+
status: "aborted";
|
|
10586
10582
|
thoughtSignature?: string;
|
|
10587
10583
|
time: {
|
|
10588
10584
|
start: number;
|
|
10589
10585
|
end: number;
|
|
10590
10586
|
};
|
|
10591
10587
|
type: "toolCall";
|
|
10588
|
+
} | {
|
|
10589
|
+
type: "thinking";
|
|
10590
|
+
thinking: string;
|
|
10591
|
+
thinkingSignature?: string;
|
|
10592
|
+
redacted?: boolean;
|
|
10592
10593
|
} | {
|
|
10593
10594
|
addedToolNames?: string[];
|
|
10594
10595
|
arguments: Record<string, any>;
|
|
10595
10596
|
callID: string;
|
|
10596
10597
|
name: string;
|
|
10597
10598
|
namespace?: string;
|
|
10598
|
-
|
|
10599
|
-
content
|
|
10599
|
+
partial?: {
|
|
10600
|
+
content?: ({
|
|
10600
10601
|
type: "text";
|
|
10601
10602
|
text: string;
|
|
10602
10603
|
textSignature?: string;
|
|
@@ -10606,9 +10607,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10606
10607
|
mimeType: string;
|
|
10607
10608
|
})[];
|
|
10608
10609
|
details?: any;
|
|
10609
|
-
isError: true;
|
|
10610
10610
|
};
|
|
10611
|
-
status: "
|
|
10611
|
+
status: "running";
|
|
10612
10612
|
thoughtSignature?: string;
|
|
10613
10613
|
time: {
|
|
10614
10614
|
start: number;
|
|
@@ -10783,19 +10783,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10783
10783
|
type: "image";
|
|
10784
10784
|
data: string;
|
|
10785
10785
|
mimeType: string;
|
|
10786
|
-
} | {
|
|
10787
|
-
type: "thinking";
|
|
10788
|
-
thinking: string;
|
|
10789
|
-
thinkingSignature?: string;
|
|
10790
|
-
redacted?: boolean;
|
|
10791
10786
|
} | {
|
|
10792
10787
|
addedToolNames?: string[];
|
|
10793
10788
|
arguments: Record<string, any>;
|
|
10794
10789
|
callID: string;
|
|
10795
10790
|
name: string;
|
|
10796
10791
|
namespace?: string;
|
|
10797
|
-
|
|
10798
|
-
content
|
|
10792
|
+
result: {
|
|
10793
|
+
content: ({
|
|
10799
10794
|
type: "text";
|
|
10800
10795
|
text: string;
|
|
10801
10796
|
textSignature?: string;
|
|
@@ -10805,8 +10800,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10805
10800
|
mimeType: string;
|
|
10806
10801
|
})[];
|
|
10807
10802
|
details?: any;
|
|
10803
|
+
isError: false;
|
|
10808
10804
|
};
|
|
10809
|
-
status: "
|
|
10805
|
+
status: "completed";
|
|
10810
10806
|
thoughtSignature?: string;
|
|
10811
10807
|
time: {
|
|
10812
10808
|
start: number;
|
|
@@ -10830,9 +10826,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10830
10826
|
mimeType: string;
|
|
10831
10827
|
})[];
|
|
10832
10828
|
details?: any;
|
|
10833
|
-
isError:
|
|
10829
|
+
isError: true;
|
|
10834
10830
|
};
|
|
10835
|
-
status: "
|
|
10831
|
+
status: "error";
|
|
10836
10832
|
thoughtSignature?: string;
|
|
10837
10833
|
time: {
|
|
10838
10834
|
start: number;
|
|
@@ -10858,7 +10854,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10858
10854
|
details?: any;
|
|
10859
10855
|
isError: true;
|
|
10860
10856
|
};
|
|
10861
|
-
status: "
|
|
10857
|
+
status: "skipped";
|
|
10862
10858
|
thoughtSignature?: string;
|
|
10863
10859
|
time: {
|
|
10864
10860
|
start: number;
|
|
@@ -10884,21 +10880,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10884
10880
|
details?: any;
|
|
10885
10881
|
isError: true;
|
|
10886
10882
|
};
|
|
10887
|
-
status: "
|
|
10883
|
+
status: "aborted";
|
|
10888
10884
|
thoughtSignature?: string;
|
|
10889
10885
|
time: {
|
|
10890
10886
|
start: number;
|
|
10891
10887
|
end: number;
|
|
10892
10888
|
};
|
|
10893
10889
|
type: "toolCall";
|
|
10890
|
+
} | {
|
|
10891
|
+
type: "thinking";
|
|
10892
|
+
thinking: string;
|
|
10893
|
+
thinkingSignature?: string;
|
|
10894
|
+
redacted?: boolean;
|
|
10894
10895
|
} | {
|
|
10895
10896
|
addedToolNames?: string[];
|
|
10896
10897
|
arguments: Record<string, any>;
|
|
10897
10898
|
callID: string;
|
|
10898
10899
|
name: string;
|
|
10899
10900
|
namespace?: string;
|
|
10900
|
-
|
|
10901
|
-
content
|
|
10901
|
+
partial?: {
|
|
10902
|
+
content?: ({
|
|
10902
10903
|
type: "text";
|
|
10903
10904
|
text: string;
|
|
10904
10905
|
textSignature?: string;
|
|
@@ -10908,9 +10909,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10908
10909
|
mimeType: string;
|
|
10909
10910
|
})[];
|
|
10910
10911
|
details?: any;
|
|
10911
|
-
isError: true;
|
|
10912
10912
|
};
|
|
10913
|
-
status: "
|
|
10913
|
+
status: "running";
|
|
10914
10914
|
thoughtSignature?: string;
|
|
10915
10915
|
time: {
|
|
10916
10916
|
start: number;
|
|
@@ -11103,19 +11103,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11103
11103
|
type: "image";
|
|
11104
11104
|
data: string;
|
|
11105
11105
|
mimeType: string;
|
|
11106
|
-
} | {
|
|
11107
|
-
type: "thinking";
|
|
11108
|
-
thinking: string;
|
|
11109
|
-
thinkingSignature?: string;
|
|
11110
|
-
redacted?: boolean;
|
|
11111
11106
|
} | {
|
|
11112
11107
|
addedToolNames?: string[];
|
|
11113
11108
|
arguments: Record<string, any>;
|
|
11114
11109
|
callID: string;
|
|
11115
11110
|
name: string;
|
|
11116
11111
|
namespace?: string;
|
|
11117
|
-
|
|
11118
|
-
content
|
|
11112
|
+
result: {
|
|
11113
|
+
content: ({
|
|
11119
11114
|
type: "text";
|
|
11120
11115
|
text: string;
|
|
11121
11116
|
textSignature?: string;
|
|
@@ -11125,8 +11120,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11125
11120
|
mimeType: string;
|
|
11126
11121
|
})[];
|
|
11127
11122
|
details?: any;
|
|
11123
|
+
isError: false;
|
|
11128
11124
|
};
|
|
11129
|
-
status: "
|
|
11125
|
+
status: "completed";
|
|
11130
11126
|
thoughtSignature?: string;
|
|
11131
11127
|
time: {
|
|
11132
11128
|
start: number;
|
|
@@ -11150,9 +11146,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11150
11146
|
mimeType: string;
|
|
11151
11147
|
})[];
|
|
11152
11148
|
details?: any;
|
|
11153
|
-
isError:
|
|
11149
|
+
isError: true;
|
|
11154
11150
|
};
|
|
11155
|
-
status: "
|
|
11151
|
+
status: "error";
|
|
11156
11152
|
thoughtSignature?: string;
|
|
11157
11153
|
time: {
|
|
11158
11154
|
start: number;
|
|
@@ -11178,7 +11174,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11178
11174
|
details?: any;
|
|
11179
11175
|
isError: true;
|
|
11180
11176
|
};
|
|
11181
|
-
status: "
|
|
11177
|
+
status: "skipped";
|
|
11182
11178
|
thoughtSignature?: string;
|
|
11183
11179
|
time: {
|
|
11184
11180
|
start: number;
|
|
@@ -11204,21 +11200,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11204
11200
|
details?: any;
|
|
11205
11201
|
isError: true;
|
|
11206
11202
|
};
|
|
11207
|
-
status: "
|
|
11203
|
+
status: "aborted";
|
|
11208
11204
|
thoughtSignature?: string;
|
|
11209
11205
|
time: {
|
|
11210
11206
|
start: number;
|
|
11211
11207
|
end: number;
|
|
11212
11208
|
};
|
|
11213
11209
|
type: "toolCall";
|
|
11210
|
+
} | {
|
|
11211
|
+
type: "thinking";
|
|
11212
|
+
thinking: string;
|
|
11213
|
+
thinkingSignature?: string;
|
|
11214
|
+
redacted?: boolean;
|
|
11214
11215
|
} | {
|
|
11215
11216
|
addedToolNames?: string[];
|
|
11216
11217
|
arguments: Record<string, any>;
|
|
11217
11218
|
callID: string;
|
|
11218
11219
|
name: string;
|
|
11219
11220
|
namespace?: string;
|
|
11220
|
-
|
|
11221
|
-
content
|
|
11221
|
+
partial?: {
|
|
11222
|
+
content?: ({
|
|
11222
11223
|
type: "text";
|
|
11223
11224
|
text: string;
|
|
11224
11225
|
textSignature?: string;
|
|
@@ -11228,9 +11229,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11228
11229
|
mimeType: string;
|
|
11229
11230
|
})[];
|
|
11230
11231
|
details?: any;
|
|
11231
|
-
isError: true;
|
|
11232
11232
|
};
|
|
11233
|
-
status: "
|
|
11233
|
+
status: "running";
|
|
11234
11234
|
thoughtSignature?: string;
|
|
11235
11235
|
time: {
|
|
11236
11236
|
start: number;
|
|
@@ -11405,19 +11405,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11405
11405
|
type: "image";
|
|
11406
11406
|
data: string;
|
|
11407
11407
|
mimeType: string;
|
|
11408
|
-
} | {
|
|
11409
|
-
type: "thinking";
|
|
11410
|
-
thinking: string;
|
|
11411
|
-
thinkingSignature?: string;
|
|
11412
|
-
redacted?: boolean;
|
|
11413
11408
|
} | {
|
|
11414
11409
|
addedToolNames?: string[];
|
|
11415
11410
|
arguments: Record<string, any>;
|
|
11416
11411
|
callID: string;
|
|
11417
11412
|
name: string;
|
|
11418
11413
|
namespace?: string;
|
|
11419
|
-
|
|
11420
|
-
content
|
|
11414
|
+
result: {
|
|
11415
|
+
content: ({
|
|
11421
11416
|
type: "text";
|
|
11422
11417
|
text: string;
|
|
11423
11418
|
textSignature?: string;
|
|
@@ -11427,8 +11422,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11427
11422
|
mimeType: string;
|
|
11428
11423
|
})[];
|
|
11429
11424
|
details?: any;
|
|
11425
|
+
isError: false;
|
|
11430
11426
|
};
|
|
11431
|
-
status: "
|
|
11427
|
+
status: "completed";
|
|
11432
11428
|
thoughtSignature?: string;
|
|
11433
11429
|
time: {
|
|
11434
11430
|
start: number;
|
|
@@ -11452,9 +11448,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11452
11448
|
mimeType: string;
|
|
11453
11449
|
})[];
|
|
11454
11450
|
details?: any;
|
|
11455
|
-
isError:
|
|
11451
|
+
isError: true;
|
|
11456
11452
|
};
|
|
11457
|
-
status: "
|
|
11453
|
+
status: "error";
|
|
11458
11454
|
thoughtSignature?: string;
|
|
11459
11455
|
time: {
|
|
11460
11456
|
start: number;
|
|
@@ -11480,7 +11476,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11480
11476
|
details?: any;
|
|
11481
11477
|
isError: true;
|
|
11482
11478
|
};
|
|
11483
|
-
status: "
|
|
11479
|
+
status: "skipped";
|
|
11484
11480
|
thoughtSignature?: string;
|
|
11485
11481
|
time: {
|
|
11486
11482
|
start: number;
|
|
@@ -11506,21 +11502,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11506
11502
|
details?: any;
|
|
11507
11503
|
isError: true;
|
|
11508
11504
|
};
|
|
11509
|
-
status: "
|
|
11505
|
+
status: "aborted";
|
|
11510
11506
|
thoughtSignature?: string;
|
|
11511
11507
|
time: {
|
|
11512
11508
|
start: number;
|
|
11513
11509
|
end: number;
|
|
11514
11510
|
};
|
|
11515
11511
|
type: "toolCall";
|
|
11512
|
+
} | {
|
|
11513
|
+
type: "thinking";
|
|
11514
|
+
thinking: string;
|
|
11515
|
+
thinkingSignature?: string;
|
|
11516
|
+
redacted?: boolean;
|
|
11516
11517
|
} | {
|
|
11517
11518
|
addedToolNames?: string[];
|
|
11518
11519
|
arguments: Record<string, any>;
|
|
11519
11520
|
callID: string;
|
|
11520
11521
|
name: string;
|
|
11521
11522
|
namespace?: string;
|
|
11522
|
-
|
|
11523
|
-
content
|
|
11523
|
+
partial?: {
|
|
11524
|
+
content?: ({
|
|
11524
11525
|
type: "text";
|
|
11525
11526
|
text: string;
|
|
11526
11527
|
textSignature?: string;
|
|
@@ -11530,9 +11531,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11530
11531
|
mimeType: string;
|
|
11531
11532
|
})[];
|
|
11532
11533
|
details?: any;
|
|
11533
|
-
isError: true;
|
|
11534
11534
|
};
|
|
11535
|
-
status: "
|
|
11535
|
+
status: "running";
|
|
11536
11536
|
thoughtSignature?: string;
|
|
11537
11537
|
time: {
|
|
11538
11538
|
start: number;
|
|
@@ -12013,19 +12013,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12013
12013
|
type: "image";
|
|
12014
12014
|
data: string;
|
|
12015
12015
|
mimeType: string;
|
|
12016
|
-
} | {
|
|
12017
|
-
type: "thinking";
|
|
12018
|
-
thinking: string;
|
|
12019
|
-
thinkingSignature?: string;
|
|
12020
|
-
redacted?: boolean;
|
|
12021
12016
|
} | {
|
|
12022
12017
|
addedToolNames?: string[];
|
|
12023
12018
|
arguments: Record<string, any>;
|
|
12024
12019
|
callID: string;
|
|
12025
12020
|
name: string;
|
|
12026
12021
|
namespace?: string;
|
|
12027
|
-
|
|
12028
|
-
content
|
|
12022
|
+
result: {
|
|
12023
|
+
content: ({
|
|
12029
12024
|
type: "text";
|
|
12030
12025
|
text: string;
|
|
12031
12026
|
textSignature?: string;
|
|
@@ -12035,8 +12030,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12035
12030
|
mimeType: string;
|
|
12036
12031
|
})[];
|
|
12037
12032
|
details?: any;
|
|
12033
|
+
isError: false;
|
|
12038
12034
|
};
|
|
12039
|
-
status: "
|
|
12035
|
+
status: "completed";
|
|
12040
12036
|
thoughtSignature?: string;
|
|
12041
12037
|
time: {
|
|
12042
12038
|
start: number;
|
|
@@ -12060,9 +12056,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12060
12056
|
mimeType: string;
|
|
12061
12057
|
})[];
|
|
12062
12058
|
details?: any;
|
|
12063
|
-
isError:
|
|
12059
|
+
isError: true;
|
|
12064
12060
|
};
|
|
12065
|
-
status: "
|
|
12061
|
+
status: "error";
|
|
12066
12062
|
thoughtSignature?: string;
|
|
12067
12063
|
time: {
|
|
12068
12064
|
start: number;
|
|
@@ -12088,7 +12084,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12088
12084
|
details?: any;
|
|
12089
12085
|
isError: true;
|
|
12090
12086
|
};
|
|
12091
|
-
status: "
|
|
12087
|
+
status: "skipped";
|
|
12092
12088
|
thoughtSignature?: string;
|
|
12093
12089
|
time: {
|
|
12094
12090
|
start: number;
|
|
@@ -12114,21 +12110,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12114
12110
|
details?: any;
|
|
12115
12111
|
isError: true;
|
|
12116
12112
|
};
|
|
12117
|
-
status: "
|
|
12113
|
+
status: "aborted";
|
|
12118
12114
|
thoughtSignature?: string;
|
|
12119
12115
|
time: {
|
|
12120
12116
|
start: number;
|
|
12121
12117
|
end: number;
|
|
12122
12118
|
};
|
|
12123
12119
|
type: "toolCall";
|
|
12120
|
+
} | {
|
|
12121
|
+
type: "thinking";
|
|
12122
|
+
thinking: string;
|
|
12123
|
+
thinkingSignature?: string;
|
|
12124
|
+
redacted?: boolean;
|
|
12124
12125
|
} | {
|
|
12125
12126
|
addedToolNames?: string[];
|
|
12126
12127
|
arguments: Record<string, any>;
|
|
12127
12128
|
callID: string;
|
|
12128
12129
|
name: string;
|
|
12129
12130
|
namespace?: string;
|
|
12130
|
-
|
|
12131
|
-
content
|
|
12131
|
+
partial?: {
|
|
12132
|
+
content?: ({
|
|
12132
12133
|
type: "text";
|
|
12133
12134
|
text: string;
|
|
12134
12135
|
textSignature?: string;
|
|
@@ -12138,9 +12139,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12138
12139
|
mimeType: string;
|
|
12139
12140
|
})[];
|
|
12140
12141
|
details?: any;
|
|
12141
|
-
isError: true;
|
|
12142
12142
|
};
|
|
12143
|
-
status: "
|
|
12143
|
+
status: "running";
|
|
12144
12144
|
thoughtSignature?: string;
|
|
12145
12145
|
time: {
|
|
12146
12146
|
start: number;
|
|
@@ -12315,19 +12315,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12315
12315
|
type: "image";
|
|
12316
12316
|
data: string;
|
|
12317
12317
|
mimeType: string;
|
|
12318
|
-
} | {
|
|
12319
|
-
type: "thinking";
|
|
12320
|
-
thinking: string;
|
|
12321
|
-
thinkingSignature?: string;
|
|
12322
|
-
redacted?: boolean;
|
|
12323
12318
|
} | {
|
|
12324
12319
|
addedToolNames?: string[];
|
|
12325
12320
|
arguments: Record<string, any>;
|
|
12326
12321
|
callID: string;
|
|
12327
12322
|
name: string;
|
|
12328
12323
|
namespace?: string;
|
|
12329
|
-
|
|
12330
|
-
content
|
|
12324
|
+
result: {
|
|
12325
|
+
content: ({
|
|
12331
12326
|
type: "text";
|
|
12332
12327
|
text: string;
|
|
12333
12328
|
textSignature?: string;
|
|
@@ -12337,8 +12332,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12337
12332
|
mimeType: string;
|
|
12338
12333
|
})[];
|
|
12339
12334
|
details?: any;
|
|
12335
|
+
isError: false;
|
|
12340
12336
|
};
|
|
12341
|
-
status: "
|
|
12337
|
+
status: "completed";
|
|
12342
12338
|
thoughtSignature?: string;
|
|
12343
12339
|
time: {
|
|
12344
12340
|
start: number;
|
|
@@ -12362,9 +12358,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12362
12358
|
mimeType: string;
|
|
12363
12359
|
})[];
|
|
12364
12360
|
details?: any;
|
|
12365
|
-
isError:
|
|
12361
|
+
isError: true;
|
|
12366
12362
|
};
|
|
12367
|
-
status: "
|
|
12363
|
+
status: "error";
|
|
12368
12364
|
thoughtSignature?: string;
|
|
12369
12365
|
time: {
|
|
12370
12366
|
start: number;
|
|
@@ -12390,7 +12386,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12390
12386
|
details?: any;
|
|
12391
12387
|
isError: true;
|
|
12392
12388
|
};
|
|
12393
|
-
status: "
|
|
12389
|
+
status: "skipped";
|
|
12394
12390
|
thoughtSignature?: string;
|
|
12395
12391
|
time: {
|
|
12396
12392
|
start: number;
|
|
@@ -12416,21 +12412,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12416
12412
|
details?: any;
|
|
12417
12413
|
isError: true;
|
|
12418
12414
|
};
|
|
12419
|
-
status: "
|
|
12415
|
+
status: "aborted";
|
|
12420
12416
|
thoughtSignature?: string;
|
|
12421
12417
|
time: {
|
|
12422
12418
|
start: number;
|
|
12423
12419
|
end: number;
|
|
12424
12420
|
};
|
|
12425
12421
|
type: "toolCall";
|
|
12422
|
+
} | {
|
|
12423
|
+
type: "thinking";
|
|
12424
|
+
thinking: string;
|
|
12425
|
+
thinkingSignature?: string;
|
|
12426
|
+
redacted?: boolean;
|
|
12426
12427
|
} | {
|
|
12427
12428
|
addedToolNames?: string[];
|
|
12428
12429
|
arguments: Record<string, any>;
|
|
12429
12430
|
callID: string;
|
|
12430
12431
|
name: string;
|
|
12431
12432
|
namespace?: string;
|
|
12432
|
-
|
|
12433
|
-
content
|
|
12433
|
+
partial?: {
|
|
12434
|
+
content?: ({
|
|
12434
12435
|
type: "text";
|
|
12435
12436
|
text: string;
|
|
12436
12437
|
textSignature?: string;
|
|
@@ -12440,9 +12441,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12440
12441
|
mimeType: string;
|
|
12441
12442
|
})[];
|
|
12442
12443
|
details?: any;
|
|
12443
|
-
isError: true;
|
|
12444
12444
|
};
|
|
12445
|
-
status: "
|
|
12445
|
+
status: "running";
|
|
12446
12446
|
thoughtSignature?: string;
|
|
12447
12447
|
time: {
|
|
12448
12448
|
start: number;
|
|
@@ -12636,19 +12636,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12636
12636
|
type: "image";
|
|
12637
12637
|
data: string;
|
|
12638
12638
|
mimeType: string;
|
|
12639
|
-
} | {
|
|
12640
|
-
type: "thinking";
|
|
12641
|
-
thinking: string;
|
|
12642
|
-
thinkingSignature?: string;
|
|
12643
|
-
redacted?: boolean;
|
|
12644
12639
|
} | {
|
|
12645
12640
|
addedToolNames?: string[];
|
|
12646
12641
|
arguments: Record<string, any>;
|
|
12647
12642
|
callID: string;
|
|
12648
12643
|
name: string;
|
|
12649
12644
|
namespace?: string;
|
|
12650
|
-
|
|
12651
|
-
content
|
|
12645
|
+
result: {
|
|
12646
|
+
content: ({
|
|
12652
12647
|
type: "text";
|
|
12653
12648
|
text: string;
|
|
12654
12649
|
textSignature?: string;
|
|
@@ -12658,8 +12653,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12658
12653
|
mimeType: string;
|
|
12659
12654
|
})[];
|
|
12660
12655
|
details?: any;
|
|
12656
|
+
isError: false;
|
|
12661
12657
|
};
|
|
12662
|
-
status: "
|
|
12658
|
+
status: "completed";
|
|
12663
12659
|
thoughtSignature?: string;
|
|
12664
12660
|
time: {
|
|
12665
12661
|
start: number;
|
|
@@ -12683,9 +12679,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12683
12679
|
mimeType: string;
|
|
12684
12680
|
})[];
|
|
12685
12681
|
details?: any;
|
|
12686
|
-
isError:
|
|
12682
|
+
isError: true;
|
|
12687
12683
|
};
|
|
12688
|
-
status: "
|
|
12684
|
+
status: "error";
|
|
12689
12685
|
thoughtSignature?: string;
|
|
12690
12686
|
time: {
|
|
12691
12687
|
start: number;
|
|
@@ -12711,7 +12707,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12711
12707
|
details?: any;
|
|
12712
12708
|
isError: true;
|
|
12713
12709
|
};
|
|
12714
|
-
status: "
|
|
12710
|
+
status: "skipped";
|
|
12715
12711
|
thoughtSignature?: string;
|
|
12716
12712
|
time: {
|
|
12717
12713
|
start: number;
|
|
@@ -12737,21 +12733,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12737
12733
|
details?: any;
|
|
12738
12734
|
isError: true;
|
|
12739
12735
|
};
|
|
12740
|
-
status: "
|
|
12736
|
+
status: "aborted";
|
|
12741
12737
|
thoughtSignature?: string;
|
|
12742
12738
|
time: {
|
|
12743
12739
|
start: number;
|
|
12744
12740
|
end: number;
|
|
12745
12741
|
};
|
|
12746
12742
|
type: "toolCall";
|
|
12743
|
+
} | {
|
|
12744
|
+
type: "thinking";
|
|
12745
|
+
thinking: string;
|
|
12746
|
+
thinkingSignature?: string;
|
|
12747
|
+
redacted?: boolean;
|
|
12747
12748
|
} | {
|
|
12748
12749
|
addedToolNames?: string[];
|
|
12749
12750
|
arguments: Record<string, any>;
|
|
12750
12751
|
callID: string;
|
|
12751
12752
|
name: string;
|
|
12752
12753
|
namespace?: string;
|
|
12753
|
-
|
|
12754
|
-
content
|
|
12754
|
+
partial?: {
|
|
12755
|
+
content?: ({
|
|
12755
12756
|
type: "text";
|
|
12756
12757
|
text: string;
|
|
12757
12758
|
textSignature?: string;
|
|
@@ -12761,9 +12762,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12761
12762
|
mimeType: string;
|
|
12762
12763
|
})[];
|
|
12763
12764
|
details?: any;
|
|
12764
|
-
isError: true;
|
|
12765
12765
|
};
|
|
12766
|
-
status: "
|
|
12766
|
+
status: "running";
|
|
12767
12767
|
thoughtSignature?: string;
|
|
12768
12768
|
time: {
|
|
12769
12769
|
start: number;
|
|
@@ -12938,19 +12938,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12938
12938
|
type: "image";
|
|
12939
12939
|
data: string;
|
|
12940
12940
|
mimeType: string;
|
|
12941
|
-
} | {
|
|
12942
|
-
type: "thinking";
|
|
12943
|
-
thinking: string;
|
|
12944
|
-
thinkingSignature?: string;
|
|
12945
|
-
redacted?: boolean;
|
|
12946
12941
|
} | {
|
|
12947
12942
|
addedToolNames?: string[];
|
|
12948
12943
|
arguments: Record<string, any>;
|
|
12949
12944
|
callID: string;
|
|
12950
12945
|
name: string;
|
|
12951
12946
|
namespace?: string;
|
|
12952
|
-
|
|
12953
|
-
content
|
|
12947
|
+
result: {
|
|
12948
|
+
content: ({
|
|
12954
12949
|
type: "text";
|
|
12955
12950
|
text: string;
|
|
12956
12951
|
textSignature?: string;
|
|
@@ -12960,8 +12955,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12960
12955
|
mimeType: string;
|
|
12961
12956
|
})[];
|
|
12962
12957
|
details?: any;
|
|
12958
|
+
isError: false;
|
|
12963
12959
|
};
|
|
12964
|
-
status: "
|
|
12960
|
+
status: "completed";
|
|
12965
12961
|
thoughtSignature?: string;
|
|
12966
12962
|
time: {
|
|
12967
12963
|
start: number;
|
|
@@ -12985,9 +12981,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12985
12981
|
mimeType: string;
|
|
12986
12982
|
})[];
|
|
12987
12983
|
details?: any;
|
|
12988
|
-
isError:
|
|
12984
|
+
isError: true;
|
|
12989
12985
|
};
|
|
12990
|
-
status: "
|
|
12986
|
+
status: "error";
|
|
12991
12987
|
thoughtSignature?: string;
|
|
12992
12988
|
time: {
|
|
12993
12989
|
start: number;
|
|
@@ -13013,7 +13009,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13013
13009
|
details?: any;
|
|
13014
13010
|
isError: true;
|
|
13015
13011
|
};
|
|
13016
|
-
status: "
|
|
13012
|
+
status: "skipped";
|
|
13017
13013
|
thoughtSignature?: string;
|
|
13018
13014
|
time: {
|
|
13019
13015
|
start: number;
|
|
@@ -13039,21 +13035,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13039
13035
|
details?: any;
|
|
13040
13036
|
isError: true;
|
|
13041
13037
|
};
|
|
13042
|
-
status: "
|
|
13038
|
+
status: "aborted";
|
|
13043
13039
|
thoughtSignature?: string;
|
|
13044
13040
|
time: {
|
|
13045
13041
|
start: number;
|
|
13046
13042
|
end: number;
|
|
13047
13043
|
};
|
|
13048
13044
|
type: "toolCall";
|
|
13045
|
+
} | {
|
|
13046
|
+
type: "thinking";
|
|
13047
|
+
thinking: string;
|
|
13048
|
+
thinkingSignature?: string;
|
|
13049
|
+
redacted?: boolean;
|
|
13049
13050
|
} | {
|
|
13050
13051
|
addedToolNames?: string[];
|
|
13051
13052
|
arguments: Record<string, any>;
|
|
13052
13053
|
callID: string;
|
|
13053
13054
|
name: string;
|
|
13054
13055
|
namespace?: string;
|
|
13055
|
-
|
|
13056
|
-
content
|
|
13056
|
+
partial?: {
|
|
13057
|
+
content?: ({
|
|
13057
13058
|
type: "text";
|
|
13058
13059
|
text: string;
|
|
13059
13060
|
textSignature?: string;
|
|
@@ -13063,9 +13064,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13063
13064
|
mimeType: string;
|
|
13064
13065
|
})[];
|
|
13065
13066
|
details?: any;
|
|
13066
|
-
isError: true;
|
|
13067
13067
|
};
|
|
13068
|
-
status: "
|
|
13068
|
+
status: "running";
|
|
13069
13069
|
thoughtSignature?: string;
|
|
13070
13070
|
time: {
|
|
13071
13071
|
start: number;
|
|
@@ -13268,19 +13268,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13268
13268
|
type: "image";
|
|
13269
13269
|
data: string;
|
|
13270
13270
|
mimeType: string;
|
|
13271
|
-
} | {
|
|
13272
|
-
type: "thinking";
|
|
13273
|
-
thinking: string;
|
|
13274
|
-
thinkingSignature?: string;
|
|
13275
|
-
redacted?: boolean;
|
|
13276
13271
|
} | {
|
|
13277
13272
|
addedToolNames?: string[];
|
|
13278
13273
|
arguments: Record<string, any>;
|
|
13279
13274
|
callID: string;
|
|
13280
13275
|
name: string;
|
|
13281
13276
|
namespace?: string;
|
|
13282
|
-
|
|
13283
|
-
content
|
|
13277
|
+
result: {
|
|
13278
|
+
content: ({
|
|
13284
13279
|
type: "text";
|
|
13285
13280
|
text: string;
|
|
13286
13281
|
textSignature?: string;
|
|
@@ -13290,8 +13285,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13290
13285
|
mimeType: string;
|
|
13291
13286
|
})[];
|
|
13292
13287
|
details?: any;
|
|
13288
|
+
isError: false;
|
|
13293
13289
|
};
|
|
13294
|
-
status: "
|
|
13290
|
+
status: "completed";
|
|
13295
13291
|
thoughtSignature?: string;
|
|
13296
13292
|
time: {
|
|
13297
13293
|
start: number;
|
|
@@ -13315,9 +13311,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13315
13311
|
mimeType: string;
|
|
13316
13312
|
})[];
|
|
13317
13313
|
details?: any;
|
|
13318
|
-
isError:
|
|
13314
|
+
isError: true;
|
|
13319
13315
|
};
|
|
13320
|
-
status: "
|
|
13316
|
+
status: "error";
|
|
13321
13317
|
thoughtSignature?: string;
|
|
13322
13318
|
time: {
|
|
13323
13319
|
start: number;
|
|
@@ -13343,7 +13339,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13343
13339
|
details?: any;
|
|
13344
13340
|
isError: true;
|
|
13345
13341
|
};
|
|
13346
|
-
status: "
|
|
13342
|
+
status: "skipped";
|
|
13347
13343
|
thoughtSignature?: string;
|
|
13348
13344
|
time: {
|
|
13349
13345
|
start: number;
|
|
@@ -13369,21 +13365,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13369
13365
|
details?: any;
|
|
13370
13366
|
isError: true;
|
|
13371
13367
|
};
|
|
13372
|
-
status: "
|
|
13368
|
+
status: "aborted";
|
|
13373
13369
|
thoughtSignature?: string;
|
|
13374
13370
|
time: {
|
|
13375
13371
|
start: number;
|
|
13376
13372
|
end: number;
|
|
13377
13373
|
};
|
|
13378
13374
|
type: "toolCall";
|
|
13375
|
+
} | {
|
|
13376
|
+
type: "thinking";
|
|
13377
|
+
thinking: string;
|
|
13378
|
+
thinkingSignature?: string;
|
|
13379
|
+
redacted?: boolean;
|
|
13379
13380
|
} | {
|
|
13380
13381
|
addedToolNames?: string[];
|
|
13381
13382
|
arguments: Record<string, any>;
|
|
13382
13383
|
callID: string;
|
|
13383
13384
|
name: string;
|
|
13384
13385
|
namespace?: string;
|
|
13385
|
-
|
|
13386
|
-
content
|
|
13386
|
+
partial?: {
|
|
13387
|
+
content?: ({
|
|
13387
13388
|
type: "text";
|
|
13388
13389
|
text: string;
|
|
13389
13390
|
textSignature?: string;
|
|
@@ -13393,9 +13394,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13393
13394
|
mimeType: string;
|
|
13394
13395
|
})[];
|
|
13395
13396
|
details?: any;
|
|
13396
|
-
isError: true;
|
|
13397
13397
|
};
|
|
13398
|
-
status: "
|
|
13398
|
+
status: "running";
|
|
13399
13399
|
thoughtSignature?: string;
|
|
13400
13400
|
time: {
|
|
13401
13401
|
start: number;
|
|
@@ -13570,19 +13570,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13570
13570
|
type: "image";
|
|
13571
13571
|
data: string;
|
|
13572
13572
|
mimeType: string;
|
|
13573
|
-
} | {
|
|
13574
|
-
type: "thinking";
|
|
13575
|
-
thinking: string;
|
|
13576
|
-
thinkingSignature?: string;
|
|
13577
|
-
redacted?: boolean;
|
|
13578
13573
|
} | {
|
|
13579
13574
|
addedToolNames?: string[];
|
|
13580
13575
|
arguments: Record<string, any>;
|
|
13581
13576
|
callID: string;
|
|
13582
13577
|
name: string;
|
|
13583
13578
|
namespace?: string;
|
|
13584
|
-
|
|
13585
|
-
content
|
|
13579
|
+
result: {
|
|
13580
|
+
content: ({
|
|
13586
13581
|
type: "text";
|
|
13587
13582
|
text: string;
|
|
13588
13583
|
textSignature?: string;
|
|
@@ -13592,8 +13587,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13592
13587
|
mimeType: string;
|
|
13593
13588
|
})[];
|
|
13594
13589
|
details?: any;
|
|
13590
|
+
isError: false;
|
|
13595
13591
|
};
|
|
13596
|
-
status: "
|
|
13592
|
+
status: "completed";
|
|
13597
13593
|
thoughtSignature?: string;
|
|
13598
13594
|
time: {
|
|
13599
13595
|
start: number;
|
|
@@ -13617,9 +13613,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13617
13613
|
mimeType: string;
|
|
13618
13614
|
})[];
|
|
13619
13615
|
details?: any;
|
|
13620
|
-
isError:
|
|
13616
|
+
isError: true;
|
|
13621
13617
|
};
|
|
13622
|
-
status: "
|
|
13618
|
+
status: "error";
|
|
13623
13619
|
thoughtSignature?: string;
|
|
13624
13620
|
time: {
|
|
13625
13621
|
start: number;
|
|
@@ -13645,7 +13641,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13645
13641
|
details?: any;
|
|
13646
13642
|
isError: true;
|
|
13647
13643
|
};
|
|
13648
|
-
status: "
|
|
13644
|
+
status: "skipped";
|
|
13649
13645
|
thoughtSignature?: string;
|
|
13650
13646
|
time: {
|
|
13651
13647
|
start: number;
|
|
@@ -13671,21 +13667,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13671
13667
|
details?: any;
|
|
13672
13668
|
isError: true;
|
|
13673
13669
|
};
|
|
13674
|
-
status: "
|
|
13670
|
+
status: "aborted";
|
|
13675
13671
|
thoughtSignature?: string;
|
|
13676
13672
|
time: {
|
|
13677
13673
|
start: number;
|
|
13678
13674
|
end: number;
|
|
13679
13675
|
};
|
|
13680
13676
|
type: "toolCall";
|
|
13677
|
+
} | {
|
|
13678
|
+
type: "thinking";
|
|
13679
|
+
thinking: string;
|
|
13680
|
+
thinkingSignature?: string;
|
|
13681
|
+
redacted?: boolean;
|
|
13681
13682
|
} | {
|
|
13682
13683
|
addedToolNames?: string[];
|
|
13683
13684
|
arguments: Record<string, any>;
|
|
13684
13685
|
callID: string;
|
|
13685
13686
|
name: string;
|
|
13686
13687
|
namespace?: string;
|
|
13687
|
-
|
|
13688
|
-
content
|
|
13688
|
+
partial?: {
|
|
13689
|
+
content?: ({
|
|
13689
13690
|
type: "text";
|
|
13690
13691
|
text: string;
|
|
13691
13692
|
textSignature?: string;
|
|
@@ -13695,9 +13696,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13695
13696
|
mimeType: string;
|
|
13696
13697
|
})[];
|
|
13697
13698
|
details?: any;
|
|
13698
|
-
isError: true;
|
|
13699
13699
|
};
|
|
13700
|
-
status: "
|
|
13700
|
+
status: "running";
|
|
13701
13701
|
thoughtSignature?: string;
|
|
13702
13702
|
time: {
|
|
13703
13703
|
start: number;
|
|
@@ -13891,19 +13891,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13891
13891
|
type: "image";
|
|
13892
13892
|
data: string;
|
|
13893
13893
|
mimeType: string;
|
|
13894
|
-
} | {
|
|
13895
|
-
type: "thinking";
|
|
13896
|
-
thinking: string;
|
|
13897
|
-
thinkingSignature?: string;
|
|
13898
|
-
redacted?: boolean;
|
|
13899
13894
|
} | {
|
|
13900
13895
|
addedToolNames?: string[];
|
|
13901
13896
|
arguments: Record<string, any>;
|
|
13902
13897
|
callID: string;
|
|
13903
13898
|
name: string;
|
|
13904
13899
|
namespace?: string;
|
|
13905
|
-
|
|
13906
|
-
content
|
|
13900
|
+
result: {
|
|
13901
|
+
content: ({
|
|
13907
13902
|
type: "text";
|
|
13908
13903
|
text: string;
|
|
13909
13904
|
textSignature?: string;
|
|
@@ -13913,8 +13908,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13913
13908
|
mimeType: string;
|
|
13914
13909
|
})[];
|
|
13915
13910
|
details?: any;
|
|
13911
|
+
isError: false;
|
|
13916
13912
|
};
|
|
13917
|
-
status: "
|
|
13913
|
+
status: "completed";
|
|
13918
13914
|
thoughtSignature?: string;
|
|
13919
13915
|
time: {
|
|
13920
13916
|
start: number;
|
|
@@ -13938,9 +13934,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13938
13934
|
mimeType: string;
|
|
13939
13935
|
})[];
|
|
13940
13936
|
details?: any;
|
|
13941
|
-
isError:
|
|
13937
|
+
isError: true;
|
|
13942
13938
|
};
|
|
13943
|
-
status: "
|
|
13939
|
+
status: "error";
|
|
13944
13940
|
thoughtSignature?: string;
|
|
13945
13941
|
time: {
|
|
13946
13942
|
start: number;
|
|
@@ -13966,7 +13962,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13966
13962
|
details?: any;
|
|
13967
13963
|
isError: true;
|
|
13968
13964
|
};
|
|
13969
|
-
status: "
|
|
13965
|
+
status: "skipped";
|
|
13970
13966
|
thoughtSignature?: string;
|
|
13971
13967
|
time: {
|
|
13972
13968
|
start: number;
|
|
@@ -13992,21 +13988,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13992
13988
|
details?: any;
|
|
13993
13989
|
isError: true;
|
|
13994
13990
|
};
|
|
13995
|
-
status: "
|
|
13991
|
+
status: "aborted";
|
|
13996
13992
|
thoughtSignature?: string;
|
|
13997
13993
|
time: {
|
|
13998
13994
|
start: number;
|
|
13999
13995
|
end: number;
|
|
14000
13996
|
};
|
|
14001
13997
|
type: "toolCall";
|
|
13998
|
+
} | {
|
|
13999
|
+
type: "thinking";
|
|
14000
|
+
thinking: string;
|
|
14001
|
+
thinkingSignature?: string;
|
|
14002
|
+
redacted?: boolean;
|
|
14002
14003
|
} | {
|
|
14003
14004
|
addedToolNames?: string[];
|
|
14004
14005
|
arguments: Record<string, any>;
|
|
14005
14006
|
callID: string;
|
|
14006
14007
|
name: string;
|
|
14007
14008
|
namespace?: string;
|
|
14008
|
-
|
|
14009
|
-
content
|
|
14009
|
+
partial?: {
|
|
14010
|
+
content?: ({
|
|
14010
14011
|
type: "text";
|
|
14011
14012
|
text: string;
|
|
14012
14013
|
textSignature?: string;
|
|
@@ -14016,9 +14017,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14016
14017
|
mimeType: string;
|
|
14017
14018
|
})[];
|
|
14018
14019
|
details?: any;
|
|
14019
|
-
isError: true;
|
|
14020
14020
|
};
|
|
14021
|
-
status: "
|
|
14021
|
+
status: "running";
|
|
14022
14022
|
thoughtSignature?: string;
|
|
14023
14023
|
time: {
|
|
14024
14024
|
start: number;
|
|
@@ -14193,19 +14193,14 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14193
14193
|
type: "image";
|
|
14194
14194
|
data: string;
|
|
14195
14195
|
mimeType: string;
|
|
14196
|
-
} | {
|
|
14197
|
-
type: "thinking";
|
|
14198
|
-
thinking: string;
|
|
14199
|
-
thinkingSignature?: string;
|
|
14200
|
-
redacted?: boolean;
|
|
14201
14196
|
} | {
|
|
14202
14197
|
addedToolNames?: string[];
|
|
14203
14198
|
arguments: Record<string, any>;
|
|
14204
14199
|
callID: string;
|
|
14205
14200
|
name: string;
|
|
14206
14201
|
namespace?: string;
|
|
14207
|
-
|
|
14208
|
-
content
|
|
14202
|
+
result: {
|
|
14203
|
+
content: ({
|
|
14209
14204
|
type: "text";
|
|
14210
14205
|
text: string;
|
|
14211
14206
|
textSignature?: string;
|
|
@@ -14215,8 +14210,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14215
14210
|
mimeType: string;
|
|
14216
14211
|
})[];
|
|
14217
14212
|
details?: any;
|
|
14213
|
+
isError: false;
|
|
14218
14214
|
};
|
|
14219
|
-
status: "
|
|
14215
|
+
status: "completed";
|
|
14220
14216
|
thoughtSignature?: string;
|
|
14221
14217
|
time: {
|
|
14222
14218
|
start: number;
|
|
@@ -14240,9 +14236,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14240
14236
|
mimeType: string;
|
|
14241
14237
|
})[];
|
|
14242
14238
|
details?: any;
|
|
14243
|
-
isError:
|
|
14239
|
+
isError: true;
|
|
14244
14240
|
};
|
|
14245
|
-
status: "
|
|
14241
|
+
status: "error";
|
|
14246
14242
|
thoughtSignature?: string;
|
|
14247
14243
|
time: {
|
|
14248
14244
|
start: number;
|
|
@@ -14268,7 +14264,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14268
14264
|
details?: any;
|
|
14269
14265
|
isError: true;
|
|
14270
14266
|
};
|
|
14271
|
-
status: "
|
|
14267
|
+
status: "skipped";
|
|
14272
14268
|
thoughtSignature?: string;
|
|
14273
14269
|
time: {
|
|
14274
14270
|
start: number;
|
|
@@ -14294,21 +14290,26 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14294
14290
|
details?: any;
|
|
14295
14291
|
isError: true;
|
|
14296
14292
|
};
|
|
14297
|
-
status: "
|
|
14293
|
+
status: "aborted";
|
|
14298
14294
|
thoughtSignature?: string;
|
|
14299
14295
|
time: {
|
|
14300
14296
|
start: number;
|
|
14301
14297
|
end: number;
|
|
14302
14298
|
};
|
|
14303
14299
|
type: "toolCall";
|
|
14300
|
+
} | {
|
|
14301
|
+
type: "thinking";
|
|
14302
|
+
thinking: string;
|
|
14303
|
+
thinkingSignature?: string;
|
|
14304
|
+
redacted?: boolean;
|
|
14304
14305
|
} | {
|
|
14305
14306
|
addedToolNames?: string[];
|
|
14306
14307
|
arguments: Record<string, any>;
|
|
14307
14308
|
callID: string;
|
|
14308
14309
|
name: string;
|
|
14309
14310
|
namespace?: string;
|
|
14310
|
-
|
|
14311
|
-
content
|
|
14311
|
+
partial?: {
|
|
14312
|
+
content?: ({
|
|
14312
14313
|
type: "text";
|
|
14313
14314
|
text: string;
|
|
14314
14315
|
textSignature?: string;
|
|
@@ -14318,9 +14319,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14318
14319
|
mimeType: string;
|
|
14319
14320
|
})[];
|
|
14320
14321
|
details?: any;
|
|
14321
|
-
isError: true;
|
|
14322
14322
|
};
|
|
14323
|
-
status: "
|
|
14323
|
+
status: "running";
|
|
14324
14324
|
thoughtSignature?: string;
|
|
14325
14325
|
time: {
|
|
14326
14326
|
start: number;
|
|
@@ -15829,19 +15829,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15829
15829
|
type: "image";
|
|
15830
15830
|
data: string;
|
|
15831
15831
|
mimeType: string;
|
|
15832
|
-
} | {
|
|
15833
|
-
type: "thinking";
|
|
15834
|
-
thinking: string;
|
|
15835
|
-
thinkingSignature?: string;
|
|
15836
|
-
redacted?: boolean;
|
|
15837
15832
|
} | {
|
|
15838
15833
|
addedToolNames?: string[];
|
|
15839
15834
|
arguments: Record<string, any>;
|
|
15840
15835
|
callID: string;
|
|
15841
15836
|
name: string;
|
|
15842
15837
|
namespace?: string;
|
|
15843
|
-
|
|
15844
|
-
content
|
|
15838
|
+
result: {
|
|
15839
|
+
content: ({
|
|
15845
15840
|
type: "text";
|
|
15846
15841
|
text: string;
|
|
15847
15842
|
textSignature?: string;
|
|
@@ -15851,8 +15846,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15851
15846
|
mimeType: string;
|
|
15852
15847
|
})[];
|
|
15853
15848
|
details?: any;
|
|
15849
|
+
isError: false;
|
|
15854
15850
|
};
|
|
15855
|
-
status: "
|
|
15851
|
+
status: "completed";
|
|
15856
15852
|
thoughtSignature?: string;
|
|
15857
15853
|
time: {
|
|
15858
15854
|
start: number;
|
|
@@ -15876,9 +15872,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15876
15872
|
mimeType: string;
|
|
15877
15873
|
})[];
|
|
15878
15874
|
details?: any;
|
|
15879
|
-
isError:
|
|
15875
|
+
isError: true;
|
|
15880
15876
|
};
|
|
15881
|
-
status: "
|
|
15877
|
+
status: "error";
|
|
15882
15878
|
thoughtSignature?: string;
|
|
15883
15879
|
time: {
|
|
15884
15880
|
start: number;
|
|
@@ -15904,7 +15900,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15904
15900
|
details?: any;
|
|
15905
15901
|
isError: true;
|
|
15906
15902
|
};
|
|
15907
|
-
status: "
|
|
15903
|
+
status: "skipped";
|
|
15908
15904
|
thoughtSignature?: string;
|
|
15909
15905
|
time: {
|
|
15910
15906
|
start: number;
|
|
@@ -15930,21 +15926,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15930
15926
|
details?: any;
|
|
15931
15927
|
isError: true;
|
|
15932
15928
|
};
|
|
15933
|
-
status: "
|
|
15929
|
+
status: "aborted";
|
|
15934
15930
|
thoughtSignature?: string;
|
|
15935
15931
|
time: {
|
|
15936
15932
|
start: number;
|
|
15937
15933
|
end: number;
|
|
15938
15934
|
};
|
|
15939
15935
|
type: "toolCall";
|
|
15936
|
+
} | {
|
|
15937
|
+
type: "thinking";
|
|
15938
|
+
thinking: string;
|
|
15939
|
+
thinkingSignature?: string;
|
|
15940
|
+
redacted?: boolean;
|
|
15940
15941
|
} | {
|
|
15941
15942
|
addedToolNames?: string[];
|
|
15942
15943
|
arguments: Record<string, any>;
|
|
15943
15944
|
callID: string;
|
|
15944
15945
|
name: string;
|
|
15945
15946
|
namespace?: string;
|
|
15946
|
-
|
|
15947
|
-
content
|
|
15947
|
+
partial?: {
|
|
15948
|
+
content?: ({
|
|
15948
15949
|
type: "text";
|
|
15949
15950
|
text: string;
|
|
15950
15951
|
textSignature?: string;
|
|
@@ -15954,9 +15955,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15954
15955
|
mimeType: string;
|
|
15955
15956
|
})[];
|
|
15956
15957
|
details?: any;
|
|
15957
|
-
isError: true;
|
|
15958
15958
|
};
|
|
15959
|
-
status: "
|
|
15959
|
+
status: "running";
|
|
15960
15960
|
thoughtSignature?: string;
|
|
15961
15961
|
time: {
|
|
15962
15962
|
start: number;
|
|
@@ -16131,19 +16131,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16131
16131
|
type: "image";
|
|
16132
16132
|
data: string;
|
|
16133
16133
|
mimeType: string;
|
|
16134
|
-
} | {
|
|
16135
|
-
type: "thinking";
|
|
16136
|
-
thinking: string;
|
|
16137
|
-
thinkingSignature?: string;
|
|
16138
|
-
redacted?: boolean;
|
|
16139
16134
|
} | {
|
|
16140
16135
|
addedToolNames?: string[];
|
|
16141
16136
|
arguments: Record<string, any>;
|
|
16142
16137
|
callID: string;
|
|
16143
16138
|
name: string;
|
|
16144
16139
|
namespace?: string;
|
|
16145
|
-
|
|
16146
|
-
content
|
|
16140
|
+
result: {
|
|
16141
|
+
content: ({
|
|
16147
16142
|
type: "text";
|
|
16148
16143
|
text: string;
|
|
16149
16144
|
textSignature?: string;
|
|
@@ -16153,8 +16148,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16153
16148
|
mimeType: string;
|
|
16154
16149
|
})[];
|
|
16155
16150
|
details?: any;
|
|
16151
|
+
isError: false;
|
|
16156
16152
|
};
|
|
16157
|
-
status: "
|
|
16153
|
+
status: "completed";
|
|
16158
16154
|
thoughtSignature?: string;
|
|
16159
16155
|
time: {
|
|
16160
16156
|
start: number;
|
|
@@ -16178,9 +16174,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16178
16174
|
mimeType: string;
|
|
16179
16175
|
})[];
|
|
16180
16176
|
details?: any;
|
|
16181
|
-
isError:
|
|
16177
|
+
isError: true;
|
|
16182
16178
|
};
|
|
16183
|
-
status: "
|
|
16179
|
+
status: "error";
|
|
16184
16180
|
thoughtSignature?: string;
|
|
16185
16181
|
time: {
|
|
16186
16182
|
start: number;
|
|
@@ -16206,7 +16202,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16206
16202
|
details?: any;
|
|
16207
16203
|
isError: true;
|
|
16208
16204
|
};
|
|
16209
|
-
status: "
|
|
16205
|
+
status: "skipped";
|
|
16210
16206
|
thoughtSignature?: string;
|
|
16211
16207
|
time: {
|
|
16212
16208
|
start: number;
|
|
@@ -16232,21 +16228,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16232
16228
|
details?: any;
|
|
16233
16229
|
isError: true;
|
|
16234
16230
|
};
|
|
16235
|
-
status: "
|
|
16231
|
+
status: "aborted";
|
|
16236
16232
|
thoughtSignature?: string;
|
|
16237
16233
|
time: {
|
|
16238
16234
|
start: number;
|
|
16239
16235
|
end: number;
|
|
16240
16236
|
};
|
|
16241
16237
|
type: "toolCall";
|
|
16238
|
+
} | {
|
|
16239
|
+
type: "thinking";
|
|
16240
|
+
thinking: string;
|
|
16241
|
+
thinkingSignature?: string;
|
|
16242
|
+
redacted?: boolean;
|
|
16242
16243
|
} | {
|
|
16243
16244
|
addedToolNames?: string[];
|
|
16244
16245
|
arguments: Record<string, any>;
|
|
16245
16246
|
callID: string;
|
|
16246
16247
|
name: string;
|
|
16247
16248
|
namespace?: string;
|
|
16248
|
-
|
|
16249
|
-
content
|
|
16249
|
+
partial?: {
|
|
16250
|
+
content?: ({
|
|
16250
16251
|
type: "text";
|
|
16251
16252
|
text: string;
|
|
16252
16253
|
textSignature?: string;
|
|
@@ -16256,9 +16257,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16256
16257
|
mimeType: string;
|
|
16257
16258
|
})[];
|
|
16258
16259
|
details?: any;
|
|
16259
|
-
isError: true;
|
|
16260
16260
|
};
|
|
16261
|
-
status: "
|
|
16261
|
+
status: "running";
|
|
16262
16262
|
thoughtSignature?: string;
|
|
16263
16263
|
time: {
|
|
16264
16264
|
start: number;
|
|
@@ -16451,19 +16451,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16451
16451
|
type: "image";
|
|
16452
16452
|
data: string;
|
|
16453
16453
|
mimeType: string;
|
|
16454
|
-
} | {
|
|
16455
|
-
type: "thinking";
|
|
16456
|
-
thinking: string;
|
|
16457
|
-
thinkingSignature?: string;
|
|
16458
|
-
redacted?: boolean;
|
|
16459
16454
|
} | {
|
|
16460
16455
|
addedToolNames?: string[];
|
|
16461
16456
|
arguments: Record<string, any>;
|
|
16462
16457
|
callID: string;
|
|
16463
16458
|
name: string;
|
|
16464
16459
|
namespace?: string;
|
|
16465
|
-
|
|
16466
|
-
content
|
|
16460
|
+
result: {
|
|
16461
|
+
content: ({
|
|
16467
16462
|
type: "text";
|
|
16468
16463
|
text: string;
|
|
16469
16464
|
textSignature?: string;
|
|
@@ -16473,8 +16468,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16473
16468
|
mimeType: string;
|
|
16474
16469
|
})[];
|
|
16475
16470
|
details?: any;
|
|
16471
|
+
isError: false;
|
|
16476
16472
|
};
|
|
16477
|
-
status: "
|
|
16473
|
+
status: "completed";
|
|
16478
16474
|
thoughtSignature?: string;
|
|
16479
16475
|
time: {
|
|
16480
16476
|
start: number;
|
|
@@ -16498,9 +16494,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16498
16494
|
mimeType: string;
|
|
16499
16495
|
})[];
|
|
16500
16496
|
details?: any;
|
|
16501
|
-
isError:
|
|
16497
|
+
isError: true;
|
|
16502
16498
|
};
|
|
16503
|
-
status: "
|
|
16499
|
+
status: "error";
|
|
16504
16500
|
thoughtSignature?: string;
|
|
16505
16501
|
time: {
|
|
16506
16502
|
start: number;
|
|
@@ -16526,7 +16522,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16526
16522
|
details?: any;
|
|
16527
16523
|
isError: true;
|
|
16528
16524
|
};
|
|
16529
|
-
status: "
|
|
16525
|
+
status: "skipped";
|
|
16530
16526
|
thoughtSignature?: string;
|
|
16531
16527
|
time: {
|
|
16532
16528
|
start: number;
|
|
@@ -16552,21 +16548,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16552
16548
|
details?: any;
|
|
16553
16549
|
isError: true;
|
|
16554
16550
|
};
|
|
16555
|
-
status: "
|
|
16551
|
+
status: "aborted";
|
|
16556
16552
|
thoughtSignature?: string;
|
|
16557
16553
|
time: {
|
|
16558
16554
|
start: number;
|
|
16559
16555
|
end: number;
|
|
16560
16556
|
};
|
|
16561
16557
|
type: "toolCall";
|
|
16558
|
+
} | {
|
|
16559
|
+
type: "thinking";
|
|
16560
|
+
thinking: string;
|
|
16561
|
+
thinkingSignature?: string;
|
|
16562
|
+
redacted?: boolean;
|
|
16562
16563
|
} | {
|
|
16563
16564
|
addedToolNames?: string[];
|
|
16564
16565
|
arguments: Record<string, any>;
|
|
16565
16566
|
callID: string;
|
|
16566
16567
|
name: string;
|
|
16567
16568
|
namespace?: string;
|
|
16568
|
-
|
|
16569
|
-
content
|
|
16569
|
+
partial?: {
|
|
16570
|
+
content?: ({
|
|
16570
16571
|
type: "text";
|
|
16571
16572
|
text: string;
|
|
16572
16573
|
textSignature?: string;
|
|
@@ -16576,9 +16577,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16576
16577
|
mimeType: string;
|
|
16577
16578
|
})[];
|
|
16578
16579
|
details?: any;
|
|
16579
|
-
isError: true;
|
|
16580
16580
|
};
|
|
16581
|
-
status: "
|
|
16581
|
+
status: "running";
|
|
16582
16582
|
thoughtSignature?: string;
|
|
16583
16583
|
time: {
|
|
16584
16584
|
start: number;
|
|
@@ -16753,19 +16753,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16753
16753
|
type: "image";
|
|
16754
16754
|
data: string;
|
|
16755
16755
|
mimeType: string;
|
|
16756
|
-
} | {
|
|
16757
|
-
type: "thinking";
|
|
16758
|
-
thinking: string;
|
|
16759
|
-
thinkingSignature?: string;
|
|
16760
|
-
redacted?: boolean;
|
|
16761
16756
|
} | {
|
|
16762
16757
|
addedToolNames?: string[];
|
|
16763
16758
|
arguments: Record<string, any>;
|
|
16764
16759
|
callID: string;
|
|
16765
16760
|
name: string;
|
|
16766
16761
|
namespace?: string;
|
|
16767
|
-
|
|
16768
|
-
content
|
|
16762
|
+
result: {
|
|
16763
|
+
content: ({
|
|
16769
16764
|
type: "text";
|
|
16770
16765
|
text: string;
|
|
16771
16766
|
textSignature?: string;
|
|
@@ -16775,8 +16770,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16775
16770
|
mimeType: string;
|
|
16776
16771
|
})[];
|
|
16777
16772
|
details?: any;
|
|
16773
|
+
isError: false;
|
|
16778
16774
|
};
|
|
16779
|
-
status: "
|
|
16775
|
+
status: "completed";
|
|
16780
16776
|
thoughtSignature?: string;
|
|
16781
16777
|
time: {
|
|
16782
16778
|
start: number;
|
|
@@ -16800,9 +16796,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16800
16796
|
mimeType: string;
|
|
16801
16797
|
})[];
|
|
16802
16798
|
details?: any;
|
|
16803
|
-
isError:
|
|
16799
|
+
isError: true;
|
|
16804
16800
|
};
|
|
16805
|
-
status: "
|
|
16801
|
+
status: "error";
|
|
16806
16802
|
thoughtSignature?: string;
|
|
16807
16803
|
time: {
|
|
16808
16804
|
start: number;
|
|
@@ -16828,7 +16824,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16828
16824
|
details?: any;
|
|
16829
16825
|
isError: true;
|
|
16830
16826
|
};
|
|
16831
|
-
status: "
|
|
16827
|
+
status: "skipped";
|
|
16832
16828
|
thoughtSignature?: string;
|
|
16833
16829
|
time: {
|
|
16834
16830
|
start: number;
|
|
@@ -16854,21 +16850,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16854
16850
|
details?: any;
|
|
16855
16851
|
isError: true;
|
|
16856
16852
|
};
|
|
16857
|
-
status: "
|
|
16853
|
+
status: "aborted";
|
|
16858
16854
|
thoughtSignature?: string;
|
|
16859
16855
|
time: {
|
|
16860
16856
|
start: number;
|
|
16861
16857
|
end: number;
|
|
16862
16858
|
};
|
|
16863
16859
|
type: "toolCall";
|
|
16860
|
+
} | {
|
|
16861
|
+
type: "thinking";
|
|
16862
|
+
thinking: string;
|
|
16863
|
+
thinkingSignature?: string;
|
|
16864
|
+
redacted?: boolean;
|
|
16864
16865
|
} | {
|
|
16865
16866
|
addedToolNames?: string[];
|
|
16866
16867
|
arguments: Record<string, any>;
|
|
16867
16868
|
callID: string;
|
|
16868
16869
|
name: string;
|
|
16869
16870
|
namespace?: string;
|
|
16870
|
-
|
|
16871
|
-
content
|
|
16871
|
+
partial?: {
|
|
16872
|
+
content?: ({
|
|
16872
16873
|
type: "text";
|
|
16873
16874
|
text: string;
|
|
16874
16875
|
textSignature?: string;
|
|
@@ -16878,9 +16879,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16878
16879
|
mimeType: string;
|
|
16879
16880
|
})[];
|
|
16880
16881
|
details?: any;
|
|
16881
|
-
isError: true;
|
|
16882
16882
|
};
|
|
16883
|
-
status: "
|
|
16883
|
+
status: "running";
|
|
16884
16884
|
thoughtSignature?: string;
|
|
16885
16885
|
time: {
|
|
16886
16886
|
start: number;
|
|
@@ -17361,19 +17361,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17361
17361
|
type: "image";
|
|
17362
17362
|
data: string;
|
|
17363
17363
|
mimeType: string;
|
|
17364
|
-
} | {
|
|
17365
|
-
type: "thinking";
|
|
17366
|
-
thinking: string;
|
|
17367
|
-
thinkingSignature?: string;
|
|
17368
|
-
redacted?: boolean;
|
|
17369
17364
|
} | {
|
|
17370
17365
|
addedToolNames?: string[];
|
|
17371
17366
|
arguments: Record<string, any>;
|
|
17372
17367
|
callID: string;
|
|
17373
17368
|
name: string;
|
|
17374
17369
|
namespace?: string;
|
|
17375
|
-
|
|
17376
|
-
content
|
|
17370
|
+
result: {
|
|
17371
|
+
content: ({
|
|
17377
17372
|
type: "text";
|
|
17378
17373
|
text: string;
|
|
17379
17374
|
textSignature?: string;
|
|
@@ -17383,8 +17378,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17383
17378
|
mimeType: string;
|
|
17384
17379
|
})[];
|
|
17385
17380
|
details?: any;
|
|
17381
|
+
isError: false;
|
|
17386
17382
|
};
|
|
17387
|
-
status: "
|
|
17383
|
+
status: "completed";
|
|
17388
17384
|
thoughtSignature?: string;
|
|
17389
17385
|
time: {
|
|
17390
17386
|
start: number;
|
|
@@ -17408,9 +17404,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17408
17404
|
mimeType: string;
|
|
17409
17405
|
})[];
|
|
17410
17406
|
details?: any;
|
|
17411
|
-
isError:
|
|
17407
|
+
isError: true;
|
|
17412
17408
|
};
|
|
17413
|
-
status: "
|
|
17409
|
+
status: "error";
|
|
17414
17410
|
thoughtSignature?: string;
|
|
17415
17411
|
time: {
|
|
17416
17412
|
start: number;
|
|
@@ -17436,7 +17432,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17436
17432
|
details?: any;
|
|
17437
17433
|
isError: true;
|
|
17438
17434
|
};
|
|
17439
|
-
status: "
|
|
17435
|
+
status: "skipped";
|
|
17440
17436
|
thoughtSignature?: string;
|
|
17441
17437
|
time: {
|
|
17442
17438
|
start: number;
|
|
@@ -17462,21 +17458,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17462
17458
|
details?: any;
|
|
17463
17459
|
isError: true;
|
|
17464
17460
|
};
|
|
17465
|
-
status: "
|
|
17461
|
+
status: "aborted";
|
|
17466
17462
|
thoughtSignature?: string;
|
|
17467
17463
|
time: {
|
|
17468
17464
|
start: number;
|
|
17469
17465
|
end: number;
|
|
17470
17466
|
};
|
|
17471
17467
|
type: "toolCall";
|
|
17468
|
+
} | {
|
|
17469
|
+
type: "thinking";
|
|
17470
|
+
thinking: string;
|
|
17471
|
+
thinkingSignature?: string;
|
|
17472
|
+
redacted?: boolean;
|
|
17472
17473
|
} | {
|
|
17473
17474
|
addedToolNames?: string[];
|
|
17474
17475
|
arguments: Record<string, any>;
|
|
17475
17476
|
callID: string;
|
|
17476
17477
|
name: string;
|
|
17477
17478
|
namespace?: string;
|
|
17478
|
-
|
|
17479
|
-
content
|
|
17479
|
+
partial?: {
|
|
17480
|
+
content?: ({
|
|
17480
17481
|
type: "text";
|
|
17481
17482
|
text: string;
|
|
17482
17483
|
textSignature?: string;
|
|
@@ -17486,9 +17487,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17486
17487
|
mimeType: string;
|
|
17487
17488
|
})[];
|
|
17488
17489
|
details?: any;
|
|
17489
|
-
isError: true;
|
|
17490
17490
|
};
|
|
17491
|
-
status: "
|
|
17491
|
+
status: "running";
|
|
17492
17492
|
thoughtSignature?: string;
|
|
17493
17493
|
time: {
|
|
17494
17494
|
start: number;
|
|
@@ -17663,19 +17663,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17663
17663
|
type: "image";
|
|
17664
17664
|
data: string;
|
|
17665
17665
|
mimeType: string;
|
|
17666
|
-
} | {
|
|
17667
|
-
type: "thinking";
|
|
17668
|
-
thinking: string;
|
|
17669
|
-
thinkingSignature?: string;
|
|
17670
|
-
redacted?: boolean;
|
|
17671
17666
|
} | {
|
|
17672
17667
|
addedToolNames?: string[];
|
|
17673
17668
|
arguments: Record<string, any>;
|
|
17674
17669
|
callID: string;
|
|
17675
17670
|
name: string;
|
|
17676
17671
|
namespace?: string;
|
|
17677
|
-
|
|
17678
|
-
content
|
|
17672
|
+
result: {
|
|
17673
|
+
content: ({
|
|
17679
17674
|
type: "text";
|
|
17680
17675
|
text: string;
|
|
17681
17676
|
textSignature?: string;
|
|
@@ -17685,8 +17680,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17685
17680
|
mimeType: string;
|
|
17686
17681
|
})[];
|
|
17687
17682
|
details?: any;
|
|
17683
|
+
isError: false;
|
|
17688
17684
|
};
|
|
17689
|
-
status: "
|
|
17685
|
+
status: "completed";
|
|
17690
17686
|
thoughtSignature?: string;
|
|
17691
17687
|
time: {
|
|
17692
17688
|
start: number;
|
|
@@ -17710,9 +17706,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17710
17706
|
mimeType: string;
|
|
17711
17707
|
})[];
|
|
17712
17708
|
details?: any;
|
|
17713
|
-
isError:
|
|
17709
|
+
isError: true;
|
|
17714
17710
|
};
|
|
17715
|
-
status: "
|
|
17711
|
+
status: "error";
|
|
17716
17712
|
thoughtSignature?: string;
|
|
17717
17713
|
time: {
|
|
17718
17714
|
start: number;
|
|
@@ -17738,7 +17734,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17738
17734
|
details?: any;
|
|
17739
17735
|
isError: true;
|
|
17740
17736
|
};
|
|
17741
|
-
status: "
|
|
17737
|
+
status: "skipped";
|
|
17742
17738
|
thoughtSignature?: string;
|
|
17743
17739
|
time: {
|
|
17744
17740
|
start: number;
|
|
@@ -17764,21 +17760,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17764
17760
|
details?: any;
|
|
17765
17761
|
isError: true;
|
|
17766
17762
|
};
|
|
17767
|
-
status: "
|
|
17763
|
+
status: "aborted";
|
|
17768
17764
|
thoughtSignature?: string;
|
|
17769
17765
|
time: {
|
|
17770
17766
|
start: number;
|
|
17771
17767
|
end: number;
|
|
17772
17768
|
};
|
|
17773
17769
|
type: "toolCall";
|
|
17770
|
+
} | {
|
|
17771
|
+
type: "thinking";
|
|
17772
|
+
thinking: string;
|
|
17773
|
+
thinkingSignature?: string;
|
|
17774
|
+
redacted?: boolean;
|
|
17774
17775
|
} | {
|
|
17775
17776
|
addedToolNames?: string[];
|
|
17776
17777
|
arguments: Record<string, any>;
|
|
17777
17778
|
callID: string;
|
|
17778
17779
|
name: string;
|
|
17779
17780
|
namespace?: string;
|
|
17780
|
-
|
|
17781
|
-
content
|
|
17781
|
+
partial?: {
|
|
17782
|
+
content?: ({
|
|
17782
17783
|
type: "text";
|
|
17783
17784
|
text: string;
|
|
17784
17785
|
textSignature?: string;
|
|
@@ -17788,9 +17789,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17788
17789
|
mimeType: string;
|
|
17789
17790
|
})[];
|
|
17790
17791
|
details?: any;
|
|
17791
|
-
isError: true;
|
|
17792
17792
|
};
|
|
17793
|
-
status: "
|
|
17793
|
+
status: "running";
|
|
17794
17794
|
thoughtSignature?: string;
|
|
17795
17795
|
time: {
|
|
17796
17796
|
start: number;
|
|
@@ -17984,19 +17984,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17984
17984
|
type: "image";
|
|
17985
17985
|
data: string;
|
|
17986
17986
|
mimeType: string;
|
|
17987
|
-
} | {
|
|
17988
|
-
type: "thinking";
|
|
17989
|
-
thinking: string;
|
|
17990
|
-
thinkingSignature?: string;
|
|
17991
|
-
redacted?: boolean;
|
|
17992
17987
|
} | {
|
|
17993
17988
|
addedToolNames?: string[];
|
|
17994
17989
|
arguments: Record<string, any>;
|
|
17995
17990
|
callID: string;
|
|
17996
17991
|
name: string;
|
|
17997
17992
|
namespace?: string;
|
|
17998
|
-
|
|
17999
|
-
content
|
|
17993
|
+
result: {
|
|
17994
|
+
content: ({
|
|
18000
17995
|
type: "text";
|
|
18001
17996
|
text: string;
|
|
18002
17997
|
textSignature?: string;
|
|
@@ -18006,8 +18001,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18006
18001
|
mimeType: string;
|
|
18007
18002
|
})[];
|
|
18008
18003
|
details?: any;
|
|
18004
|
+
isError: false;
|
|
18009
18005
|
};
|
|
18010
|
-
status: "
|
|
18006
|
+
status: "completed";
|
|
18011
18007
|
thoughtSignature?: string;
|
|
18012
18008
|
time: {
|
|
18013
18009
|
start: number;
|
|
@@ -18031,9 +18027,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18031
18027
|
mimeType: string;
|
|
18032
18028
|
})[];
|
|
18033
18029
|
details?: any;
|
|
18034
|
-
isError:
|
|
18030
|
+
isError: true;
|
|
18035
18031
|
};
|
|
18036
|
-
status: "
|
|
18032
|
+
status: "error";
|
|
18037
18033
|
thoughtSignature?: string;
|
|
18038
18034
|
time: {
|
|
18039
18035
|
start: number;
|
|
@@ -18059,7 +18055,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18059
18055
|
details?: any;
|
|
18060
18056
|
isError: true;
|
|
18061
18057
|
};
|
|
18062
|
-
status: "
|
|
18058
|
+
status: "skipped";
|
|
18063
18059
|
thoughtSignature?: string;
|
|
18064
18060
|
time: {
|
|
18065
18061
|
start: number;
|
|
@@ -18085,21 +18081,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18085
18081
|
details?: any;
|
|
18086
18082
|
isError: true;
|
|
18087
18083
|
};
|
|
18088
|
-
status: "
|
|
18084
|
+
status: "aborted";
|
|
18089
18085
|
thoughtSignature?: string;
|
|
18090
18086
|
time: {
|
|
18091
18087
|
start: number;
|
|
18092
18088
|
end: number;
|
|
18093
18089
|
};
|
|
18094
18090
|
type: "toolCall";
|
|
18091
|
+
} | {
|
|
18092
|
+
type: "thinking";
|
|
18093
|
+
thinking: string;
|
|
18094
|
+
thinkingSignature?: string;
|
|
18095
|
+
redacted?: boolean;
|
|
18095
18096
|
} | {
|
|
18096
18097
|
addedToolNames?: string[];
|
|
18097
18098
|
arguments: Record<string, any>;
|
|
18098
18099
|
callID: string;
|
|
18099
18100
|
name: string;
|
|
18100
18101
|
namespace?: string;
|
|
18101
|
-
|
|
18102
|
-
content
|
|
18102
|
+
partial?: {
|
|
18103
|
+
content?: ({
|
|
18103
18104
|
type: "text";
|
|
18104
18105
|
text: string;
|
|
18105
18106
|
textSignature?: string;
|
|
@@ -18109,9 +18110,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18109
18110
|
mimeType: string;
|
|
18110
18111
|
})[];
|
|
18111
18112
|
details?: any;
|
|
18112
|
-
isError: true;
|
|
18113
18113
|
};
|
|
18114
|
-
status: "
|
|
18114
|
+
status: "running";
|
|
18115
18115
|
thoughtSignature?: string;
|
|
18116
18116
|
time: {
|
|
18117
18117
|
start: number;
|
|
@@ -18286,19 +18286,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18286
18286
|
type: "image";
|
|
18287
18287
|
data: string;
|
|
18288
18288
|
mimeType: string;
|
|
18289
|
-
} | {
|
|
18290
|
-
type: "thinking";
|
|
18291
|
-
thinking: string;
|
|
18292
|
-
thinkingSignature?: string;
|
|
18293
|
-
redacted?: boolean;
|
|
18294
18289
|
} | {
|
|
18295
18290
|
addedToolNames?: string[];
|
|
18296
18291
|
arguments: Record<string, any>;
|
|
18297
18292
|
callID: string;
|
|
18298
18293
|
name: string;
|
|
18299
18294
|
namespace?: string;
|
|
18300
|
-
|
|
18301
|
-
content
|
|
18295
|
+
result: {
|
|
18296
|
+
content: ({
|
|
18302
18297
|
type: "text";
|
|
18303
18298
|
text: string;
|
|
18304
18299
|
textSignature?: string;
|
|
@@ -18308,8 +18303,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18308
18303
|
mimeType: string;
|
|
18309
18304
|
})[];
|
|
18310
18305
|
details?: any;
|
|
18306
|
+
isError: false;
|
|
18311
18307
|
};
|
|
18312
|
-
status: "
|
|
18308
|
+
status: "completed";
|
|
18313
18309
|
thoughtSignature?: string;
|
|
18314
18310
|
time: {
|
|
18315
18311
|
start: number;
|
|
@@ -18333,9 +18329,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18333
18329
|
mimeType: string;
|
|
18334
18330
|
})[];
|
|
18335
18331
|
details?: any;
|
|
18336
|
-
isError:
|
|
18332
|
+
isError: true;
|
|
18337
18333
|
};
|
|
18338
|
-
status: "
|
|
18334
|
+
status: "error";
|
|
18339
18335
|
thoughtSignature?: string;
|
|
18340
18336
|
time: {
|
|
18341
18337
|
start: number;
|
|
@@ -18361,7 +18357,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18361
18357
|
details?: any;
|
|
18362
18358
|
isError: true;
|
|
18363
18359
|
};
|
|
18364
|
-
status: "
|
|
18360
|
+
status: "skipped";
|
|
18365
18361
|
thoughtSignature?: string;
|
|
18366
18362
|
time: {
|
|
18367
18363
|
start: number;
|
|
@@ -18387,21 +18383,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18387
18383
|
details?: any;
|
|
18388
18384
|
isError: true;
|
|
18389
18385
|
};
|
|
18390
|
-
status: "
|
|
18386
|
+
status: "aborted";
|
|
18391
18387
|
thoughtSignature?: string;
|
|
18392
18388
|
time: {
|
|
18393
18389
|
start: number;
|
|
18394
18390
|
end: number;
|
|
18395
18391
|
};
|
|
18396
18392
|
type: "toolCall";
|
|
18393
|
+
} | {
|
|
18394
|
+
type: "thinking";
|
|
18395
|
+
thinking: string;
|
|
18396
|
+
thinkingSignature?: string;
|
|
18397
|
+
redacted?: boolean;
|
|
18397
18398
|
} | {
|
|
18398
18399
|
addedToolNames?: string[];
|
|
18399
18400
|
arguments: Record<string, any>;
|
|
18400
18401
|
callID: string;
|
|
18401
18402
|
name: string;
|
|
18402
18403
|
namespace?: string;
|
|
18403
|
-
|
|
18404
|
-
content
|
|
18404
|
+
partial?: {
|
|
18405
|
+
content?: ({
|
|
18405
18406
|
type: "text";
|
|
18406
18407
|
text: string;
|
|
18407
18408
|
textSignature?: string;
|
|
@@ -18411,9 +18412,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18411
18412
|
mimeType: string;
|
|
18412
18413
|
})[];
|
|
18413
18414
|
details?: any;
|
|
18414
|
-
isError: true;
|
|
18415
18415
|
};
|
|
18416
|
-
status: "
|
|
18416
|
+
status: "running";
|
|
18417
18417
|
thoughtSignature?: string;
|
|
18418
18418
|
time: {
|
|
18419
18419
|
start: number;
|
|
@@ -18616,19 +18616,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18616
18616
|
type: "image";
|
|
18617
18617
|
data: string;
|
|
18618
18618
|
mimeType: string;
|
|
18619
|
-
} | {
|
|
18620
|
-
type: "thinking";
|
|
18621
|
-
thinking: string;
|
|
18622
|
-
thinkingSignature?: string;
|
|
18623
|
-
redacted?: boolean;
|
|
18624
18619
|
} | {
|
|
18625
18620
|
addedToolNames?: string[];
|
|
18626
18621
|
arguments: Record<string, any>;
|
|
18627
18622
|
callID: string;
|
|
18628
18623
|
name: string;
|
|
18629
18624
|
namespace?: string;
|
|
18630
|
-
|
|
18631
|
-
content
|
|
18625
|
+
result: {
|
|
18626
|
+
content: ({
|
|
18632
18627
|
type: "text";
|
|
18633
18628
|
text: string;
|
|
18634
18629
|
textSignature?: string;
|
|
@@ -18638,8 +18633,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18638
18633
|
mimeType: string;
|
|
18639
18634
|
})[];
|
|
18640
18635
|
details?: any;
|
|
18636
|
+
isError: false;
|
|
18641
18637
|
};
|
|
18642
|
-
status: "
|
|
18638
|
+
status: "completed";
|
|
18643
18639
|
thoughtSignature?: string;
|
|
18644
18640
|
time: {
|
|
18645
18641
|
start: number;
|
|
@@ -18663,9 +18659,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18663
18659
|
mimeType: string;
|
|
18664
18660
|
})[];
|
|
18665
18661
|
details?: any;
|
|
18666
|
-
isError:
|
|
18662
|
+
isError: true;
|
|
18667
18663
|
};
|
|
18668
|
-
status: "
|
|
18664
|
+
status: "error";
|
|
18669
18665
|
thoughtSignature?: string;
|
|
18670
18666
|
time: {
|
|
18671
18667
|
start: number;
|
|
@@ -18691,7 +18687,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18691
18687
|
details?: any;
|
|
18692
18688
|
isError: true;
|
|
18693
18689
|
};
|
|
18694
|
-
status: "
|
|
18690
|
+
status: "skipped";
|
|
18695
18691
|
thoughtSignature?: string;
|
|
18696
18692
|
time: {
|
|
18697
18693
|
start: number;
|
|
@@ -18717,21 +18713,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18717
18713
|
details?: any;
|
|
18718
18714
|
isError: true;
|
|
18719
18715
|
};
|
|
18720
|
-
status: "
|
|
18716
|
+
status: "aborted";
|
|
18721
18717
|
thoughtSignature?: string;
|
|
18722
18718
|
time: {
|
|
18723
18719
|
start: number;
|
|
18724
18720
|
end: number;
|
|
18725
18721
|
};
|
|
18726
18722
|
type: "toolCall";
|
|
18723
|
+
} | {
|
|
18724
|
+
type: "thinking";
|
|
18725
|
+
thinking: string;
|
|
18726
|
+
thinkingSignature?: string;
|
|
18727
|
+
redacted?: boolean;
|
|
18727
18728
|
} | {
|
|
18728
18729
|
addedToolNames?: string[];
|
|
18729
18730
|
arguments: Record<string, any>;
|
|
18730
18731
|
callID: string;
|
|
18731
18732
|
name: string;
|
|
18732
18733
|
namespace?: string;
|
|
18733
|
-
|
|
18734
|
-
content
|
|
18734
|
+
partial?: {
|
|
18735
|
+
content?: ({
|
|
18735
18736
|
type: "text";
|
|
18736
18737
|
text: string;
|
|
18737
18738
|
textSignature?: string;
|
|
@@ -18741,9 +18742,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18741
18742
|
mimeType: string;
|
|
18742
18743
|
})[];
|
|
18743
18744
|
details?: any;
|
|
18744
|
-
isError: true;
|
|
18745
18745
|
};
|
|
18746
|
-
status: "
|
|
18746
|
+
status: "running";
|
|
18747
18747
|
thoughtSignature?: string;
|
|
18748
18748
|
time: {
|
|
18749
18749
|
start: number;
|
|
@@ -18918,19 +18918,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18918
18918
|
type: "image";
|
|
18919
18919
|
data: string;
|
|
18920
18920
|
mimeType: string;
|
|
18921
|
-
} | {
|
|
18922
|
-
type: "thinking";
|
|
18923
|
-
thinking: string;
|
|
18924
|
-
thinkingSignature?: string;
|
|
18925
|
-
redacted?: boolean;
|
|
18926
18921
|
} | {
|
|
18927
18922
|
addedToolNames?: string[];
|
|
18928
18923
|
arguments: Record<string, any>;
|
|
18929
18924
|
callID: string;
|
|
18930
18925
|
name: string;
|
|
18931
18926
|
namespace?: string;
|
|
18932
|
-
|
|
18933
|
-
content
|
|
18927
|
+
result: {
|
|
18928
|
+
content: ({
|
|
18934
18929
|
type: "text";
|
|
18935
18930
|
text: string;
|
|
18936
18931
|
textSignature?: string;
|
|
@@ -18940,8 +18935,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18940
18935
|
mimeType: string;
|
|
18941
18936
|
})[];
|
|
18942
18937
|
details?: any;
|
|
18938
|
+
isError: false;
|
|
18943
18939
|
};
|
|
18944
|
-
status: "
|
|
18940
|
+
status: "completed";
|
|
18945
18941
|
thoughtSignature?: string;
|
|
18946
18942
|
time: {
|
|
18947
18943
|
start: number;
|
|
@@ -18965,9 +18961,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18965
18961
|
mimeType: string;
|
|
18966
18962
|
})[];
|
|
18967
18963
|
details?: any;
|
|
18968
|
-
isError:
|
|
18964
|
+
isError: true;
|
|
18969
18965
|
};
|
|
18970
|
-
status: "
|
|
18966
|
+
status: "error";
|
|
18971
18967
|
thoughtSignature?: string;
|
|
18972
18968
|
time: {
|
|
18973
18969
|
start: number;
|
|
@@ -18993,7 +18989,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18993
18989
|
details?: any;
|
|
18994
18990
|
isError: true;
|
|
18995
18991
|
};
|
|
18996
|
-
status: "
|
|
18992
|
+
status: "skipped";
|
|
18997
18993
|
thoughtSignature?: string;
|
|
18998
18994
|
time: {
|
|
18999
18995
|
start: number;
|
|
@@ -19019,21 +19015,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19019
19015
|
details?: any;
|
|
19020
19016
|
isError: true;
|
|
19021
19017
|
};
|
|
19022
|
-
status: "
|
|
19018
|
+
status: "aborted";
|
|
19023
19019
|
thoughtSignature?: string;
|
|
19024
19020
|
time: {
|
|
19025
19021
|
start: number;
|
|
19026
19022
|
end: number;
|
|
19027
19023
|
};
|
|
19028
19024
|
type: "toolCall";
|
|
19025
|
+
} | {
|
|
19026
|
+
type: "thinking";
|
|
19027
|
+
thinking: string;
|
|
19028
|
+
thinkingSignature?: string;
|
|
19029
|
+
redacted?: boolean;
|
|
19029
19030
|
} | {
|
|
19030
19031
|
addedToolNames?: string[];
|
|
19031
19032
|
arguments: Record<string, any>;
|
|
19032
19033
|
callID: string;
|
|
19033
19034
|
name: string;
|
|
19034
19035
|
namespace?: string;
|
|
19035
|
-
|
|
19036
|
-
content
|
|
19036
|
+
partial?: {
|
|
19037
|
+
content?: ({
|
|
19037
19038
|
type: "text";
|
|
19038
19039
|
text: string;
|
|
19039
19040
|
textSignature?: string;
|
|
@@ -19043,9 +19044,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19043
19044
|
mimeType: string;
|
|
19044
19045
|
})[];
|
|
19045
19046
|
details?: any;
|
|
19046
|
-
isError: true;
|
|
19047
19047
|
};
|
|
19048
|
-
status: "
|
|
19048
|
+
status: "running";
|
|
19049
19049
|
thoughtSignature?: string;
|
|
19050
19050
|
time: {
|
|
19051
19051
|
start: number;
|
|
@@ -19239,19 +19239,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19239
19239
|
type: "image";
|
|
19240
19240
|
data: string;
|
|
19241
19241
|
mimeType: string;
|
|
19242
|
-
} | {
|
|
19243
|
-
type: "thinking";
|
|
19244
|
-
thinking: string;
|
|
19245
|
-
thinkingSignature?: string;
|
|
19246
|
-
redacted?: boolean;
|
|
19247
19242
|
} | {
|
|
19248
19243
|
addedToolNames?: string[];
|
|
19249
19244
|
arguments: Record<string, any>;
|
|
19250
19245
|
callID: string;
|
|
19251
19246
|
name: string;
|
|
19252
19247
|
namespace?: string;
|
|
19253
|
-
|
|
19254
|
-
content
|
|
19248
|
+
result: {
|
|
19249
|
+
content: ({
|
|
19255
19250
|
type: "text";
|
|
19256
19251
|
text: string;
|
|
19257
19252
|
textSignature?: string;
|
|
@@ -19261,8 +19256,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19261
19256
|
mimeType: string;
|
|
19262
19257
|
})[];
|
|
19263
19258
|
details?: any;
|
|
19259
|
+
isError: false;
|
|
19264
19260
|
};
|
|
19265
|
-
status: "
|
|
19261
|
+
status: "completed";
|
|
19266
19262
|
thoughtSignature?: string;
|
|
19267
19263
|
time: {
|
|
19268
19264
|
start: number;
|
|
@@ -19286,9 +19282,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19286
19282
|
mimeType: string;
|
|
19287
19283
|
})[];
|
|
19288
19284
|
details?: any;
|
|
19289
|
-
isError:
|
|
19285
|
+
isError: true;
|
|
19290
19286
|
};
|
|
19291
|
-
status: "
|
|
19287
|
+
status: "error";
|
|
19292
19288
|
thoughtSignature?: string;
|
|
19293
19289
|
time: {
|
|
19294
19290
|
start: number;
|
|
@@ -19314,7 +19310,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19314
19310
|
details?: any;
|
|
19315
19311
|
isError: true;
|
|
19316
19312
|
};
|
|
19317
|
-
status: "
|
|
19313
|
+
status: "skipped";
|
|
19318
19314
|
thoughtSignature?: string;
|
|
19319
19315
|
time: {
|
|
19320
19316
|
start: number;
|
|
@@ -19340,21 +19336,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19340
19336
|
details?: any;
|
|
19341
19337
|
isError: true;
|
|
19342
19338
|
};
|
|
19343
|
-
status: "
|
|
19339
|
+
status: "aborted";
|
|
19344
19340
|
thoughtSignature?: string;
|
|
19345
19341
|
time: {
|
|
19346
19342
|
start: number;
|
|
19347
19343
|
end: number;
|
|
19348
19344
|
};
|
|
19349
19345
|
type: "toolCall";
|
|
19346
|
+
} | {
|
|
19347
|
+
type: "thinking";
|
|
19348
|
+
thinking: string;
|
|
19349
|
+
thinkingSignature?: string;
|
|
19350
|
+
redacted?: boolean;
|
|
19350
19351
|
} | {
|
|
19351
19352
|
addedToolNames?: string[];
|
|
19352
19353
|
arguments: Record<string, any>;
|
|
19353
19354
|
callID: string;
|
|
19354
19355
|
name: string;
|
|
19355
19356
|
namespace?: string;
|
|
19356
|
-
|
|
19357
|
-
content
|
|
19357
|
+
partial?: {
|
|
19358
|
+
content?: ({
|
|
19358
19359
|
type: "text";
|
|
19359
19360
|
text: string;
|
|
19360
19361
|
textSignature?: string;
|
|
@@ -19364,9 +19365,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19364
19365
|
mimeType: string;
|
|
19365
19366
|
})[];
|
|
19366
19367
|
details?: any;
|
|
19367
|
-
isError: true;
|
|
19368
19368
|
};
|
|
19369
|
-
status: "
|
|
19369
|
+
status: "running";
|
|
19370
19370
|
thoughtSignature?: string;
|
|
19371
19371
|
time: {
|
|
19372
19372
|
start: number;
|
|
@@ -19541,19 +19541,14 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19541
19541
|
type: "image";
|
|
19542
19542
|
data: string;
|
|
19543
19543
|
mimeType: string;
|
|
19544
|
-
} | {
|
|
19545
|
-
type: "thinking";
|
|
19546
|
-
thinking: string;
|
|
19547
|
-
thinkingSignature?: string;
|
|
19548
|
-
redacted?: boolean;
|
|
19549
19544
|
} | {
|
|
19550
19545
|
addedToolNames?: string[];
|
|
19551
19546
|
arguments: Record<string, any>;
|
|
19552
19547
|
callID: string;
|
|
19553
19548
|
name: string;
|
|
19554
19549
|
namespace?: string;
|
|
19555
|
-
|
|
19556
|
-
content
|
|
19550
|
+
result: {
|
|
19551
|
+
content: ({
|
|
19557
19552
|
type: "text";
|
|
19558
19553
|
text: string;
|
|
19559
19554
|
textSignature?: string;
|
|
@@ -19563,8 +19558,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19563
19558
|
mimeType: string;
|
|
19564
19559
|
})[];
|
|
19565
19560
|
details?: any;
|
|
19561
|
+
isError: false;
|
|
19566
19562
|
};
|
|
19567
|
-
status: "
|
|
19563
|
+
status: "completed";
|
|
19568
19564
|
thoughtSignature?: string;
|
|
19569
19565
|
time: {
|
|
19570
19566
|
start: number;
|
|
@@ -19588,9 +19584,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19588
19584
|
mimeType: string;
|
|
19589
19585
|
})[];
|
|
19590
19586
|
details?: any;
|
|
19591
|
-
isError:
|
|
19587
|
+
isError: true;
|
|
19592
19588
|
};
|
|
19593
|
-
status: "
|
|
19589
|
+
status: "error";
|
|
19594
19590
|
thoughtSignature?: string;
|
|
19595
19591
|
time: {
|
|
19596
19592
|
start: number;
|
|
@@ -19616,7 +19612,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19616
19612
|
details?: any;
|
|
19617
19613
|
isError: true;
|
|
19618
19614
|
};
|
|
19619
|
-
status: "
|
|
19615
|
+
status: "skipped";
|
|
19620
19616
|
thoughtSignature?: string;
|
|
19621
19617
|
time: {
|
|
19622
19618
|
start: number;
|
|
@@ -19642,21 +19638,26 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19642
19638
|
details?: any;
|
|
19643
19639
|
isError: true;
|
|
19644
19640
|
};
|
|
19645
|
-
status: "
|
|
19641
|
+
status: "aborted";
|
|
19646
19642
|
thoughtSignature?: string;
|
|
19647
19643
|
time: {
|
|
19648
19644
|
start: number;
|
|
19649
19645
|
end: number;
|
|
19650
19646
|
};
|
|
19651
19647
|
type: "toolCall";
|
|
19648
|
+
} | {
|
|
19649
|
+
type: "thinking";
|
|
19650
|
+
thinking: string;
|
|
19651
|
+
thinkingSignature?: string;
|
|
19652
|
+
redacted?: boolean;
|
|
19652
19653
|
} | {
|
|
19653
19654
|
addedToolNames?: string[];
|
|
19654
19655
|
arguments: Record<string, any>;
|
|
19655
19656
|
callID: string;
|
|
19656
19657
|
name: string;
|
|
19657
19658
|
namespace?: string;
|
|
19658
|
-
|
|
19659
|
-
content
|
|
19659
|
+
partial?: {
|
|
19660
|
+
content?: ({
|
|
19660
19661
|
type: "text";
|
|
19661
19662
|
text: string;
|
|
19662
19663
|
textSignature?: string;
|
|
@@ -19666,9 +19667,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19666
19667
|
mimeType: string;
|
|
19667
19668
|
})[];
|
|
19668
19669
|
details?: any;
|
|
19669
|
-
isError: true;
|
|
19670
19670
|
};
|
|
19671
|
-
status: "
|
|
19671
|
+
status: "running";
|
|
19672
19672
|
thoughtSignature?: string;
|
|
19673
19673
|
time: {
|
|
19674
19674
|
start: number;
|
|
@@ -20856,19 +20856,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20856
20856
|
type: "image";
|
|
20857
20857
|
data: string;
|
|
20858
20858
|
mimeType: string;
|
|
20859
|
-
} | {
|
|
20860
|
-
type: "thinking";
|
|
20861
|
-
thinking: string;
|
|
20862
|
-
thinkingSignature?: string;
|
|
20863
|
-
redacted?: boolean;
|
|
20864
20859
|
} | {
|
|
20865
20860
|
addedToolNames?: string[];
|
|
20866
20861
|
arguments: Record<string, any>;
|
|
20867
20862
|
callID: string;
|
|
20868
20863
|
name: string;
|
|
20869
20864
|
namespace?: string;
|
|
20870
|
-
|
|
20871
|
-
content
|
|
20865
|
+
result: {
|
|
20866
|
+
content: ({
|
|
20872
20867
|
type: "text";
|
|
20873
20868
|
text: string;
|
|
20874
20869
|
textSignature?: string;
|
|
@@ -20878,8 +20873,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20878
20873
|
mimeType: string;
|
|
20879
20874
|
})[];
|
|
20880
20875
|
details?: any;
|
|
20876
|
+
isError: false;
|
|
20881
20877
|
};
|
|
20882
|
-
status: "
|
|
20878
|
+
status: "completed";
|
|
20883
20879
|
thoughtSignature?: string;
|
|
20884
20880
|
time: {
|
|
20885
20881
|
start: number;
|
|
@@ -20903,9 +20899,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20903
20899
|
mimeType: string;
|
|
20904
20900
|
})[];
|
|
20905
20901
|
details?: any;
|
|
20906
|
-
isError:
|
|
20902
|
+
isError: true;
|
|
20907
20903
|
};
|
|
20908
|
-
status: "
|
|
20904
|
+
status: "error";
|
|
20909
20905
|
thoughtSignature?: string;
|
|
20910
20906
|
time: {
|
|
20911
20907
|
start: number;
|
|
@@ -20931,7 +20927,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20931
20927
|
details?: any;
|
|
20932
20928
|
isError: true;
|
|
20933
20929
|
};
|
|
20934
|
-
status: "
|
|
20930
|
+
status: "skipped";
|
|
20935
20931
|
thoughtSignature?: string;
|
|
20936
20932
|
time: {
|
|
20937
20933
|
start: number;
|
|
@@ -20957,21 +20953,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20957
20953
|
details?: any;
|
|
20958
20954
|
isError: true;
|
|
20959
20955
|
};
|
|
20960
|
-
status: "
|
|
20956
|
+
status: "aborted";
|
|
20961
20957
|
thoughtSignature?: string;
|
|
20962
20958
|
time: {
|
|
20963
20959
|
start: number;
|
|
20964
20960
|
end: number;
|
|
20965
20961
|
};
|
|
20966
20962
|
type: "toolCall";
|
|
20963
|
+
} | {
|
|
20964
|
+
type: "thinking";
|
|
20965
|
+
thinking: string;
|
|
20966
|
+
thinkingSignature?: string;
|
|
20967
|
+
redacted?: boolean;
|
|
20967
20968
|
} | {
|
|
20968
20969
|
addedToolNames?: string[];
|
|
20969
20970
|
arguments: Record<string, any>;
|
|
20970
20971
|
callID: string;
|
|
20971
20972
|
name: string;
|
|
20972
20973
|
namespace?: string;
|
|
20973
|
-
|
|
20974
|
-
content
|
|
20974
|
+
partial?: {
|
|
20975
|
+
content?: ({
|
|
20975
20976
|
type: "text";
|
|
20976
20977
|
text: string;
|
|
20977
20978
|
textSignature?: string;
|
|
@@ -20981,9 +20982,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20981
20982
|
mimeType: string;
|
|
20982
20983
|
})[];
|
|
20983
20984
|
details?: any;
|
|
20984
|
-
isError: true;
|
|
20985
20985
|
};
|
|
20986
|
-
status: "
|
|
20986
|
+
status: "running";
|
|
20987
20987
|
thoughtSignature?: string;
|
|
20988
20988
|
time: {
|
|
20989
20989
|
start: number;
|
|
@@ -21158,19 +21158,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21158
21158
|
type: "image";
|
|
21159
21159
|
data: string;
|
|
21160
21160
|
mimeType: string;
|
|
21161
|
-
} | {
|
|
21162
|
-
type: "thinking";
|
|
21163
|
-
thinking: string;
|
|
21164
|
-
thinkingSignature?: string;
|
|
21165
|
-
redacted?: boolean;
|
|
21166
21161
|
} | {
|
|
21167
21162
|
addedToolNames?: string[];
|
|
21168
21163
|
arguments: Record<string, any>;
|
|
21169
21164
|
callID: string;
|
|
21170
21165
|
name: string;
|
|
21171
21166
|
namespace?: string;
|
|
21172
|
-
|
|
21173
|
-
content
|
|
21167
|
+
result: {
|
|
21168
|
+
content: ({
|
|
21174
21169
|
type: "text";
|
|
21175
21170
|
text: string;
|
|
21176
21171
|
textSignature?: string;
|
|
@@ -21180,8 +21175,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21180
21175
|
mimeType: string;
|
|
21181
21176
|
})[];
|
|
21182
21177
|
details?: any;
|
|
21178
|
+
isError: false;
|
|
21183
21179
|
};
|
|
21184
|
-
status: "
|
|
21180
|
+
status: "completed";
|
|
21185
21181
|
thoughtSignature?: string;
|
|
21186
21182
|
time: {
|
|
21187
21183
|
start: number;
|
|
@@ -21205,9 +21201,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21205
21201
|
mimeType: string;
|
|
21206
21202
|
})[];
|
|
21207
21203
|
details?: any;
|
|
21208
|
-
isError:
|
|
21204
|
+
isError: true;
|
|
21209
21205
|
};
|
|
21210
|
-
status: "
|
|
21206
|
+
status: "error";
|
|
21211
21207
|
thoughtSignature?: string;
|
|
21212
21208
|
time: {
|
|
21213
21209
|
start: number;
|
|
@@ -21233,7 +21229,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21233
21229
|
details?: any;
|
|
21234
21230
|
isError: true;
|
|
21235
21231
|
};
|
|
21236
|
-
status: "
|
|
21232
|
+
status: "skipped";
|
|
21237
21233
|
thoughtSignature?: string;
|
|
21238
21234
|
time: {
|
|
21239
21235
|
start: number;
|
|
@@ -21259,21 +21255,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21259
21255
|
details?: any;
|
|
21260
21256
|
isError: true;
|
|
21261
21257
|
};
|
|
21262
|
-
status: "
|
|
21258
|
+
status: "aborted";
|
|
21263
21259
|
thoughtSignature?: string;
|
|
21264
21260
|
time: {
|
|
21265
21261
|
start: number;
|
|
21266
21262
|
end: number;
|
|
21267
21263
|
};
|
|
21268
21264
|
type: "toolCall";
|
|
21265
|
+
} | {
|
|
21266
|
+
type: "thinking";
|
|
21267
|
+
thinking: string;
|
|
21268
|
+
thinkingSignature?: string;
|
|
21269
|
+
redacted?: boolean;
|
|
21269
21270
|
} | {
|
|
21270
21271
|
addedToolNames?: string[];
|
|
21271
21272
|
arguments: Record<string, any>;
|
|
21272
21273
|
callID: string;
|
|
21273
21274
|
name: string;
|
|
21274
21275
|
namespace?: string;
|
|
21275
|
-
|
|
21276
|
-
content
|
|
21276
|
+
partial?: {
|
|
21277
|
+
content?: ({
|
|
21277
21278
|
type: "text";
|
|
21278
21279
|
text: string;
|
|
21279
21280
|
textSignature?: string;
|
|
@@ -21283,9 +21284,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21283
21284
|
mimeType: string;
|
|
21284
21285
|
})[];
|
|
21285
21286
|
details?: any;
|
|
21286
|
-
isError: true;
|
|
21287
21287
|
};
|
|
21288
|
-
status: "
|
|
21288
|
+
status: "running";
|
|
21289
21289
|
thoughtSignature?: string;
|
|
21290
21290
|
time: {
|
|
21291
21291
|
start: number;
|
|
@@ -21478,19 +21478,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21478
21478
|
type: "image";
|
|
21479
21479
|
data: string;
|
|
21480
21480
|
mimeType: string;
|
|
21481
|
-
} | {
|
|
21482
|
-
type: "thinking";
|
|
21483
|
-
thinking: string;
|
|
21484
|
-
thinkingSignature?: string;
|
|
21485
|
-
redacted?: boolean;
|
|
21486
21481
|
} | {
|
|
21487
21482
|
addedToolNames?: string[];
|
|
21488
21483
|
arguments: Record<string, any>;
|
|
21489
21484
|
callID: string;
|
|
21490
21485
|
name: string;
|
|
21491
21486
|
namespace?: string;
|
|
21492
|
-
|
|
21493
|
-
content
|
|
21487
|
+
result: {
|
|
21488
|
+
content: ({
|
|
21494
21489
|
type: "text";
|
|
21495
21490
|
text: string;
|
|
21496
21491
|
textSignature?: string;
|
|
@@ -21500,8 +21495,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21500
21495
|
mimeType: string;
|
|
21501
21496
|
})[];
|
|
21502
21497
|
details?: any;
|
|
21498
|
+
isError: false;
|
|
21503
21499
|
};
|
|
21504
|
-
status: "
|
|
21500
|
+
status: "completed";
|
|
21505
21501
|
thoughtSignature?: string;
|
|
21506
21502
|
time: {
|
|
21507
21503
|
start: number;
|
|
@@ -21525,9 +21521,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21525
21521
|
mimeType: string;
|
|
21526
21522
|
})[];
|
|
21527
21523
|
details?: any;
|
|
21528
|
-
isError:
|
|
21524
|
+
isError: true;
|
|
21529
21525
|
};
|
|
21530
|
-
status: "
|
|
21526
|
+
status: "error";
|
|
21531
21527
|
thoughtSignature?: string;
|
|
21532
21528
|
time: {
|
|
21533
21529
|
start: number;
|
|
@@ -21553,7 +21549,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21553
21549
|
details?: any;
|
|
21554
21550
|
isError: true;
|
|
21555
21551
|
};
|
|
21556
|
-
status: "
|
|
21552
|
+
status: "skipped";
|
|
21557
21553
|
thoughtSignature?: string;
|
|
21558
21554
|
time: {
|
|
21559
21555
|
start: number;
|
|
@@ -21579,21 +21575,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21579
21575
|
details?: any;
|
|
21580
21576
|
isError: true;
|
|
21581
21577
|
};
|
|
21582
|
-
status: "
|
|
21578
|
+
status: "aborted";
|
|
21583
21579
|
thoughtSignature?: string;
|
|
21584
21580
|
time: {
|
|
21585
21581
|
start: number;
|
|
21586
21582
|
end: number;
|
|
21587
21583
|
};
|
|
21588
21584
|
type: "toolCall";
|
|
21585
|
+
} | {
|
|
21586
|
+
type: "thinking";
|
|
21587
|
+
thinking: string;
|
|
21588
|
+
thinkingSignature?: string;
|
|
21589
|
+
redacted?: boolean;
|
|
21589
21590
|
} | {
|
|
21590
21591
|
addedToolNames?: string[];
|
|
21591
21592
|
arguments: Record<string, any>;
|
|
21592
21593
|
callID: string;
|
|
21593
21594
|
name: string;
|
|
21594
21595
|
namespace?: string;
|
|
21595
|
-
|
|
21596
|
-
content
|
|
21596
|
+
partial?: {
|
|
21597
|
+
content?: ({
|
|
21597
21598
|
type: "text";
|
|
21598
21599
|
text: string;
|
|
21599
21600
|
textSignature?: string;
|
|
@@ -21603,9 +21604,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21603
21604
|
mimeType: string;
|
|
21604
21605
|
})[];
|
|
21605
21606
|
details?: any;
|
|
21606
|
-
isError: true;
|
|
21607
21607
|
};
|
|
21608
|
-
status: "
|
|
21608
|
+
status: "running";
|
|
21609
21609
|
thoughtSignature?: string;
|
|
21610
21610
|
time: {
|
|
21611
21611
|
start: number;
|
|
@@ -21780,19 +21780,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21780
21780
|
type: "image";
|
|
21781
21781
|
data: string;
|
|
21782
21782
|
mimeType: string;
|
|
21783
|
-
} | {
|
|
21784
|
-
type: "thinking";
|
|
21785
|
-
thinking: string;
|
|
21786
|
-
thinkingSignature?: string;
|
|
21787
|
-
redacted?: boolean;
|
|
21788
21783
|
} | {
|
|
21789
21784
|
addedToolNames?: string[];
|
|
21790
21785
|
arguments: Record<string, any>;
|
|
21791
21786
|
callID: string;
|
|
21792
21787
|
name: string;
|
|
21793
21788
|
namespace?: string;
|
|
21794
|
-
|
|
21795
|
-
content
|
|
21789
|
+
result: {
|
|
21790
|
+
content: ({
|
|
21796
21791
|
type: "text";
|
|
21797
21792
|
text: string;
|
|
21798
21793
|
textSignature?: string;
|
|
@@ -21802,8 +21797,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21802
21797
|
mimeType: string;
|
|
21803
21798
|
})[];
|
|
21804
21799
|
details?: any;
|
|
21800
|
+
isError: false;
|
|
21805
21801
|
};
|
|
21806
|
-
status: "
|
|
21802
|
+
status: "completed";
|
|
21807
21803
|
thoughtSignature?: string;
|
|
21808
21804
|
time: {
|
|
21809
21805
|
start: number;
|
|
@@ -21827,9 +21823,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21827
21823
|
mimeType: string;
|
|
21828
21824
|
})[];
|
|
21829
21825
|
details?: any;
|
|
21830
|
-
isError:
|
|
21826
|
+
isError: true;
|
|
21831
21827
|
};
|
|
21832
|
-
status: "
|
|
21828
|
+
status: "error";
|
|
21833
21829
|
thoughtSignature?: string;
|
|
21834
21830
|
time: {
|
|
21835
21831
|
start: number;
|
|
@@ -21855,7 +21851,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21855
21851
|
details?: any;
|
|
21856
21852
|
isError: true;
|
|
21857
21853
|
};
|
|
21858
|
-
status: "
|
|
21854
|
+
status: "skipped";
|
|
21859
21855
|
thoughtSignature?: string;
|
|
21860
21856
|
time: {
|
|
21861
21857
|
start: number;
|
|
@@ -21881,21 +21877,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21881
21877
|
details?: any;
|
|
21882
21878
|
isError: true;
|
|
21883
21879
|
};
|
|
21884
|
-
status: "
|
|
21880
|
+
status: "aborted";
|
|
21885
21881
|
thoughtSignature?: string;
|
|
21886
21882
|
time: {
|
|
21887
21883
|
start: number;
|
|
21888
21884
|
end: number;
|
|
21889
21885
|
};
|
|
21890
21886
|
type: "toolCall";
|
|
21887
|
+
} | {
|
|
21888
|
+
type: "thinking";
|
|
21889
|
+
thinking: string;
|
|
21890
|
+
thinkingSignature?: string;
|
|
21891
|
+
redacted?: boolean;
|
|
21891
21892
|
} | {
|
|
21892
21893
|
addedToolNames?: string[];
|
|
21893
21894
|
arguments: Record<string, any>;
|
|
21894
21895
|
callID: string;
|
|
21895
21896
|
name: string;
|
|
21896
21897
|
namespace?: string;
|
|
21897
|
-
|
|
21898
|
-
content
|
|
21898
|
+
partial?: {
|
|
21899
|
+
content?: ({
|
|
21899
21900
|
type: "text";
|
|
21900
21901
|
text: string;
|
|
21901
21902
|
textSignature?: string;
|
|
@@ -21905,9 +21906,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21905
21906
|
mimeType: string;
|
|
21906
21907
|
})[];
|
|
21907
21908
|
details?: any;
|
|
21908
|
-
isError: true;
|
|
21909
21909
|
};
|
|
21910
|
-
status: "
|
|
21910
|
+
status: "running";
|
|
21911
21911
|
thoughtSignature?: string;
|
|
21912
21912
|
time: {
|
|
21913
21913
|
start: number;
|
|
@@ -22110,19 +22110,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22110
22110
|
type: "image";
|
|
22111
22111
|
data: string;
|
|
22112
22112
|
mimeType: string;
|
|
22113
|
-
} | {
|
|
22114
|
-
type: "thinking";
|
|
22115
|
-
thinking: string;
|
|
22116
|
-
thinkingSignature?: string;
|
|
22117
|
-
redacted?: boolean;
|
|
22118
22113
|
} | {
|
|
22119
22114
|
addedToolNames?: string[];
|
|
22120
22115
|
arguments: Record<string, any>;
|
|
22121
22116
|
callID: string;
|
|
22122
22117
|
name: string;
|
|
22123
22118
|
namespace?: string;
|
|
22124
|
-
|
|
22125
|
-
content
|
|
22119
|
+
result: {
|
|
22120
|
+
content: ({
|
|
22126
22121
|
type: "text";
|
|
22127
22122
|
text: string;
|
|
22128
22123
|
textSignature?: string;
|
|
@@ -22132,8 +22127,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22132
22127
|
mimeType: string;
|
|
22133
22128
|
})[];
|
|
22134
22129
|
details?: any;
|
|
22130
|
+
isError: false;
|
|
22135
22131
|
};
|
|
22136
|
-
status: "
|
|
22132
|
+
status: "completed";
|
|
22137
22133
|
thoughtSignature?: string;
|
|
22138
22134
|
time: {
|
|
22139
22135
|
start: number;
|
|
@@ -22157,9 +22153,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22157
22153
|
mimeType: string;
|
|
22158
22154
|
})[];
|
|
22159
22155
|
details?: any;
|
|
22160
|
-
isError:
|
|
22156
|
+
isError: true;
|
|
22161
22157
|
};
|
|
22162
|
-
status: "
|
|
22158
|
+
status: "error";
|
|
22163
22159
|
thoughtSignature?: string;
|
|
22164
22160
|
time: {
|
|
22165
22161
|
start: number;
|
|
@@ -22185,7 +22181,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22185
22181
|
details?: any;
|
|
22186
22182
|
isError: true;
|
|
22187
22183
|
};
|
|
22188
|
-
status: "
|
|
22184
|
+
status: "skipped";
|
|
22189
22185
|
thoughtSignature?: string;
|
|
22190
22186
|
time: {
|
|
22191
22187
|
start: number;
|
|
@@ -22211,21 +22207,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22211
22207
|
details?: any;
|
|
22212
22208
|
isError: true;
|
|
22213
22209
|
};
|
|
22214
|
-
status: "
|
|
22210
|
+
status: "aborted";
|
|
22215
22211
|
thoughtSignature?: string;
|
|
22216
22212
|
time: {
|
|
22217
22213
|
start: number;
|
|
22218
22214
|
end: number;
|
|
22219
22215
|
};
|
|
22220
22216
|
type: "toolCall";
|
|
22217
|
+
} | {
|
|
22218
|
+
type: "thinking";
|
|
22219
|
+
thinking: string;
|
|
22220
|
+
thinkingSignature?: string;
|
|
22221
|
+
redacted?: boolean;
|
|
22221
22222
|
} | {
|
|
22222
22223
|
addedToolNames?: string[];
|
|
22223
22224
|
arguments: Record<string, any>;
|
|
22224
22225
|
callID: string;
|
|
22225
22226
|
name: string;
|
|
22226
22227
|
namespace?: string;
|
|
22227
|
-
|
|
22228
|
-
content
|
|
22228
|
+
partial?: {
|
|
22229
|
+
content?: ({
|
|
22229
22230
|
type: "text";
|
|
22230
22231
|
text: string;
|
|
22231
22232
|
textSignature?: string;
|
|
@@ -22235,9 +22236,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22235
22236
|
mimeType: string;
|
|
22236
22237
|
})[];
|
|
22237
22238
|
details?: any;
|
|
22238
|
-
isError: true;
|
|
22239
22239
|
};
|
|
22240
|
-
status: "
|
|
22240
|
+
status: "running";
|
|
22241
22241
|
thoughtSignature?: string;
|
|
22242
22242
|
time: {
|
|
22243
22243
|
start: number;
|
|
@@ -22412,19 +22412,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22412
22412
|
type: "image";
|
|
22413
22413
|
data: string;
|
|
22414
22414
|
mimeType: string;
|
|
22415
|
-
} | {
|
|
22416
|
-
type: "thinking";
|
|
22417
|
-
thinking: string;
|
|
22418
|
-
thinkingSignature?: string;
|
|
22419
|
-
redacted?: boolean;
|
|
22420
22415
|
} | {
|
|
22421
22416
|
addedToolNames?: string[];
|
|
22422
22417
|
arguments: Record<string, any>;
|
|
22423
22418
|
callID: string;
|
|
22424
22419
|
name: string;
|
|
22425
22420
|
namespace?: string;
|
|
22426
|
-
|
|
22427
|
-
content
|
|
22421
|
+
result: {
|
|
22422
|
+
content: ({
|
|
22428
22423
|
type: "text";
|
|
22429
22424
|
text: string;
|
|
22430
22425
|
textSignature?: string;
|
|
@@ -22434,8 +22429,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22434
22429
|
mimeType: string;
|
|
22435
22430
|
})[];
|
|
22436
22431
|
details?: any;
|
|
22432
|
+
isError: false;
|
|
22437
22433
|
};
|
|
22438
|
-
status: "
|
|
22434
|
+
status: "completed";
|
|
22439
22435
|
thoughtSignature?: string;
|
|
22440
22436
|
time: {
|
|
22441
22437
|
start: number;
|
|
@@ -22459,9 +22455,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22459
22455
|
mimeType: string;
|
|
22460
22456
|
})[];
|
|
22461
22457
|
details?: any;
|
|
22462
|
-
isError:
|
|
22458
|
+
isError: true;
|
|
22463
22459
|
};
|
|
22464
|
-
status: "
|
|
22460
|
+
status: "error";
|
|
22465
22461
|
thoughtSignature?: string;
|
|
22466
22462
|
time: {
|
|
22467
22463
|
start: number;
|
|
@@ -22487,7 +22483,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22487
22483
|
details?: any;
|
|
22488
22484
|
isError: true;
|
|
22489
22485
|
};
|
|
22490
|
-
status: "
|
|
22486
|
+
status: "skipped";
|
|
22491
22487
|
thoughtSignature?: string;
|
|
22492
22488
|
time: {
|
|
22493
22489
|
start: number;
|
|
@@ -22513,21 +22509,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22513
22509
|
details?: any;
|
|
22514
22510
|
isError: true;
|
|
22515
22511
|
};
|
|
22516
|
-
status: "
|
|
22512
|
+
status: "aborted";
|
|
22517
22513
|
thoughtSignature?: string;
|
|
22518
22514
|
time: {
|
|
22519
22515
|
start: number;
|
|
22520
22516
|
end: number;
|
|
22521
22517
|
};
|
|
22522
22518
|
type: "toolCall";
|
|
22519
|
+
} | {
|
|
22520
|
+
type: "thinking";
|
|
22521
|
+
thinking: string;
|
|
22522
|
+
thinkingSignature?: string;
|
|
22523
|
+
redacted?: boolean;
|
|
22523
22524
|
} | {
|
|
22524
22525
|
addedToolNames?: string[];
|
|
22525
22526
|
arguments: Record<string, any>;
|
|
22526
22527
|
callID: string;
|
|
22527
22528
|
name: string;
|
|
22528
22529
|
namespace?: string;
|
|
22529
|
-
|
|
22530
|
-
content
|
|
22530
|
+
partial?: {
|
|
22531
|
+
content?: ({
|
|
22531
22532
|
type: "text";
|
|
22532
22533
|
text: string;
|
|
22533
22534
|
textSignature?: string;
|
|
@@ -22537,9 +22538,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22537
22538
|
mimeType: string;
|
|
22538
22539
|
})[];
|
|
22539
22540
|
details?: any;
|
|
22540
|
-
isError: true;
|
|
22541
22541
|
};
|
|
22542
|
-
status: "
|
|
22542
|
+
status: "running";
|
|
22543
22543
|
thoughtSignature?: string;
|
|
22544
22544
|
time: {
|
|
22545
22545
|
start: number;
|
|
@@ -22733,19 +22733,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22733
22733
|
type: "image";
|
|
22734
22734
|
data: string;
|
|
22735
22735
|
mimeType: string;
|
|
22736
|
-
} | {
|
|
22737
|
-
type: "thinking";
|
|
22738
|
-
thinking: string;
|
|
22739
|
-
thinkingSignature?: string;
|
|
22740
|
-
redacted?: boolean;
|
|
22741
22736
|
} | {
|
|
22742
22737
|
addedToolNames?: string[];
|
|
22743
22738
|
arguments: Record<string, any>;
|
|
22744
22739
|
callID: string;
|
|
22745
22740
|
name: string;
|
|
22746
22741
|
namespace?: string;
|
|
22747
|
-
|
|
22748
|
-
content
|
|
22742
|
+
result: {
|
|
22743
|
+
content: ({
|
|
22749
22744
|
type: "text";
|
|
22750
22745
|
text: string;
|
|
22751
22746
|
textSignature?: string;
|
|
@@ -22755,8 +22750,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22755
22750
|
mimeType: string;
|
|
22756
22751
|
})[];
|
|
22757
22752
|
details?: any;
|
|
22753
|
+
isError: false;
|
|
22758
22754
|
};
|
|
22759
|
-
status: "
|
|
22755
|
+
status: "completed";
|
|
22760
22756
|
thoughtSignature?: string;
|
|
22761
22757
|
time: {
|
|
22762
22758
|
start: number;
|
|
@@ -22780,9 +22776,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22780
22776
|
mimeType: string;
|
|
22781
22777
|
})[];
|
|
22782
22778
|
details?: any;
|
|
22783
|
-
isError:
|
|
22779
|
+
isError: true;
|
|
22784
22780
|
};
|
|
22785
|
-
status: "
|
|
22781
|
+
status: "error";
|
|
22786
22782
|
thoughtSignature?: string;
|
|
22787
22783
|
time: {
|
|
22788
22784
|
start: number;
|
|
@@ -22808,7 +22804,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22808
22804
|
details?: any;
|
|
22809
22805
|
isError: true;
|
|
22810
22806
|
};
|
|
22811
|
-
status: "
|
|
22807
|
+
status: "skipped";
|
|
22812
22808
|
thoughtSignature?: string;
|
|
22813
22809
|
time: {
|
|
22814
22810
|
start: number;
|
|
@@ -22834,21 +22830,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22834
22830
|
details?: any;
|
|
22835
22831
|
isError: true;
|
|
22836
22832
|
};
|
|
22837
|
-
status: "
|
|
22833
|
+
status: "aborted";
|
|
22838
22834
|
thoughtSignature?: string;
|
|
22839
22835
|
time: {
|
|
22840
22836
|
start: number;
|
|
22841
22837
|
end: number;
|
|
22842
22838
|
};
|
|
22843
22839
|
type: "toolCall";
|
|
22840
|
+
} | {
|
|
22841
|
+
type: "thinking";
|
|
22842
|
+
thinking: string;
|
|
22843
|
+
thinkingSignature?: string;
|
|
22844
|
+
redacted?: boolean;
|
|
22844
22845
|
} | {
|
|
22845
22846
|
addedToolNames?: string[];
|
|
22846
22847
|
arguments: Record<string, any>;
|
|
22847
22848
|
callID: string;
|
|
22848
22849
|
name: string;
|
|
22849
22850
|
namespace?: string;
|
|
22850
|
-
|
|
22851
|
-
content
|
|
22851
|
+
partial?: {
|
|
22852
|
+
content?: ({
|
|
22852
22853
|
type: "text";
|
|
22853
22854
|
text: string;
|
|
22854
22855
|
textSignature?: string;
|
|
@@ -22858,9 +22859,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22858
22859
|
mimeType: string;
|
|
22859
22860
|
})[];
|
|
22860
22861
|
details?: any;
|
|
22861
|
-
isError: true;
|
|
22862
22862
|
};
|
|
22863
|
-
status: "
|
|
22863
|
+
status: "running";
|
|
22864
22864
|
thoughtSignature?: string;
|
|
22865
22865
|
time: {
|
|
22866
22866
|
start: number;
|
|
@@ -23035,19 +23035,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23035
23035
|
type: "image";
|
|
23036
23036
|
data: string;
|
|
23037
23037
|
mimeType: string;
|
|
23038
|
-
} | {
|
|
23039
|
-
type: "thinking";
|
|
23040
|
-
thinking: string;
|
|
23041
|
-
thinkingSignature?: string;
|
|
23042
|
-
redacted?: boolean;
|
|
23043
23038
|
} | {
|
|
23044
23039
|
addedToolNames?: string[];
|
|
23045
23040
|
arguments: Record<string, any>;
|
|
23046
23041
|
callID: string;
|
|
23047
23042
|
name: string;
|
|
23048
23043
|
namespace?: string;
|
|
23049
|
-
|
|
23050
|
-
content
|
|
23044
|
+
result: {
|
|
23045
|
+
content: ({
|
|
23051
23046
|
type: "text";
|
|
23052
23047
|
text: string;
|
|
23053
23048
|
textSignature?: string;
|
|
@@ -23057,8 +23052,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23057
23052
|
mimeType: string;
|
|
23058
23053
|
})[];
|
|
23059
23054
|
details?: any;
|
|
23055
|
+
isError: false;
|
|
23060
23056
|
};
|
|
23061
|
-
status: "
|
|
23057
|
+
status: "completed";
|
|
23062
23058
|
thoughtSignature?: string;
|
|
23063
23059
|
time: {
|
|
23064
23060
|
start: number;
|
|
@@ -23082,9 +23078,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23082
23078
|
mimeType: string;
|
|
23083
23079
|
})[];
|
|
23084
23080
|
details?: any;
|
|
23085
|
-
isError:
|
|
23081
|
+
isError: true;
|
|
23086
23082
|
};
|
|
23087
|
-
status: "
|
|
23083
|
+
status: "error";
|
|
23088
23084
|
thoughtSignature?: string;
|
|
23089
23085
|
time: {
|
|
23090
23086
|
start: number;
|
|
@@ -23110,7 +23106,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23110
23106
|
details?: any;
|
|
23111
23107
|
isError: true;
|
|
23112
23108
|
};
|
|
23113
|
-
status: "
|
|
23109
|
+
status: "skipped";
|
|
23114
23110
|
thoughtSignature?: string;
|
|
23115
23111
|
time: {
|
|
23116
23112
|
start: number;
|
|
@@ -23136,21 +23132,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23136
23132
|
details?: any;
|
|
23137
23133
|
isError: true;
|
|
23138
23134
|
};
|
|
23139
|
-
status: "
|
|
23135
|
+
status: "aborted";
|
|
23140
23136
|
thoughtSignature?: string;
|
|
23141
23137
|
time: {
|
|
23142
23138
|
start: number;
|
|
23143
23139
|
end: number;
|
|
23144
23140
|
};
|
|
23145
23141
|
type: "toolCall";
|
|
23142
|
+
} | {
|
|
23143
|
+
type: "thinking";
|
|
23144
|
+
thinking: string;
|
|
23145
|
+
thinkingSignature?: string;
|
|
23146
|
+
redacted?: boolean;
|
|
23146
23147
|
} | {
|
|
23147
23148
|
addedToolNames?: string[];
|
|
23148
23149
|
arguments: Record<string, any>;
|
|
23149
23150
|
callID: string;
|
|
23150
23151
|
name: string;
|
|
23151
23152
|
namespace?: string;
|
|
23152
|
-
|
|
23153
|
-
content
|
|
23153
|
+
partial?: {
|
|
23154
|
+
content?: ({
|
|
23154
23155
|
type: "text";
|
|
23155
23156
|
text: string;
|
|
23156
23157
|
textSignature?: string;
|
|
@@ -23160,9 +23161,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23160
23161
|
mimeType: string;
|
|
23161
23162
|
})[];
|
|
23162
23163
|
details?: any;
|
|
23163
|
-
isError: true;
|
|
23164
23164
|
};
|
|
23165
|
-
status: "
|
|
23165
|
+
status: "running";
|
|
23166
23166
|
thoughtSignature?: string;
|
|
23167
23167
|
time: {
|
|
23168
23168
|
start: number;
|
|
@@ -23365,19 +23365,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23365
23365
|
type: "image";
|
|
23366
23366
|
data: string;
|
|
23367
23367
|
mimeType: string;
|
|
23368
|
-
} | {
|
|
23369
|
-
type: "thinking";
|
|
23370
|
-
thinking: string;
|
|
23371
|
-
thinkingSignature?: string;
|
|
23372
|
-
redacted?: boolean;
|
|
23373
23368
|
} | {
|
|
23374
23369
|
addedToolNames?: string[];
|
|
23375
23370
|
arguments: Record<string, any>;
|
|
23376
23371
|
callID: string;
|
|
23377
23372
|
name: string;
|
|
23378
23373
|
namespace?: string;
|
|
23379
|
-
|
|
23380
|
-
content
|
|
23374
|
+
result: {
|
|
23375
|
+
content: ({
|
|
23381
23376
|
type: "text";
|
|
23382
23377
|
text: string;
|
|
23383
23378
|
textSignature?: string;
|
|
@@ -23387,8 +23382,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23387
23382
|
mimeType: string;
|
|
23388
23383
|
})[];
|
|
23389
23384
|
details?: any;
|
|
23385
|
+
isError: false;
|
|
23390
23386
|
};
|
|
23391
|
-
status: "
|
|
23387
|
+
status: "completed";
|
|
23392
23388
|
thoughtSignature?: string;
|
|
23393
23389
|
time: {
|
|
23394
23390
|
start: number;
|
|
@@ -23412,9 +23408,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23412
23408
|
mimeType: string;
|
|
23413
23409
|
})[];
|
|
23414
23410
|
details?: any;
|
|
23415
|
-
isError:
|
|
23411
|
+
isError: true;
|
|
23416
23412
|
};
|
|
23417
|
-
status: "
|
|
23413
|
+
status: "error";
|
|
23418
23414
|
thoughtSignature?: string;
|
|
23419
23415
|
time: {
|
|
23420
23416
|
start: number;
|
|
@@ -23440,7 +23436,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23440
23436
|
details?: any;
|
|
23441
23437
|
isError: true;
|
|
23442
23438
|
};
|
|
23443
|
-
status: "
|
|
23439
|
+
status: "skipped";
|
|
23444
23440
|
thoughtSignature?: string;
|
|
23445
23441
|
time: {
|
|
23446
23442
|
start: number;
|
|
@@ -23466,21 +23462,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23466
23462
|
details?: any;
|
|
23467
23463
|
isError: true;
|
|
23468
23464
|
};
|
|
23469
|
-
status: "
|
|
23465
|
+
status: "aborted";
|
|
23470
23466
|
thoughtSignature?: string;
|
|
23471
23467
|
time: {
|
|
23472
23468
|
start: number;
|
|
23473
23469
|
end: number;
|
|
23474
23470
|
};
|
|
23475
23471
|
type: "toolCall";
|
|
23472
|
+
} | {
|
|
23473
|
+
type: "thinking";
|
|
23474
|
+
thinking: string;
|
|
23475
|
+
thinkingSignature?: string;
|
|
23476
|
+
redacted?: boolean;
|
|
23476
23477
|
} | {
|
|
23477
23478
|
addedToolNames?: string[];
|
|
23478
23479
|
arguments: Record<string, any>;
|
|
23479
23480
|
callID: string;
|
|
23480
23481
|
name: string;
|
|
23481
23482
|
namespace?: string;
|
|
23482
|
-
|
|
23483
|
-
content
|
|
23483
|
+
partial?: {
|
|
23484
|
+
content?: ({
|
|
23484
23485
|
type: "text";
|
|
23485
23486
|
text: string;
|
|
23486
23487
|
textSignature?: string;
|
|
@@ -23490,9 +23491,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23490
23491
|
mimeType: string;
|
|
23491
23492
|
})[];
|
|
23492
23493
|
details?: any;
|
|
23493
|
-
isError: true;
|
|
23494
23494
|
};
|
|
23495
|
-
status: "
|
|
23495
|
+
status: "running";
|
|
23496
23496
|
thoughtSignature?: string;
|
|
23497
23497
|
time: {
|
|
23498
23498
|
start: number;
|
|
@@ -23667,19 +23667,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23667
23667
|
type: "image";
|
|
23668
23668
|
data: string;
|
|
23669
23669
|
mimeType: string;
|
|
23670
|
-
} | {
|
|
23671
|
-
type: "thinking";
|
|
23672
|
-
thinking: string;
|
|
23673
|
-
thinkingSignature?: string;
|
|
23674
|
-
redacted?: boolean;
|
|
23675
23670
|
} | {
|
|
23676
23671
|
addedToolNames?: string[];
|
|
23677
23672
|
arguments: Record<string, any>;
|
|
23678
23673
|
callID: string;
|
|
23679
23674
|
name: string;
|
|
23680
23675
|
namespace?: string;
|
|
23681
|
-
|
|
23682
|
-
content
|
|
23676
|
+
result: {
|
|
23677
|
+
content: ({
|
|
23683
23678
|
type: "text";
|
|
23684
23679
|
text: string;
|
|
23685
23680
|
textSignature?: string;
|
|
@@ -23689,8 +23684,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23689
23684
|
mimeType: string;
|
|
23690
23685
|
})[];
|
|
23691
23686
|
details?: any;
|
|
23687
|
+
isError: false;
|
|
23692
23688
|
};
|
|
23693
|
-
status: "
|
|
23689
|
+
status: "completed";
|
|
23694
23690
|
thoughtSignature?: string;
|
|
23695
23691
|
time: {
|
|
23696
23692
|
start: number;
|
|
@@ -23714,9 +23710,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23714
23710
|
mimeType: string;
|
|
23715
23711
|
})[];
|
|
23716
23712
|
details?: any;
|
|
23717
|
-
isError:
|
|
23713
|
+
isError: true;
|
|
23718
23714
|
};
|
|
23719
|
-
status: "
|
|
23715
|
+
status: "error";
|
|
23720
23716
|
thoughtSignature?: string;
|
|
23721
23717
|
time: {
|
|
23722
23718
|
start: number;
|
|
@@ -23742,7 +23738,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23742
23738
|
details?: any;
|
|
23743
23739
|
isError: true;
|
|
23744
23740
|
};
|
|
23745
|
-
status: "
|
|
23741
|
+
status: "skipped";
|
|
23746
23742
|
thoughtSignature?: string;
|
|
23747
23743
|
time: {
|
|
23748
23744
|
start: number;
|
|
@@ -23768,21 +23764,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23768
23764
|
details?: any;
|
|
23769
23765
|
isError: true;
|
|
23770
23766
|
};
|
|
23771
|
-
status: "
|
|
23767
|
+
status: "aborted";
|
|
23772
23768
|
thoughtSignature?: string;
|
|
23773
23769
|
time: {
|
|
23774
23770
|
start: number;
|
|
23775
23771
|
end: number;
|
|
23776
23772
|
};
|
|
23777
23773
|
type: "toolCall";
|
|
23774
|
+
} | {
|
|
23775
|
+
type: "thinking";
|
|
23776
|
+
thinking: string;
|
|
23777
|
+
thinkingSignature?: string;
|
|
23778
|
+
redacted?: boolean;
|
|
23778
23779
|
} | {
|
|
23779
23780
|
addedToolNames?: string[];
|
|
23780
23781
|
arguments: Record<string, any>;
|
|
23781
23782
|
callID: string;
|
|
23782
23783
|
name: string;
|
|
23783
23784
|
namespace?: string;
|
|
23784
|
-
|
|
23785
|
-
content
|
|
23785
|
+
partial?: {
|
|
23786
|
+
content?: ({
|
|
23786
23787
|
type: "text";
|
|
23787
23788
|
text: string;
|
|
23788
23789
|
textSignature?: string;
|
|
@@ -23792,9 +23793,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23792
23793
|
mimeType: string;
|
|
23793
23794
|
})[];
|
|
23794
23795
|
details?: any;
|
|
23795
|
-
isError: true;
|
|
23796
23796
|
};
|
|
23797
|
-
status: "
|
|
23797
|
+
status: "running";
|
|
23798
23798
|
thoughtSignature?: string;
|
|
23799
23799
|
time: {
|
|
23800
23800
|
start: number;
|
|
@@ -23988,19 +23988,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23988
23988
|
type: "image";
|
|
23989
23989
|
data: string;
|
|
23990
23990
|
mimeType: string;
|
|
23991
|
-
} | {
|
|
23992
|
-
type: "thinking";
|
|
23993
|
-
thinking: string;
|
|
23994
|
-
thinkingSignature?: string;
|
|
23995
|
-
redacted?: boolean;
|
|
23996
23991
|
} | {
|
|
23997
23992
|
addedToolNames?: string[];
|
|
23998
23993
|
arguments: Record<string, any>;
|
|
23999
23994
|
callID: string;
|
|
24000
23995
|
name: string;
|
|
24001
23996
|
namespace?: string;
|
|
24002
|
-
|
|
24003
|
-
content
|
|
23997
|
+
result: {
|
|
23998
|
+
content: ({
|
|
24004
23999
|
type: "text";
|
|
24005
24000
|
text: string;
|
|
24006
24001
|
textSignature?: string;
|
|
@@ -24010,8 +24005,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24010
24005
|
mimeType: string;
|
|
24011
24006
|
})[];
|
|
24012
24007
|
details?: any;
|
|
24008
|
+
isError: false;
|
|
24013
24009
|
};
|
|
24014
|
-
status: "
|
|
24010
|
+
status: "completed";
|
|
24015
24011
|
thoughtSignature?: string;
|
|
24016
24012
|
time: {
|
|
24017
24013
|
start: number;
|
|
@@ -24035,9 +24031,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24035
24031
|
mimeType: string;
|
|
24036
24032
|
})[];
|
|
24037
24033
|
details?: any;
|
|
24038
|
-
isError:
|
|
24034
|
+
isError: true;
|
|
24039
24035
|
};
|
|
24040
|
-
status: "
|
|
24036
|
+
status: "error";
|
|
24041
24037
|
thoughtSignature?: string;
|
|
24042
24038
|
time: {
|
|
24043
24039
|
start: number;
|
|
@@ -24063,7 +24059,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24063
24059
|
details?: any;
|
|
24064
24060
|
isError: true;
|
|
24065
24061
|
};
|
|
24066
|
-
status: "
|
|
24062
|
+
status: "skipped";
|
|
24067
24063
|
thoughtSignature?: string;
|
|
24068
24064
|
time: {
|
|
24069
24065
|
start: number;
|
|
@@ -24089,21 +24085,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24089
24085
|
details?: any;
|
|
24090
24086
|
isError: true;
|
|
24091
24087
|
};
|
|
24092
|
-
status: "
|
|
24088
|
+
status: "aborted";
|
|
24093
24089
|
thoughtSignature?: string;
|
|
24094
24090
|
time: {
|
|
24095
24091
|
start: number;
|
|
24096
24092
|
end: number;
|
|
24097
24093
|
};
|
|
24098
24094
|
type: "toolCall";
|
|
24095
|
+
} | {
|
|
24096
|
+
type: "thinking";
|
|
24097
|
+
thinking: string;
|
|
24098
|
+
thinkingSignature?: string;
|
|
24099
|
+
redacted?: boolean;
|
|
24099
24100
|
} | {
|
|
24100
24101
|
addedToolNames?: string[];
|
|
24101
24102
|
arguments: Record<string, any>;
|
|
24102
24103
|
callID: string;
|
|
24103
24104
|
name: string;
|
|
24104
24105
|
namespace?: string;
|
|
24105
|
-
|
|
24106
|
-
content
|
|
24106
|
+
partial?: {
|
|
24107
|
+
content?: ({
|
|
24107
24108
|
type: "text";
|
|
24108
24109
|
text: string;
|
|
24109
24110
|
textSignature?: string;
|
|
@@ -24113,9 +24114,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24113
24114
|
mimeType: string;
|
|
24114
24115
|
})[];
|
|
24115
24116
|
details?: any;
|
|
24116
|
-
isError: true;
|
|
24117
24117
|
};
|
|
24118
|
-
status: "
|
|
24118
|
+
status: "running";
|
|
24119
24119
|
thoughtSignature?: string;
|
|
24120
24120
|
time: {
|
|
24121
24121
|
start: number;
|
|
@@ -24290,19 +24290,14 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24290
24290
|
type: "image";
|
|
24291
24291
|
data: string;
|
|
24292
24292
|
mimeType: string;
|
|
24293
|
-
} | {
|
|
24294
|
-
type: "thinking";
|
|
24295
|
-
thinking: string;
|
|
24296
|
-
thinkingSignature?: string;
|
|
24297
|
-
redacted?: boolean;
|
|
24298
24293
|
} | {
|
|
24299
24294
|
addedToolNames?: string[];
|
|
24300
24295
|
arguments: Record<string, any>;
|
|
24301
24296
|
callID: string;
|
|
24302
24297
|
name: string;
|
|
24303
24298
|
namespace?: string;
|
|
24304
|
-
|
|
24305
|
-
content
|
|
24299
|
+
result: {
|
|
24300
|
+
content: ({
|
|
24306
24301
|
type: "text";
|
|
24307
24302
|
text: string;
|
|
24308
24303
|
textSignature?: string;
|
|
@@ -24312,8 +24307,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24312
24307
|
mimeType: string;
|
|
24313
24308
|
})[];
|
|
24314
24309
|
details?: any;
|
|
24310
|
+
isError: false;
|
|
24315
24311
|
};
|
|
24316
|
-
status: "
|
|
24312
|
+
status: "completed";
|
|
24317
24313
|
thoughtSignature?: string;
|
|
24318
24314
|
time: {
|
|
24319
24315
|
start: number;
|
|
@@ -24337,9 +24333,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24337
24333
|
mimeType: string;
|
|
24338
24334
|
})[];
|
|
24339
24335
|
details?: any;
|
|
24340
|
-
isError:
|
|
24336
|
+
isError: true;
|
|
24341
24337
|
};
|
|
24342
|
-
status: "
|
|
24338
|
+
status: "error";
|
|
24343
24339
|
thoughtSignature?: string;
|
|
24344
24340
|
time: {
|
|
24345
24341
|
start: number;
|
|
@@ -24365,7 +24361,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24365
24361
|
details?: any;
|
|
24366
24362
|
isError: true;
|
|
24367
24363
|
};
|
|
24368
|
-
status: "
|
|
24364
|
+
status: "skipped";
|
|
24369
24365
|
thoughtSignature?: string;
|
|
24370
24366
|
time: {
|
|
24371
24367
|
start: number;
|
|
@@ -24391,21 +24387,26 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24391
24387
|
details?: any;
|
|
24392
24388
|
isError: true;
|
|
24393
24389
|
};
|
|
24394
|
-
status: "
|
|
24390
|
+
status: "aborted";
|
|
24395
24391
|
thoughtSignature?: string;
|
|
24396
24392
|
time: {
|
|
24397
24393
|
start: number;
|
|
24398
24394
|
end: number;
|
|
24399
24395
|
};
|
|
24400
24396
|
type: "toolCall";
|
|
24397
|
+
} | {
|
|
24398
|
+
type: "thinking";
|
|
24399
|
+
thinking: string;
|
|
24400
|
+
thinkingSignature?: string;
|
|
24401
|
+
redacted?: boolean;
|
|
24401
24402
|
} | {
|
|
24402
24403
|
addedToolNames?: string[];
|
|
24403
24404
|
arguments: Record<string, any>;
|
|
24404
24405
|
callID: string;
|
|
24405
24406
|
name: string;
|
|
24406
24407
|
namespace?: string;
|
|
24407
|
-
|
|
24408
|
-
content
|
|
24408
|
+
partial?: {
|
|
24409
|
+
content?: ({
|
|
24409
24410
|
type: "text";
|
|
24410
24411
|
text: string;
|
|
24411
24412
|
textSignature?: string;
|
|
@@ -24415,9 +24416,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24415
24416
|
mimeType: string;
|
|
24416
24417
|
})[];
|
|
24417
24418
|
details?: any;
|
|
24418
|
-
isError: true;
|
|
24419
24419
|
};
|
|
24420
|
-
status: "
|
|
24420
|
+
status: "running";
|
|
24421
24421
|
thoughtSignature?: string;
|
|
24422
24422
|
time: {
|
|
24423
24423
|
start: number;
|