@codeworksh/harness 0.3.0-dev.20261013131320 → 0.3.0-dev.20261019181702
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/{daytona-D4sNwzSr.mjs → daytona-BqRoRhe7.mjs} +5 -8
- package/daytona-BqRoRhe7.mjs.map +1 -0
- package/effect.d.mts +897 -828
- package/effect.mjs +373 -57
- package/effect.mjs.map +1 -1
- package/package.json +10 -7
- package/sandboxes/daytona/index.mjs +1 -1
- package/daytona-D4sNwzSr.mjs.map +0 -1
package/effect.d.mts
CHANGED
|
@@ -1156,6 +1156,8 @@ interface Interface$16 {
|
|
|
1156
1156
|
readonly get: (sessionId: ID$1) => Effect.Effect<Option.Option<SessionRow>>;
|
|
1157
1157
|
/** The space a session attaches to — its env and absolute location. None when the session is unknown. */
|
|
1158
1158
|
readonly space: (sessionId: ID$1) => Effect.Effect<Option.Option<schema_d_exports$7.SpaceSchema.Info>>;
|
|
1159
|
+
/** The project a session belongs to, through its space. None when the session is unknown. */
|
|
1160
|
+
readonly project: (sessionId: ID$1) => Effect.Effect<Option.Option<schema_d_exports$9.ProjectSchema.Info>>;
|
|
1159
1161
|
/** Sessions newest first, across the whole database when no scope is given. */
|
|
1160
1162
|
readonly list: (input?: ListInput$1) => Effect.Effect<SessionRow[]>;
|
|
1161
1163
|
readonly entry: (entryId: string) => Effect.Effect<Option.Option<HydratedEntry>>;
|
|
@@ -1484,7 +1486,7 @@ declare const layer$12: Layer.Layer<Service$12, never, import("@codeworksh/plugi
|
|
|
1484
1486
|
declare const layerWith$2: <E, RIn>(sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service$12, E, RIn>;
|
|
1485
1487
|
declare const defaultLayer$3: (rootPath: string) => Layer.Layer<Service$12, never, never>;
|
|
1486
1488
|
declare namespace project_d_exports {
|
|
1487
|
-
export { Interface$10 as Interface, project_d_exports as Project, Resolved$2 as Resolved, Service$11 as Service, defaultLayer$2 as defaultLayer, layer$11 as layer, layerWith$1 as layerWith, provisional };
|
|
1489
|
+
export { Interface$10 as Interface, project_d_exports as Project, ProjectNotFoundError, ResolveOptions, Resolved$2 as Resolved, Service$11 as Service, defaultLayer$2 as defaultLayer, layer$11 as layer, layerWith$1 as layerWith, provisional, rename };
|
|
1488
1490
|
}
|
|
1489
1491
|
/** Deterministic, env-local id for a directory without a portable identity. Never written to a marker. */
|
|
1490
1492
|
declare const provisional: (env: instance_d_exports.SandboxInstance.ID, location: string) => schema_d_exports$9.ProjectSchema.ID;
|
|
@@ -1496,27 +1498,43 @@ interface Resolved$2 {
|
|
|
1496
1498
|
/** `space.kind ∈ { primary, plain }` */
|
|
1497
1499
|
readonly isDefault: boolean;
|
|
1498
1500
|
}
|
|
1501
|
+
interface ResolveOptions {
|
|
1502
|
+
/**
|
|
1503
|
+
* Names the project when this resolution creates it, ahead of the repository's and the
|
|
1504
|
+
* folder's name. An existing project keeps its name; {@link rename} changes it.
|
|
1505
|
+
*/
|
|
1506
|
+
readonly name?: string;
|
|
1507
|
+
}
|
|
1499
1508
|
interface Interface$10 {
|
|
1500
|
-
readonly resolveOrCreate: (cwd: schema_d_exports$8.AbsolutePath) => Effect.Effect<Resolved$2, Error$1>;
|
|
1509
|
+
readonly resolveOrCreate: (cwd: schema_d_exports$8.AbsolutePath, options?: ResolveOptions) => Effect.Effect<Resolved$2, Error$1>;
|
|
1501
1510
|
readonly get: (id: schema_d_exports$9.ProjectSchema.ID) => Effect.Effect<Option.Option<schema_d_exports$9.ProjectSchema.Info>>;
|
|
1502
1511
|
readonly list: () => Effect.Effect<schema_d_exports$9.ProjectSchema.Info[]>;
|
|
1503
1512
|
}
|
|
1504
1513
|
declare const Service_base$9: Context.ServiceClass<Service$11, "@codeworksh/harness/project/project/Service", Interface$10>;
|
|
1505
1514
|
declare class Service$11 extends Service_base$9 {}
|
|
1506
1515
|
declare const layer$11: Layer.Layer<Service$11, never, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | Service$13 | Service$14 | Service$12 | SqlClient.SqlClient>;
|
|
1516
|
+
declare const ProjectNotFoundError_base: Schema.Class<ProjectNotFoundError, Schema.TaggedStruct<"ProjectNotFoundError", {
|
|
1517
|
+
readonly projectId: Schema.String;
|
|
1518
|
+
}>, import("effect/Cause").YieldableError>;
|
|
1519
|
+
declare class ProjectNotFoundError extends ProjectNotFoundError_base {}
|
|
1520
|
+
/** Renames a project. Needs only the database, not a mount: a name is the same in every env. */
|
|
1521
|
+
declare const rename: (input: {
|
|
1522
|
+
readonly projectId: string;
|
|
1523
|
+
readonly name: string;
|
|
1524
|
+
}) => Effect.Effect<schema_d_exports$9.ProjectSchema.Info, ProjectNotFoundError, SqlClient.SqlClient>;
|
|
1507
1525
|
/** Takes an assembled sandbox — local or remote — not a local backend. */
|
|
1508
1526
|
declare const layerWith$1: <E, RIn>(sandbox: Sandbox.Sandbox<E, RIn>) => Layer.Layer<Service$11, E | import("effect/Config").ConfigError, Exclude<RIn, SqlClient.SqlClient | import("@effect/sql-sqlite-node/SqliteClient").SqliteClient>>;
|
|
1509
1527
|
declare const defaultLayer$2: (path: string) => Layer.Layer<Service$11, import("effect/Config").ConfigError, never>;
|
|
1510
1528
|
declare namespace location_d_exports {
|
|
1511
1529
|
export { DirectoryNotFoundError, Error, Info$5 as Info, Interface$9 as Interface, location_d_exports as Location, NotDirectoryError, Service$10 as Service, layer$10 as layer, layerMounted };
|
|
1512
1530
|
}
|
|
1513
|
-
declare const layer$10: () => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | Service$11>;
|
|
1531
|
+
declare const layer$10: (options?: ResolveOptions) => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | Service$11>;
|
|
1514
1532
|
/**
|
|
1515
1533
|
* `layer` with the whole resolution stack (Project, Space, Repo, Worktree, Git)
|
|
1516
1534
|
* folded in. What remains is exactly the mount and the database — for callers
|
|
1517
1535
|
* that already hold both, such as the runner and `Session.create`.
|
|
1518
1536
|
*/
|
|
1519
|
-
declare const layerMounted: () => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | import("@codeworksh/plugin/sandbox/shell").Shell | import("effect/sql/SqlClient").SqlClient>;
|
|
1537
|
+
declare const layerMounted: (options?: ResolveOptions) => Layer.Layer<Service, import("@codeworksh/plugin/location").Error, io_d_exports.SandboxIO.Current | import("@codeworksh/plugin/sandbox/filesystem").Service | import("@codeworksh/plugin/sandbox/shell").Shell | import("effect/sql/SqlClient").SqlClient>;
|
|
1520
1538
|
declare namespace global_d_exports {
|
|
1521
1539
|
export { global_d_exports as Global, Interface$8 as Interface, Service$9 as Service, app, appConfigDir, authFile, defaultLayer$1 as defaultLayer, homeConfig, layer$9 as layer, layerWith, make$3 as make, resolve$3 as resolve };
|
|
1522
1540
|
}
|
|
@@ -1736,6 +1754,7 @@ declare const parse$1: (path: string, source: string) => Effect.Effect<{
|
|
|
1736
1754
|
supportsOpenAIGrammarTools?: boolean;
|
|
1737
1755
|
supportsThinkingTokenBudget?: boolean;
|
|
1738
1756
|
forceAdaptiveThinking?: boolean;
|
|
1757
|
+
supportsTemperature?: boolean;
|
|
1739
1758
|
thinkingTokenBudgetField?: string;
|
|
1740
1759
|
};
|
|
1741
1760
|
contextWindow: number;
|
|
@@ -2637,7 +2656,7 @@ declare class ProviderError extends ProviderError_base {
|
|
|
2637
2656
|
}
|
|
2638
2657
|
declare const ModelCatalogError_base: Schema.Class<ModelCatalogError, Schema.TaggedStruct<"Runner.ModelCatalogError", {
|
|
2639
2658
|
readonly path: Schema.String;
|
|
2640
|
-
readonly reason: Schema.Literals<readonly ["
|
|
2659
|
+
readonly reason: Schema.Literals<readonly ["unreadable", "empty", "invalid"]>;
|
|
2641
2660
|
readonly detail: Schema.String;
|
|
2642
2661
|
}>, import("effect/Cause").YieldableError>;
|
|
2643
2662
|
declare class ModelCatalogError extends ModelCatalogError_base {
|
|
@@ -2715,21 +2734,6 @@ type AikitPart = Message.AssistantMessage["parts"][number] | Message.UserMessage
|
|
|
2715
2734
|
declare const encodePart: (part: AikitPart) => Effect.Effect<AppendPart, ContextEncodeError, never>;
|
|
2716
2735
|
declare const validateUserMessage: (value: unknown, entryId: string, type: string) => Effect.Effect<Message.UserMessage, ContextDecodeError>;
|
|
2717
2736
|
declare const encodeMessage: (message: {
|
|
2718
|
-
messageId: string;
|
|
2719
|
-
role: "user";
|
|
2720
|
-
time: {
|
|
2721
|
-
created: number;
|
|
2722
|
-
};
|
|
2723
|
-
parts: ({
|
|
2724
|
-
type: "text";
|
|
2725
|
-
text: string;
|
|
2726
|
-
textSignature?: string;
|
|
2727
|
-
} | {
|
|
2728
|
-
type: "image";
|
|
2729
|
-
data: string;
|
|
2730
|
-
mimeType: string;
|
|
2731
|
-
})[];
|
|
2732
|
-
} | {
|
|
2733
2737
|
role: "assistant";
|
|
2734
2738
|
protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
|
|
2735
2739
|
provider: {
|
|
@@ -2879,14 +2883,19 @@ declare const encodeMessage: (message: {
|
|
|
2879
2883
|
type: "image";
|
|
2880
2884
|
data: string;
|
|
2881
2885
|
mimeType: string;
|
|
2886
|
+
} | {
|
|
2887
|
+
type: "thinking";
|
|
2888
|
+
thinking: string;
|
|
2889
|
+
thinkingSignature?: string;
|
|
2890
|
+
redacted?: boolean;
|
|
2882
2891
|
} | {
|
|
2883
2892
|
addedToolNames?: string[];
|
|
2884
2893
|
arguments: Record<string, any>;
|
|
2885
2894
|
callID: string;
|
|
2886
2895
|
name: string;
|
|
2887
2896
|
namespace?: string;
|
|
2888
|
-
|
|
2889
|
-
content
|
|
2897
|
+
partial?: {
|
|
2898
|
+
content?: ({
|
|
2890
2899
|
type: "text";
|
|
2891
2900
|
text: string;
|
|
2892
2901
|
textSignature?: string;
|
|
@@ -2896,9 +2905,8 @@ declare const encodeMessage: (message: {
|
|
|
2896
2905
|
mimeType: string;
|
|
2897
2906
|
})[];
|
|
2898
2907
|
details?: any;
|
|
2899
|
-
isError: false;
|
|
2900
2908
|
};
|
|
2901
|
-
status: "
|
|
2909
|
+
status: "running";
|
|
2902
2910
|
thoughtSignature?: string;
|
|
2903
2911
|
time: {
|
|
2904
2912
|
start: number;
|
|
@@ -2922,9 +2930,9 @@ declare const encodeMessage: (message: {
|
|
|
2922
2930
|
mimeType: string;
|
|
2923
2931
|
})[];
|
|
2924
2932
|
details?: any;
|
|
2925
|
-
isError:
|
|
2933
|
+
isError: false;
|
|
2926
2934
|
};
|
|
2927
|
-
status: "
|
|
2935
|
+
status: "completed";
|
|
2928
2936
|
thoughtSignature?: string;
|
|
2929
2937
|
time: {
|
|
2930
2938
|
start: number;
|
|
@@ -2950,7 +2958,7 @@ declare const encodeMessage: (message: {
|
|
|
2950
2958
|
details?: any;
|
|
2951
2959
|
isError: true;
|
|
2952
2960
|
};
|
|
2953
|
-
status: "
|
|
2961
|
+
status: "error";
|
|
2954
2962
|
thoughtSignature?: string;
|
|
2955
2963
|
time: {
|
|
2956
2964
|
start: number;
|
|
@@ -2976,26 +2984,21 @@ declare const encodeMessage: (message: {
|
|
|
2976
2984
|
details?: any;
|
|
2977
2985
|
isError: true;
|
|
2978
2986
|
};
|
|
2979
|
-
status: "
|
|
2987
|
+
status: "skipped";
|
|
2980
2988
|
thoughtSignature?: string;
|
|
2981
2989
|
time: {
|
|
2982
2990
|
start: number;
|
|
2983
2991
|
end: number;
|
|
2984
2992
|
};
|
|
2985
2993
|
type: "toolCall";
|
|
2986
|
-
} | {
|
|
2987
|
-
type: "thinking";
|
|
2988
|
-
thinking: string;
|
|
2989
|
-
thinkingSignature?: string;
|
|
2990
|
-
redacted?: boolean;
|
|
2991
2994
|
} | {
|
|
2992
2995
|
addedToolNames?: string[];
|
|
2993
2996
|
arguments: Record<string, any>;
|
|
2994
2997
|
callID: string;
|
|
2995
2998
|
name: string;
|
|
2996
2999
|
namespace?: string;
|
|
2997
|
-
|
|
2998
|
-
content
|
|
3000
|
+
result: {
|
|
3001
|
+
content: ({
|
|
2999
3002
|
type: "text";
|
|
3000
3003
|
text: string;
|
|
3001
3004
|
textSignature?: string;
|
|
@@ -3005,8 +3008,9 @@ declare const encodeMessage: (message: {
|
|
|
3005
3008
|
mimeType: string;
|
|
3006
3009
|
})[];
|
|
3007
3010
|
details?: any;
|
|
3011
|
+
isError: true;
|
|
3008
3012
|
};
|
|
3009
|
-
status: "
|
|
3013
|
+
status: "aborted";
|
|
3010
3014
|
thoughtSignature?: string;
|
|
3011
3015
|
time: {
|
|
3012
3016
|
start: number;
|
|
@@ -3031,8 +3035,7 @@ declare const encodeMessage: (message: {
|
|
|
3031
3035
|
responseId?: string;
|
|
3032
3036
|
responseModel?: string;
|
|
3033
3037
|
messageId: string;
|
|
3034
|
-
}
|
|
3035
|
-
declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3038
|
+
} | {
|
|
3036
3039
|
messageId: string;
|
|
3037
3040
|
role: "user";
|
|
3038
3041
|
time: {
|
|
@@ -3047,8 +3050,8 @@ declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect
|
|
|
3047
3050
|
data: string;
|
|
3048
3051
|
mimeType: string;
|
|
3049
3052
|
})[];
|
|
3050
|
-
},
|
|
3051
|
-
declare const
|
|
3053
|
+
}) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
|
|
3054
|
+
declare const decodeSyntheticMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3052
3055
|
messageId: string;
|
|
3053
3056
|
role: "user";
|
|
3054
3057
|
time: {
|
|
@@ -3063,7 +3066,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3063
3066
|
data: string;
|
|
3064
3067
|
mimeType: string;
|
|
3065
3068
|
})[];
|
|
3066
|
-
}
|
|
3069
|
+
}, ContextDecodeError, never>;
|
|
3070
|
+
declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
3067
3071
|
role: "assistant";
|
|
3068
3072
|
protocol: "anthropic" | "github-copilot" | "google" | "google-vertex" | "google-vertex-anthropic" | "openai" | "openai-codex" | "openai-compatible" | "openrouter" | "xai";
|
|
3069
3073
|
provider: {
|
|
@@ -3213,14 +3217,19 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3213
3217
|
type: "image";
|
|
3214
3218
|
data: string;
|
|
3215
3219
|
mimeType: string;
|
|
3220
|
+
} | {
|
|
3221
|
+
type: "thinking";
|
|
3222
|
+
thinking: string;
|
|
3223
|
+
thinkingSignature?: string;
|
|
3224
|
+
redacted?: boolean;
|
|
3216
3225
|
} | {
|
|
3217
3226
|
addedToolNames?: string[];
|
|
3218
3227
|
arguments: Record<string, any>;
|
|
3219
3228
|
callID: string;
|
|
3220
3229
|
name: string;
|
|
3221
3230
|
namespace?: string;
|
|
3222
|
-
|
|
3223
|
-
content
|
|
3231
|
+
partial?: {
|
|
3232
|
+
content?: ({
|
|
3224
3233
|
type: "text";
|
|
3225
3234
|
text: string;
|
|
3226
3235
|
textSignature?: string;
|
|
@@ -3230,9 +3239,8 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3230
3239
|
mimeType: string;
|
|
3231
3240
|
})[];
|
|
3232
3241
|
details?: any;
|
|
3233
|
-
isError: false;
|
|
3234
3242
|
};
|
|
3235
|
-
status: "
|
|
3243
|
+
status: "running";
|
|
3236
3244
|
thoughtSignature?: string;
|
|
3237
3245
|
time: {
|
|
3238
3246
|
start: number;
|
|
@@ -3256,9 +3264,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3256
3264
|
mimeType: string;
|
|
3257
3265
|
})[];
|
|
3258
3266
|
details?: any;
|
|
3259
|
-
isError:
|
|
3267
|
+
isError: false;
|
|
3260
3268
|
};
|
|
3261
|
-
status: "
|
|
3269
|
+
status: "completed";
|
|
3262
3270
|
thoughtSignature?: string;
|
|
3263
3271
|
time: {
|
|
3264
3272
|
start: number;
|
|
@@ -3284,7 +3292,7 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3284
3292
|
details?: any;
|
|
3285
3293
|
isError: true;
|
|
3286
3294
|
};
|
|
3287
|
-
status: "
|
|
3295
|
+
status: "error";
|
|
3288
3296
|
thoughtSignature?: string;
|
|
3289
3297
|
time: {
|
|
3290
3298
|
start: number;
|
|
@@ -3310,26 +3318,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3310
3318
|
details?: any;
|
|
3311
3319
|
isError: true;
|
|
3312
3320
|
};
|
|
3313
|
-
status: "
|
|
3321
|
+
status: "skipped";
|
|
3314
3322
|
thoughtSignature?: string;
|
|
3315
3323
|
time: {
|
|
3316
3324
|
start: number;
|
|
3317
3325
|
end: number;
|
|
3318
3326
|
};
|
|
3319
3327
|
type: "toolCall";
|
|
3320
|
-
} | {
|
|
3321
|
-
type: "thinking";
|
|
3322
|
-
thinking: string;
|
|
3323
|
-
thinkingSignature?: string;
|
|
3324
|
-
redacted?: boolean;
|
|
3325
3328
|
} | {
|
|
3326
3329
|
addedToolNames?: string[];
|
|
3327
3330
|
arguments: Record<string, any>;
|
|
3328
3331
|
callID: string;
|
|
3329
3332
|
name: string;
|
|
3330
3333
|
namespace?: string;
|
|
3331
|
-
|
|
3332
|
-
content
|
|
3334
|
+
result: {
|
|
3335
|
+
content: ({
|
|
3333
3336
|
type: "text";
|
|
3334
3337
|
text: string;
|
|
3335
3338
|
textSignature?: string;
|
|
@@ -3339,8 +3342,9 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3339
3342
|
mimeType: string;
|
|
3340
3343
|
})[];
|
|
3341
3344
|
details?: any;
|
|
3345
|
+
isError: true;
|
|
3342
3346
|
};
|
|
3343
|
-
status: "
|
|
3347
|
+
status: "aborted";
|
|
3344
3348
|
thoughtSignature?: string;
|
|
3345
3349
|
time: {
|
|
3346
3350
|
start: number;
|
|
@@ -3365,6 +3369,21 @@ declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
|
|
|
3365
3369
|
responseId?: string;
|
|
3366
3370
|
responseModel?: string;
|
|
3367
3371
|
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
|
+
})[];
|
|
3368
3387
|
}, ContextDecodeError, never>;
|
|
3369
3388
|
declare namespace context_d_exports {
|
|
3370
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 };
|
|
@@ -3546,6 +3565,7 @@ declare const models: Effect.Effect<Partial<Record<string, Record<string, {
|
|
|
3546
3565
|
supportsOpenAIGrammarTools?: boolean;
|
|
3547
3566
|
supportsThinkingTokenBudget?: boolean;
|
|
3548
3567
|
forceAdaptiveThinking?: boolean;
|
|
3568
|
+
supportsTemperature?: boolean;
|
|
3549
3569
|
thinkingTokenBudgetField?: string;
|
|
3550
3570
|
};
|
|
3551
3571
|
contextWindow: number;
|
|
@@ -3653,6 +3673,7 @@ declare const effective: (declared: readonly schema_d_exports$4.DeclaredModel[])
|
|
|
3653
3673
|
supportsOpenAIGrammarTools?: boolean;
|
|
3654
3674
|
supportsThinkingTokenBudget?: boolean;
|
|
3655
3675
|
forceAdaptiveThinking?: boolean;
|
|
3676
|
+
supportsTemperature?: boolean;
|
|
3656
3677
|
thinkingTokenBudgetField?: string;
|
|
3657
3678
|
};
|
|
3658
3679
|
contextWindow: number;
|
|
@@ -3997,6 +4018,10 @@ interface CreateInput extends RuntimeInput {
|
|
|
3997
4018
|
* own directory. {@link link} assigns one afterwards.
|
|
3998
4019
|
*/
|
|
3999
4020
|
readonly hostDir?: string;
|
|
4021
|
+
/** Names the session's project if this creates it; an existing project keeps its name. */
|
|
4022
|
+
readonly project?: {
|
|
4023
|
+
readonly name: string;
|
|
4024
|
+
};
|
|
4000
4025
|
}
|
|
4001
4026
|
interface AttachInput extends RuntimeInput {
|
|
4002
4027
|
readonly sessionId: ID$1;
|
|
@@ -4029,6 +4054,20 @@ interface Info$1 {
|
|
|
4029
4054
|
*/
|
|
4030
4055
|
readonly hasHostLink: boolean;
|
|
4031
4056
|
readonly sandbox?: Info$2;
|
|
4057
|
+
/** Absent only when the session's space or project row is missing. */
|
|
4058
|
+
readonly project?: {
|
|
4059
|
+
readonly id: schema_d_exports$9.ProjectSchema.ID;
|
|
4060
|
+
readonly name: string;
|
|
4061
|
+
};
|
|
4062
|
+
/** Last activity, epoch milliseconds: every appended entry moves it. */
|
|
4063
|
+
readonly updatedAt: number;
|
|
4064
|
+
/** The model chosen for this session over settings; absent when settings decide. */
|
|
4065
|
+
readonly model?: {
|
|
4066
|
+
readonly provider: string;
|
|
4067
|
+
readonly id: string;
|
|
4068
|
+
};
|
|
4069
|
+
/** The thinking level chosen for this session over settings; absent when settings decide. */
|
|
4070
|
+
readonly thinkingLevel?: Model.ThinkingLevel;
|
|
4032
4071
|
}
|
|
4033
4072
|
interface Handle {
|
|
4034
4073
|
readonly id: ID$1;
|
|
@@ -4054,6 +4093,16 @@ declare const create$1: (input?: CreateInput | undefined) => Effect.Effect<{
|
|
|
4054
4093
|
hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
|
|
4055
4094
|
hasHostLink: boolean;
|
|
4056
4095
|
sandbox?: instance_d_exports.SandboxInstance.Info;
|
|
4096
|
+
project?: {
|
|
4097
|
+
id: string & import("effect/Brand").Brand<"Project.ID">;
|
|
4098
|
+
name: string;
|
|
4099
|
+
};
|
|
4100
|
+
updatedAt: number;
|
|
4101
|
+
model?: {
|
|
4102
|
+
readonly provider: string;
|
|
4103
|
+
readonly id: string;
|
|
4104
|
+
};
|
|
4105
|
+
thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
|
|
4057
4106
|
}, SessionNotFoundError, never>;
|
|
4058
4107
|
prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
|
|
4059
4108
|
run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
|
|
@@ -4082,6 +4131,16 @@ declare const link: (input: {
|
|
|
4082
4131
|
hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
|
|
4083
4132
|
hasHostLink: boolean;
|
|
4084
4133
|
sandbox?: instance_d_exports.SandboxInstance.Info;
|
|
4134
|
+
project?: {
|
|
4135
|
+
id: string & import("effect/Brand").Brand<"Project.ID">;
|
|
4136
|
+
name: string;
|
|
4137
|
+
};
|
|
4138
|
+
updatedAt: number;
|
|
4139
|
+
model?: {
|
|
4140
|
+
readonly provider: string;
|
|
4141
|
+
readonly id: string;
|
|
4142
|
+
};
|
|
4143
|
+
thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
|
|
4085
4144
|
}, SessionNotFoundError, never>;
|
|
4086
4145
|
prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
|
|
4087
4146
|
run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
|
|
@@ -4108,6 +4167,16 @@ declare const relink: (input: RelinkInput) => Effect.Effect<{
|
|
|
4108
4167
|
hostDir?: string & import("effect/Brand").Brand<"AbsolutePath">;
|
|
4109
4168
|
hasHostLink: boolean;
|
|
4110
4169
|
sandbox?: instance_d_exports.SandboxInstance.Info;
|
|
4170
|
+
project?: {
|
|
4171
|
+
id: string & import("effect/Brand").Brand<"Project.ID">;
|
|
4172
|
+
name: string;
|
|
4173
|
+
};
|
|
4174
|
+
updatedAt: number;
|
|
4175
|
+
model?: {
|
|
4176
|
+
readonly provider: string;
|
|
4177
|
+
readonly id: string;
|
|
4178
|
+
};
|
|
4179
|
+
thinkingLevel?: "high" | "low" | "max" | "medium" | "minimal" | "off" | "xhigh";
|
|
4111
4180
|
}, SessionNotFoundError, never>;
|
|
4112
4181
|
prompt: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
|
|
4113
4182
|
run: (input: PromptInput) => Effect.Effect<Admitted, InvalidPromptError | PromptConflictError | SessionNotFoundError, never>;
|
|
@@ -4807,14 +4876,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4807
4876
|
type: "image";
|
|
4808
4877
|
data: string;
|
|
4809
4878
|
mimeType: string;
|
|
4879
|
+
} | {
|
|
4880
|
+
type: "thinking";
|
|
4881
|
+
thinking: string;
|
|
4882
|
+
thinkingSignature?: string;
|
|
4883
|
+
redacted?: boolean;
|
|
4810
4884
|
} | {
|
|
4811
4885
|
addedToolNames?: string[];
|
|
4812
4886
|
arguments: Record<string, any>;
|
|
4813
4887
|
callID: string;
|
|
4814
4888
|
name: string;
|
|
4815
4889
|
namespace?: string;
|
|
4816
|
-
|
|
4817
|
-
content
|
|
4890
|
+
partial?: {
|
|
4891
|
+
content?: ({
|
|
4818
4892
|
type: "text";
|
|
4819
4893
|
text: string;
|
|
4820
4894
|
textSignature?: string;
|
|
@@ -4824,9 +4898,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4824
4898
|
mimeType: string;
|
|
4825
4899
|
})[];
|
|
4826
4900
|
details?: any;
|
|
4827
|
-
isError: false;
|
|
4828
4901
|
};
|
|
4829
|
-
status: "
|
|
4902
|
+
status: "running";
|
|
4830
4903
|
thoughtSignature?: string;
|
|
4831
4904
|
time: {
|
|
4832
4905
|
start: number;
|
|
@@ -4850,9 +4923,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4850
4923
|
mimeType: string;
|
|
4851
4924
|
})[];
|
|
4852
4925
|
details?: any;
|
|
4853
|
-
isError:
|
|
4926
|
+
isError: false;
|
|
4854
4927
|
};
|
|
4855
|
-
status: "
|
|
4928
|
+
status: "completed";
|
|
4856
4929
|
thoughtSignature?: string;
|
|
4857
4930
|
time: {
|
|
4858
4931
|
start: number;
|
|
@@ -4878,7 +4951,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4878
4951
|
details?: any;
|
|
4879
4952
|
isError: true;
|
|
4880
4953
|
};
|
|
4881
|
-
status: "
|
|
4954
|
+
status: "error";
|
|
4882
4955
|
thoughtSignature?: string;
|
|
4883
4956
|
time: {
|
|
4884
4957
|
start: number;
|
|
@@ -4904,26 +4977,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4904
4977
|
details?: any;
|
|
4905
4978
|
isError: true;
|
|
4906
4979
|
};
|
|
4907
|
-
status: "
|
|
4980
|
+
status: "skipped";
|
|
4908
4981
|
thoughtSignature?: string;
|
|
4909
4982
|
time: {
|
|
4910
4983
|
start: number;
|
|
4911
4984
|
end: number;
|
|
4912
4985
|
};
|
|
4913
4986
|
type: "toolCall";
|
|
4914
|
-
} | {
|
|
4915
|
-
type: "thinking";
|
|
4916
|
-
thinking: string;
|
|
4917
|
-
thinkingSignature?: string;
|
|
4918
|
-
redacted?: boolean;
|
|
4919
4987
|
} | {
|
|
4920
4988
|
addedToolNames?: string[];
|
|
4921
4989
|
arguments: Record<string, any>;
|
|
4922
4990
|
callID: string;
|
|
4923
4991
|
name: string;
|
|
4924
4992
|
namespace?: string;
|
|
4925
|
-
|
|
4926
|
-
content
|
|
4993
|
+
result: {
|
|
4994
|
+
content: ({
|
|
4927
4995
|
type: "text";
|
|
4928
4996
|
text: string;
|
|
4929
4997
|
textSignature?: string;
|
|
@@ -4933,8 +5001,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
4933
5001
|
mimeType: string;
|
|
4934
5002
|
})[];
|
|
4935
5003
|
details?: any;
|
|
5004
|
+
isError: true;
|
|
4936
5005
|
};
|
|
4937
|
-
status: "
|
|
5006
|
+
status: "aborted";
|
|
4938
5007
|
thoughtSignature?: string;
|
|
4939
5008
|
time: {
|
|
4940
5009
|
start: number;
|
|
@@ -5109,14 +5178,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5109
5178
|
type: "image";
|
|
5110
5179
|
data: string;
|
|
5111
5180
|
mimeType: string;
|
|
5181
|
+
} | {
|
|
5182
|
+
type: "thinking";
|
|
5183
|
+
thinking: string;
|
|
5184
|
+
thinkingSignature?: string;
|
|
5185
|
+
redacted?: boolean;
|
|
5112
5186
|
} | {
|
|
5113
5187
|
addedToolNames?: string[];
|
|
5114
5188
|
arguments: Record<string, any>;
|
|
5115
5189
|
callID: string;
|
|
5116
5190
|
name: string;
|
|
5117
5191
|
namespace?: string;
|
|
5118
|
-
|
|
5119
|
-
content
|
|
5192
|
+
partial?: {
|
|
5193
|
+
content?: ({
|
|
5120
5194
|
type: "text";
|
|
5121
5195
|
text: string;
|
|
5122
5196
|
textSignature?: string;
|
|
@@ -5126,9 +5200,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5126
5200
|
mimeType: string;
|
|
5127
5201
|
})[];
|
|
5128
5202
|
details?: any;
|
|
5129
|
-
isError: false;
|
|
5130
5203
|
};
|
|
5131
|
-
status: "
|
|
5204
|
+
status: "running";
|
|
5132
5205
|
thoughtSignature?: string;
|
|
5133
5206
|
time: {
|
|
5134
5207
|
start: number;
|
|
@@ -5152,9 +5225,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5152
5225
|
mimeType: string;
|
|
5153
5226
|
})[];
|
|
5154
5227
|
details?: any;
|
|
5155
|
-
isError:
|
|
5228
|
+
isError: false;
|
|
5156
5229
|
};
|
|
5157
|
-
status: "
|
|
5230
|
+
status: "completed";
|
|
5158
5231
|
thoughtSignature?: string;
|
|
5159
5232
|
time: {
|
|
5160
5233
|
start: number;
|
|
@@ -5180,7 +5253,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5180
5253
|
details?: any;
|
|
5181
5254
|
isError: true;
|
|
5182
5255
|
};
|
|
5183
|
-
status: "
|
|
5256
|
+
status: "error";
|
|
5184
5257
|
thoughtSignature?: string;
|
|
5185
5258
|
time: {
|
|
5186
5259
|
start: number;
|
|
@@ -5206,26 +5279,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5206
5279
|
details?: any;
|
|
5207
5280
|
isError: true;
|
|
5208
5281
|
};
|
|
5209
|
-
status: "
|
|
5282
|
+
status: "skipped";
|
|
5210
5283
|
thoughtSignature?: string;
|
|
5211
5284
|
time: {
|
|
5212
5285
|
start: number;
|
|
5213
5286
|
end: number;
|
|
5214
5287
|
};
|
|
5215
5288
|
type: "toolCall";
|
|
5216
|
-
} | {
|
|
5217
|
-
type: "thinking";
|
|
5218
|
-
thinking: string;
|
|
5219
|
-
thinkingSignature?: string;
|
|
5220
|
-
redacted?: boolean;
|
|
5221
5289
|
} | {
|
|
5222
5290
|
addedToolNames?: string[];
|
|
5223
5291
|
arguments: Record<string, any>;
|
|
5224
5292
|
callID: string;
|
|
5225
5293
|
name: string;
|
|
5226
5294
|
namespace?: string;
|
|
5227
|
-
|
|
5228
|
-
content
|
|
5295
|
+
result: {
|
|
5296
|
+
content: ({
|
|
5229
5297
|
type: "text";
|
|
5230
5298
|
text: string;
|
|
5231
5299
|
textSignature?: string;
|
|
@@ -5235,8 +5303,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5235
5303
|
mimeType: string;
|
|
5236
5304
|
})[];
|
|
5237
5305
|
details?: any;
|
|
5306
|
+
isError: true;
|
|
5238
5307
|
};
|
|
5239
|
-
status: "
|
|
5308
|
+
status: "aborted";
|
|
5240
5309
|
thoughtSignature?: string;
|
|
5241
5310
|
time: {
|
|
5242
5311
|
start: number;
|
|
@@ -5429,14 +5498,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5429
5498
|
type: "image";
|
|
5430
5499
|
data: string;
|
|
5431
5500
|
mimeType: string;
|
|
5501
|
+
} | {
|
|
5502
|
+
type: "thinking";
|
|
5503
|
+
thinking: string;
|
|
5504
|
+
thinkingSignature?: string;
|
|
5505
|
+
redacted?: boolean;
|
|
5432
5506
|
} | {
|
|
5433
5507
|
addedToolNames?: string[];
|
|
5434
5508
|
arguments: Record<string, any>;
|
|
5435
5509
|
callID: string;
|
|
5436
5510
|
name: string;
|
|
5437
5511
|
namespace?: string;
|
|
5438
|
-
|
|
5439
|
-
content
|
|
5512
|
+
partial?: {
|
|
5513
|
+
content?: ({
|
|
5440
5514
|
type: "text";
|
|
5441
5515
|
text: string;
|
|
5442
5516
|
textSignature?: string;
|
|
@@ -5446,9 +5520,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5446
5520
|
mimeType: string;
|
|
5447
5521
|
})[];
|
|
5448
5522
|
details?: any;
|
|
5449
|
-
isError: false;
|
|
5450
5523
|
};
|
|
5451
|
-
status: "
|
|
5524
|
+
status: "running";
|
|
5452
5525
|
thoughtSignature?: string;
|
|
5453
5526
|
time: {
|
|
5454
5527
|
start: number;
|
|
@@ -5472,9 +5545,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5472
5545
|
mimeType: string;
|
|
5473
5546
|
})[];
|
|
5474
5547
|
details?: any;
|
|
5475
|
-
isError:
|
|
5548
|
+
isError: false;
|
|
5476
5549
|
};
|
|
5477
|
-
status: "
|
|
5550
|
+
status: "completed";
|
|
5478
5551
|
thoughtSignature?: string;
|
|
5479
5552
|
time: {
|
|
5480
5553
|
start: number;
|
|
@@ -5500,7 +5573,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5500
5573
|
details?: any;
|
|
5501
5574
|
isError: true;
|
|
5502
5575
|
};
|
|
5503
|
-
status: "
|
|
5576
|
+
status: "error";
|
|
5504
5577
|
thoughtSignature?: string;
|
|
5505
5578
|
time: {
|
|
5506
5579
|
start: number;
|
|
@@ -5526,26 +5599,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5526
5599
|
details?: any;
|
|
5527
5600
|
isError: true;
|
|
5528
5601
|
};
|
|
5529
|
-
status: "
|
|
5602
|
+
status: "skipped";
|
|
5530
5603
|
thoughtSignature?: string;
|
|
5531
5604
|
time: {
|
|
5532
5605
|
start: number;
|
|
5533
5606
|
end: number;
|
|
5534
5607
|
};
|
|
5535
5608
|
type: "toolCall";
|
|
5536
|
-
} | {
|
|
5537
|
-
type: "thinking";
|
|
5538
|
-
thinking: string;
|
|
5539
|
-
thinkingSignature?: string;
|
|
5540
|
-
redacted?: boolean;
|
|
5541
5609
|
} | {
|
|
5542
5610
|
addedToolNames?: string[];
|
|
5543
5611
|
arguments: Record<string, any>;
|
|
5544
5612
|
callID: string;
|
|
5545
5613
|
name: string;
|
|
5546
5614
|
namespace?: string;
|
|
5547
|
-
|
|
5548
|
-
content
|
|
5615
|
+
result: {
|
|
5616
|
+
content: ({
|
|
5549
5617
|
type: "text";
|
|
5550
5618
|
text: string;
|
|
5551
5619
|
textSignature?: string;
|
|
@@ -5555,8 +5623,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5555
5623
|
mimeType: string;
|
|
5556
5624
|
})[];
|
|
5557
5625
|
details?: any;
|
|
5626
|
+
isError: true;
|
|
5558
5627
|
};
|
|
5559
|
-
status: "
|
|
5628
|
+
status: "aborted";
|
|
5560
5629
|
thoughtSignature?: string;
|
|
5561
5630
|
time: {
|
|
5562
5631
|
start: number;
|
|
@@ -5731,14 +5800,19 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5731
5800
|
type: "image";
|
|
5732
5801
|
data: string;
|
|
5733
5802
|
mimeType: string;
|
|
5803
|
+
} | {
|
|
5804
|
+
type: "thinking";
|
|
5805
|
+
thinking: string;
|
|
5806
|
+
thinkingSignature?: string;
|
|
5807
|
+
redacted?: boolean;
|
|
5734
5808
|
} | {
|
|
5735
5809
|
addedToolNames?: string[];
|
|
5736
5810
|
arguments: Record<string, any>;
|
|
5737
5811
|
callID: string;
|
|
5738
5812
|
name: string;
|
|
5739
5813
|
namespace?: string;
|
|
5740
|
-
|
|
5741
|
-
content
|
|
5814
|
+
partial?: {
|
|
5815
|
+
content?: ({
|
|
5742
5816
|
type: "text";
|
|
5743
5817
|
text: string;
|
|
5744
5818
|
textSignature?: string;
|
|
@@ -5748,9 +5822,8 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5748
5822
|
mimeType: string;
|
|
5749
5823
|
})[];
|
|
5750
5824
|
details?: any;
|
|
5751
|
-
isError: false;
|
|
5752
5825
|
};
|
|
5753
|
-
status: "
|
|
5826
|
+
status: "running";
|
|
5754
5827
|
thoughtSignature?: string;
|
|
5755
5828
|
time: {
|
|
5756
5829
|
start: number;
|
|
@@ -5774,9 +5847,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5774
5847
|
mimeType: string;
|
|
5775
5848
|
})[];
|
|
5776
5849
|
details?: any;
|
|
5777
|
-
isError:
|
|
5850
|
+
isError: false;
|
|
5778
5851
|
};
|
|
5779
|
-
status: "
|
|
5852
|
+
status: "completed";
|
|
5780
5853
|
thoughtSignature?: string;
|
|
5781
5854
|
time: {
|
|
5782
5855
|
start: number;
|
|
@@ -5802,7 +5875,7 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5802
5875
|
details?: any;
|
|
5803
5876
|
isError: true;
|
|
5804
5877
|
};
|
|
5805
|
-
status: "
|
|
5878
|
+
status: "error";
|
|
5806
5879
|
thoughtSignature?: string;
|
|
5807
5880
|
time: {
|
|
5808
5881
|
start: number;
|
|
@@ -5828,26 +5901,21 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5828
5901
|
details?: any;
|
|
5829
5902
|
isError: true;
|
|
5830
5903
|
};
|
|
5831
|
-
status: "
|
|
5904
|
+
status: "skipped";
|
|
5832
5905
|
thoughtSignature?: string;
|
|
5833
5906
|
time: {
|
|
5834
5907
|
start: number;
|
|
5835
5908
|
end: number;
|
|
5836
5909
|
};
|
|
5837
5910
|
type: "toolCall";
|
|
5838
|
-
} | {
|
|
5839
|
-
type: "thinking";
|
|
5840
|
-
thinking: string;
|
|
5841
|
-
thinkingSignature?: string;
|
|
5842
|
-
redacted?: boolean;
|
|
5843
5911
|
} | {
|
|
5844
5912
|
addedToolNames?: string[];
|
|
5845
5913
|
arguments: Record<string, any>;
|
|
5846
5914
|
callID: string;
|
|
5847
5915
|
name: string;
|
|
5848
5916
|
namespace?: string;
|
|
5849
|
-
|
|
5850
|
-
content
|
|
5917
|
+
result: {
|
|
5918
|
+
content: ({
|
|
5851
5919
|
type: "text";
|
|
5852
5920
|
text: string;
|
|
5853
5921
|
textSignature?: string;
|
|
@@ -5857,8 +5925,9 @@ declare const LLMStarted: Schema.Struct<{
|
|
|
5857
5925
|
mimeType: string;
|
|
5858
5926
|
})[];
|
|
5859
5927
|
details?: any;
|
|
5928
|
+
isError: true;
|
|
5860
5929
|
};
|
|
5861
|
-
status: "
|
|
5930
|
+
status: "aborted";
|
|
5862
5931
|
thoughtSignature?: string;
|
|
5863
5932
|
time: {
|
|
5864
5933
|
start: number;
|
|
@@ -6355,13 +6424,18 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6355
6424
|
data: string;
|
|
6356
6425
|
mimeType: string;
|
|
6357
6426
|
} | {
|
|
6358
|
-
|
|
6359
|
-
|
|
6427
|
+
type: "thinking";
|
|
6428
|
+
thinking: string;
|
|
6429
|
+
thinkingSignature?: string;
|
|
6430
|
+
redacted?: boolean;
|
|
6431
|
+
} | {
|
|
6432
|
+
addedToolNames?: string[];
|
|
6433
|
+
arguments: Record<string, any>;
|
|
6360
6434
|
callID: string;
|
|
6361
6435
|
name: string;
|
|
6362
6436
|
namespace?: string;
|
|
6363
|
-
|
|
6364
|
-
content
|
|
6437
|
+
partial?: {
|
|
6438
|
+
content?: ({
|
|
6365
6439
|
type: "text";
|
|
6366
6440
|
text: string;
|
|
6367
6441
|
textSignature?: string;
|
|
@@ -6371,9 +6445,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6371
6445
|
mimeType: string;
|
|
6372
6446
|
})[];
|
|
6373
6447
|
details?: any;
|
|
6374
|
-
isError: false;
|
|
6375
6448
|
};
|
|
6376
|
-
status: "
|
|
6449
|
+
status: "running";
|
|
6377
6450
|
thoughtSignature?: string;
|
|
6378
6451
|
time: {
|
|
6379
6452
|
start: number;
|
|
@@ -6397,9 +6470,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6397
6470
|
mimeType: string;
|
|
6398
6471
|
})[];
|
|
6399
6472
|
details?: any;
|
|
6400
|
-
isError:
|
|
6473
|
+
isError: false;
|
|
6401
6474
|
};
|
|
6402
|
-
status: "
|
|
6475
|
+
status: "completed";
|
|
6403
6476
|
thoughtSignature?: string;
|
|
6404
6477
|
time: {
|
|
6405
6478
|
start: number;
|
|
@@ -6425,7 +6498,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6425
6498
|
details?: any;
|
|
6426
6499
|
isError: true;
|
|
6427
6500
|
};
|
|
6428
|
-
status: "
|
|
6501
|
+
status: "error";
|
|
6429
6502
|
thoughtSignature?: string;
|
|
6430
6503
|
time: {
|
|
6431
6504
|
start: number;
|
|
@@ -6451,26 +6524,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6451
6524
|
details?: any;
|
|
6452
6525
|
isError: true;
|
|
6453
6526
|
};
|
|
6454
|
-
status: "
|
|
6527
|
+
status: "skipped";
|
|
6455
6528
|
thoughtSignature?: string;
|
|
6456
6529
|
time: {
|
|
6457
6530
|
start: number;
|
|
6458
6531
|
end: number;
|
|
6459
6532
|
};
|
|
6460
6533
|
type: "toolCall";
|
|
6461
|
-
} | {
|
|
6462
|
-
type: "thinking";
|
|
6463
|
-
thinking: string;
|
|
6464
|
-
thinkingSignature?: string;
|
|
6465
|
-
redacted?: boolean;
|
|
6466
6534
|
} | {
|
|
6467
6535
|
addedToolNames?: string[];
|
|
6468
6536
|
arguments: Record<string, any>;
|
|
6469
6537
|
callID: string;
|
|
6470
6538
|
name: string;
|
|
6471
6539
|
namespace?: string;
|
|
6472
|
-
|
|
6473
|
-
content
|
|
6540
|
+
result: {
|
|
6541
|
+
content: ({
|
|
6474
6542
|
type: "text";
|
|
6475
6543
|
text: string;
|
|
6476
6544
|
textSignature?: string;
|
|
@@ -6480,8 +6548,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6480
6548
|
mimeType: string;
|
|
6481
6549
|
})[];
|
|
6482
6550
|
details?: any;
|
|
6551
|
+
isError: true;
|
|
6483
6552
|
};
|
|
6484
|
-
status: "
|
|
6553
|
+
status: "aborted";
|
|
6485
6554
|
thoughtSignature?: string;
|
|
6486
6555
|
time: {
|
|
6487
6556
|
start: number;
|
|
@@ -6656,14 +6725,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6656
6725
|
type: "image";
|
|
6657
6726
|
data: string;
|
|
6658
6727
|
mimeType: string;
|
|
6728
|
+
} | {
|
|
6729
|
+
type: "thinking";
|
|
6730
|
+
thinking: string;
|
|
6731
|
+
thinkingSignature?: string;
|
|
6732
|
+
redacted?: boolean;
|
|
6659
6733
|
} | {
|
|
6660
6734
|
addedToolNames?: string[];
|
|
6661
6735
|
arguments: Record<string, any>;
|
|
6662
6736
|
callID: string;
|
|
6663
6737
|
name: string;
|
|
6664
6738
|
namespace?: string;
|
|
6665
|
-
|
|
6666
|
-
content
|
|
6739
|
+
partial?: {
|
|
6740
|
+
content?: ({
|
|
6667
6741
|
type: "text";
|
|
6668
6742
|
text: string;
|
|
6669
6743
|
textSignature?: string;
|
|
@@ -6673,9 +6747,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6673
6747
|
mimeType: string;
|
|
6674
6748
|
})[];
|
|
6675
6749
|
details?: any;
|
|
6676
|
-
isError: false;
|
|
6677
6750
|
};
|
|
6678
|
-
status: "
|
|
6751
|
+
status: "running";
|
|
6679
6752
|
thoughtSignature?: string;
|
|
6680
6753
|
time: {
|
|
6681
6754
|
start: number;
|
|
@@ -6699,9 +6772,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6699
6772
|
mimeType: string;
|
|
6700
6773
|
})[];
|
|
6701
6774
|
details?: any;
|
|
6702
|
-
isError:
|
|
6775
|
+
isError: false;
|
|
6703
6776
|
};
|
|
6704
|
-
status: "
|
|
6777
|
+
status: "completed";
|
|
6705
6778
|
thoughtSignature?: string;
|
|
6706
6779
|
time: {
|
|
6707
6780
|
start: number;
|
|
@@ -6727,7 +6800,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6727
6800
|
details?: any;
|
|
6728
6801
|
isError: true;
|
|
6729
6802
|
};
|
|
6730
|
-
status: "
|
|
6803
|
+
status: "error";
|
|
6731
6804
|
thoughtSignature?: string;
|
|
6732
6805
|
time: {
|
|
6733
6806
|
start: number;
|
|
@@ -6753,26 +6826,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6753
6826
|
details?: any;
|
|
6754
6827
|
isError: true;
|
|
6755
6828
|
};
|
|
6756
|
-
status: "
|
|
6829
|
+
status: "skipped";
|
|
6757
6830
|
thoughtSignature?: string;
|
|
6758
6831
|
time: {
|
|
6759
6832
|
start: number;
|
|
6760
6833
|
end: number;
|
|
6761
6834
|
};
|
|
6762
6835
|
type: "toolCall";
|
|
6763
|
-
} | {
|
|
6764
|
-
type: "thinking";
|
|
6765
|
-
thinking: string;
|
|
6766
|
-
thinkingSignature?: string;
|
|
6767
|
-
redacted?: boolean;
|
|
6768
6836
|
} | {
|
|
6769
6837
|
addedToolNames?: string[];
|
|
6770
6838
|
arguments: Record<string, any>;
|
|
6771
6839
|
callID: string;
|
|
6772
6840
|
name: string;
|
|
6773
6841
|
namespace?: string;
|
|
6774
|
-
|
|
6775
|
-
content
|
|
6842
|
+
result: {
|
|
6843
|
+
content: ({
|
|
6776
6844
|
type: "text";
|
|
6777
6845
|
text: string;
|
|
6778
6846
|
textSignature?: string;
|
|
@@ -6782,8 +6850,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6782
6850
|
mimeType: string;
|
|
6783
6851
|
})[];
|
|
6784
6852
|
details?: any;
|
|
6853
|
+
isError: true;
|
|
6785
6854
|
};
|
|
6786
|
-
status: "
|
|
6855
|
+
status: "aborted";
|
|
6787
6856
|
thoughtSignature?: string;
|
|
6788
6857
|
time: {
|
|
6789
6858
|
start: number;
|
|
@@ -6977,14 +7046,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6977
7046
|
type: "image";
|
|
6978
7047
|
data: string;
|
|
6979
7048
|
mimeType: string;
|
|
7049
|
+
} | {
|
|
7050
|
+
type: "thinking";
|
|
7051
|
+
thinking: string;
|
|
7052
|
+
thinkingSignature?: string;
|
|
7053
|
+
redacted?: boolean;
|
|
6980
7054
|
} | {
|
|
6981
7055
|
addedToolNames?: string[];
|
|
6982
7056
|
arguments: Record<string, any>;
|
|
6983
7057
|
callID: string;
|
|
6984
7058
|
name: string;
|
|
6985
7059
|
namespace?: string;
|
|
6986
|
-
|
|
6987
|
-
content
|
|
7060
|
+
partial?: {
|
|
7061
|
+
content?: ({
|
|
6988
7062
|
type: "text";
|
|
6989
7063
|
text: string;
|
|
6990
7064
|
textSignature?: string;
|
|
@@ -6994,9 +7068,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
6994
7068
|
mimeType: string;
|
|
6995
7069
|
})[];
|
|
6996
7070
|
details?: any;
|
|
6997
|
-
isError: false;
|
|
6998
7071
|
};
|
|
6999
|
-
status: "
|
|
7072
|
+
status: "running";
|
|
7000
7073
|
thoughtSignature?: string;
|
|
7001
7074
|
time: {
|
|
7002
7075
|
start: number;
|
|
@@ -7020,9 +7093,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7020
7093
|
mimeType: string;
|
|
7021
7094
|
})[];
|
|
7022
7095
|
details?: any;
|
|
7023
|
-
isError:
|
|
7096
|
+
isError: false;
|
|
7024
7097
|
};
|
|
7025
|
-
status: "
|
|
7098
|
+
status: "completed";
|
|
7026
7099
|
thoughtSignature?: string;
|
|
7027
7100
|
time: {
|
|
7028
7101
|
start: number;
|
|
@@ -7048,7 +7121,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7048
7121
|
details?: any;
|
|
7049
7122
|
isError: true;
|
|
7050
7123
|
};
|
|
7051
|
-
status: "
|
|
7124
|
+
status: "error";
|
|
7052
7125
|
thoughtSignature?: string;
|
|
7053
7126
|
time: {
|
|
7054
7127
|
start: number;
|
|
@@ -7074,26 +7147,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7074
7147
|
details?: any;
|
|
7075
7148
|
isError: true;
|
|
7076
7149
|
};
|
|
7077
|
-
status: "
|
|
7150
|
+
status: "skipped";
|
|
7078
7151
|
thoughtSignature?: string;
|
|
7079
7152
|
time: {
|
|
7080
7153
|
start: number;
|
|
7081
7154
|
end: number;
|
|
7082
7155
|
};
|
|
7083
7156
|
type: "toolCall";
|
|
7084
|
-
} | {
|
|
7085
|
-
type: "thinking";
|
|
7086
|
-
thinking: string;
|
|
7087
|
-
thinkingSignature?: string;
|
|
7088
|
-
redacted?: boolean;
|
|
7089
7157
|
} | {
|
|
7090
7158
|
addedToolNames?: string[];
|
|
7091
7159
|
arguments: Record<string, any>;
|
|
7092
7160
|
callID: string;
|
|
7093
7161
|
name: string;
|
|
7094
7162
|
namespace?: string;
|
|
7095
|
-
|
|
7096
|
-
content
|
|
7163
|
+
result: {
|
|
7164
|
+
content: ({
|
|
7097
7165
|
type: "text";
|
|
7098
7166
|
text: string;
|
|
7099
7167
|
textSignature?: string;
|
|
@@ -7103,8 +7171,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7103
7171
|
mimeType: string;
|
|
7104
7172
|
})[];
|
|
7105
7173
|
details?: any;
|
|
7174
|
+
isError: true;
|
|
7106
7175
|
};
|
|
7107
|
-
status: "
|
|
7176
|
+
status: "aborted";
|
|
7108
7177
|
thoughtSignature?: string;
|
|
7109
7178
|
time: {
|
|
7110
7179
|
start: number;
|
|
@@ -7279,14 +7348,19 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7279
7348
|
type: "image";
|
|
7280
7349
|
data: string;
|
|
7281
7350
|
mimeType: string;
|
|
7351
|
+
} | {
|
|
7352
|
+
type: "thinking";
|
|
7353
|
+
thinking: string;
|
|
7354
|
+
thinkingSignature?: string;
|
|
7355
|
+
redacted?: boolean;
|
|
7282
7356
|
} | {
|
|
7283
7357
|
addedToolNames?: string[];
|
|
7284
7358
|
arguments: Record<string, any>;
|
|
7285
7359
|
callID: string;
|
|
7286
7360
|
name: string;
|
|
7287
7361
|
namespace?: string;
|
|
7288
|
-
|
|
7289
|
-
content
|
|
7362
|
+
partial?: {
|
|
7363
|
+
content?: ({
|
|
7290
7364
|
type: "text";
|
|
7291
7365
|
text: string;
|
|
7292
7366
|
textSignature?: string;
|
|
@@ -7296,9 +7370,8 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7296
7370
|
mimeType: string;
|
|
7297
7371
|
})[];
|
|
7298
7372
|
details?: any;
|
|
7299
|
-
isError: false;
|
|
7300
7373
|
};
|
|
7301
|
-
status: "
|
|
7374
|
+
status: "running";
|
|
7302
7375
|
thoughtSignature?: string;
|
|
7303
7376
|
time: {
|
|
7304
7377
|
start: number;
|
|
@@ -7322,9 +7395,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7322
7395
|
mimeType: string;
|
|
7323
7396
|
})[];
|
|
7324
7397
|
details?: any;
|
|
7325
|
-
isError:
|
|
7398
|
+
isError: false;
|
|
7326
7399
|
};
|
|
7327
|
-
status: "
|
|
7400
|
+
status: "completed";
|
|
7328
7401
|
thoughtSignature?: string;
|
|
7329
7402
|
time: {
|
|
7330
7403
|
start: number;
|
|
@@ -7350,7 +7423,7 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7350
7423
|
details?: any;
|
|
7351
7424
|
isError: true;
|
|
7352
7425
|
};
|
|
7353
|
-
status: "
|
|
7426
|
+
status: "error";
|
|
7354
7427
|
thoughtSignature?: string;
|
|
7355
7428
|
time: {
|
|
7356
7429
|
start: number;
|
|
@@ -7376,26 +7449,21 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7376
7449
|
details?: any;
|
|
7377
7450
|
isError: true;
|
|
7378
7451
|
};
|
|
7379
|
-
status: "
|
|
7452
|
+
status: "skipped";
|
|
7380
7453
|
thoughtSignature?: string;
|
|
7381
7454
|
time: {
|
|
7382
7455
|
start: number;
|
|
7383
7456
|
end: number;
|
|
7384
7457
|
};
|
|
7385
7458
|
type: "toolCall";
|
|
7386
|
-
} | {
|
|
7387
|
-
type: "thinking";
|
|
7388
|
-
thinking: string;
|
|
7389
|
-
thinkingSignature?: string;
|
|
7390
|
-
redacted?: boolean;
|
|
7391
7459
|
} | {
|
|
7392
7460
|
addedToolNames?: string[];
|
|
7393
7461
|
arguments: Record<string, any>;
|
|
7394
7462
|
callID: string;
|
|
7395
7463
|
name: string;
|
|
7396
7464
|
namespace?: string;
|
|
7397
|
-
|
|
7398
|
-
content
|
|
7465
|
+
result: {
|
|
7466
|
+
content: ({
|
|
7399
7467
|
type: "text";
|
|
7400
7468
|
text: string;
|
|
7401
7469
|
textSignature?: string;
|
|
@@ -7405,8 +7473,9 @@ declare const LLMEnded: Schema.Struct<{
|
|
|
7405
7473
|
mimeType: string;
|
|
7406
7474
|
})[];
|
|
7407
7475
|
details?: any;
|
|
7476
|
+
isError: true;
|
|
7408
7477
|
};
|
|
7409
|
-
status: "
|
|
7478
|
+
status: "aborted";
|
|
7410
7479
|
thoughtSignature?: string;
|
|
7411
7480
|
time: {
|
|
7412
7481
|
start: number;
|
|
@@ -7612,14 +7681,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7612
7681
|
type: "image";
|
|
7613
7682
|
data: string;
|
|
7614
7683
|
mimeType: string;
|
|
7684
|
+
} | {
|
|
7685
|
+
type: "thinking";
|
|
7686
|
+
thinking: string;
|
|
7687
|
+
thinkingSignature?: string;
|
|
7688
|
+
redacted?: boolean;
|
|
7615
7689
|
} | {
|
|
7616
7690
|
addedToolNames?: string[];
|
|
7617
7691
|
arguments: Record<string, any>;
|
|
7618
7692
|
callID: string;
|
|
7619
7693
|
name: string;
|
|
7620
7694
|
namespace?: string;
|
|
7621
|
-
|
|
7622
|
-
content
|
|
7695
|
+
partial?: {
|
|
7696
|
+
content?: ({
|
|
7623
7697
|
type: "text";
|
|
7624
7698
|
text: string;
|
|
7625
7699
|
textSignature?: string;
|
|
@@ -7629,9 +7703,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7629
7703
|
mimeType: string;
|
|
7630
7704
|
})[];
|
|
7631
7705
|
details?: any;
|
|
7632
|
-
isError: false;
|
|
7633
7706
|
};
|
|
7634
|
-
status: "
|
|
7707
|
+
status: "running";
|
|
7635
7708
|
thoughtSignature?: string;
|
|
7636
7709
|
time: {
|
|
7637
7710
|
start: number;
|
|
@@ -7655,9 +7728,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7655
7728
|
mimeType: string;
|
|
7656
7729
|
})[];
|
|
7657
7730
|
details?: any;
|
|
7658
|
-
isError:
|
|
7731
|
+
isError: false;
|
|
7659
7732
|
};
|
|
7660
|
-
status: "
|
|
7733
|
+
status: "completed";
|
|
7661
7734
|
thoughtSignature?: string;
|
|
7662
7735
|
time: {
|
|
7663
7736
|
start: number;
|
|
@@ -7683,7 +7756,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7683
7756
|
details?: any;
|
|
7684
7757
|
isError: true;
|
|
7685
7758
|
};
|
|
7686
|
-
status: "
|
|
7759
|
+
status: "error";
|
|
7687
7760
|
thoughtSignature?: string;
|
|
7688
7761
|
time: {
|
|
7689
7762
|
start: number;
|
|
@@ -7709,26 +7782,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7709
7782
|
details?: any;
|
|
7710
7783
|
isError: true;
|
|
7711
7784
|
};
|
|
7712
|
-
status: "
|
|
7785
|
+
status: "skipped";
|
|
7713
7786
|
thoughtSignature?: string;
|
|
7714
7787
|
time: {
|
|
7715
7788
|
start: number;
|
|
7716
7789
|
end: number;
|
|
7717
7790
|
};
|
|
7718
7791
|
type: "toolCall";
|
|
7719
|
-
} | {
|
|
7720
|
-
type: "thinking";
|
|
7721
|
-
thinking: string;
|
|
7722
|
-
thinkingSignature?: string;
|
|
7723
|
-
redacted?: boolean;
|
|
7724
7792
|
} | {
|
|
7725
7793
|
addedToolNames?: string[];
|
|
7726
7794
|
arguments: Record<string, any>;
|
|
7727
7795
|
callID: string;
|
|
7728
7796
|
name: string;
|
|
7729
7797
|
namespace?: string;
|
|
7730
|
-
|
|
7731
|
-
content
|
|
7798
|
+
result: {
|
|
7799
|
+
content: ({
|
|
7732
7800
|
type: "text";
|
|
7733
7801
|
text: string;
|
|
7734
7802
|
textSignature?: string;
|
|
@@ -7738,8 +7806,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7738
7806
|
mimeType: string;
|
|
7739
7807
|
})[];
|
|
7740
7808
|
details?: any;
|
|
7809
|
+
isError: true;
|
|
7741
7810
|
};
|
|
7742
|
-
status: "
|
|
7811
|
+
status: "aborted";
|
|
7743
7812
|
thoughtSignature?: string;
|
|
7744
7813
|
time: {
|
|
7745
7814
|
start: number;
|
|
@@ -7914,14 +7983,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7914
7983
|
type: "image";
|
|
7915
7984
|
data: string;
|
|
7916
7985
|
mimeType: string;
|
|
7986
|
+
} | {
|
|
7987
|
+
type: "thinking";
|
|
7988
|
+
thinking: string;
|
|
7989
|
+
thinkingSignature?: string;
|
|
7990
|
+
redacted?: boolean;
|
|
7917
7991
|
} | {
|
|
7918
7992
|
addedToolNames?: string[];
|
|
7919
7993
|
arguments: Record<string, any>;
|
|
7920
7994
|
callID: string;
|
|
7921
7995
|
name: string;
|
|
7922
7996
|
namespace?: string;
|
|
7923
|
-
|
|
7924
|
-
content
|
|
7997
|
+
partial?: {
|
|
7998
|
+
content?: ({
|
|
7925
7999
|
type: "text";
|
|
7926
8000
|
text: string;
|
|
7927
8001
|
textSignature?: string;
|
|
@@ -7931,9 +8005,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7931
8005
|
mimeType: string;
|
|
7932
8006
|
})[];
|
|
7933
8007
|
details?: any;
|
|
7934
|
-
isError: false;
|
|
7935
8008
|
};
|
|
7936
|
-
status: "
|
|
8009
|
+
status: "running";
|
|
7937
8010
|
thoughtSignature?: string;
|
|
7938
8011
|
time: {
|
|
7939
8012
|
start: number;
|
|
@@ -7957,9 +8030,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7957
8030
|
mimeType: string;
|
|
7958
8031
|
})[];
|
|
7959
8032
|
details?: any;
|
|
7960
|
-
isError:
|
|
8033
|
+
isError: false;
|
|
7961
8034
|
};
|
|
7962
|
-
status: "
|
|
8035
|
+
status: "completed";
|
|
7963
8036
|
thoughtSignature?: string;
|
|
7964
8037
|
time: {
|
|
7965
8038
|
start: number;
|
|
@@ -7985,7 +8058,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
7985
8058
|
details?: any;
|
|
7986
8059
|
isError: true;
|
|
7987
8060
|
};
|
|
7988
|
-
status: "
|
|
8061
|
+
status: "error";
|
|
7989
8062
|
thoughtSignature?: string;
|
|
7990
8063
|
time: {
|
|
7991
8064
|
start: number;
|
|
@@ -8011,26 +8084,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8011
8084
|
details?: any;
|
|
8012
8085
|
isError: true;
|
|
8013
8086
|
};
|
|
8014
|
-
status: "
|
|
8087
|
+
status: "skipped";
|
|
8015
8088
|
thoughtSignature?: string;
|
|
8016
8089
|
time: {
|
|
8017
8090
|
start: number;
|
|
8018
8091
|
end: number;
|
|
8019
8092
|
};
|
|
8020
8093
|
type: "toolCall";
|
|
8021
|
-
} | {
|
|
8022
|
-
type: "thinking";
|
|
8023
|
-
thinking: string;
|
|
8024
|
-
thinkingSignature?: string;
|
|
8025
|
-
redacted?: boolean;
|
|
8026
8094
|
} | {
|
|
8027
8095
|
addedToolNames?: string[];
|
|
8028
8096
|
arguments: Record<string, any>;
|
|
8029
8097
|
callID: string;
|
|
8030
8098
|
name: string;
|
|
8031
8099
|
namespace?: string;
|
|
8032
|
-
|
|
8033
|
-
content
|
|
8100
|
+
result: {
|
|
8101
|
+
content: ({
|
|
8034
8102
|
type: "text";
|
|
8035
8103
|
text: string;
|
|
8036
8104
|
textSignature?: string;
|
|
@@ -8040,8 +8108,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8040
8108
|
mimeType: string;
|
|
8041
8109
|
})[];
|
|
8042
8110
|
details?: any;
|
|
8111
|
+
isError: true;
|
|
8043
8112
|
};
|
|
8044
|
-
status: "
|
|
8113
|
+
status: "aborted";
|
|
8045
8114
|
thoughtSignature?: string;
|
|
8046
8115
|
time: {
|
|
8047
8116
|
start: number;
|
|
@@ -8235,14 +8304,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8235
8304
|
type: "image";
|
|
8236
8305
|
data: string;
|
|
8237
8306
|
mimeType: string;
|
|
8307
|
+
} | {
|
|
8308
|
+
type: "thinking";
|
|
8309
|
+
thinking: string;
|
|
8310
|
+
thinkingSignature?: string;
|
|
8311
|
+
redacted?: boolean;
|
|
8238
8312
|
} | {
|
|
8239
8313
|
addedToolNames?: string[];
|
|
8240
8314
|
arguments: Record<string, any>;
|
|
8241
8315
|
callID: string;
|
|
8242
8316
|
name: string;
|
|
8243
8317
|
namespace?: string;
|
|
8244
|
-
|
|
8245
|
-
content
|
|
8318
|
+
partial?: {
|
|
8319
|
+
content?: ({
|
|
8246
8320
|
type: "text";
|
|
8247
8321
|
text: string;
|
|
8248
8322
|
textSignature?: string;
|
|
@@ -8252,9 +8326,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8252
8326
|
mimeType: string;
|
|
8253
8327
|
})[];
|
|
8254
8328
|
details?: any;
|
|
8255
|
-
isError: false;
|
|
8256
8329
|
};
|
|
8257
|
-
status: "
|
|
8330
|
+
status: "running";
|
|
8258
8331
|
thoughtSignature?: string;
|
|
8259
8332
|
time: {
|
|
8260
8333
|
start: number;
|
|
@@ -8278,9 +8351,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8278
8351
|
mimeType: string;
|
|
8279
8352
|
})[];
|
|
8280
8353
|
details?: any;
|
|
8281
|
-
isError:
|
|
8354
|
+
isError: false;
|
|
8282
8355
|
};
|
|
8283
|
-
status: "
|
|
8356
|
+
status: "completed";
|
|
8284
8357
|
thoughtSignature?: string;
|
|
8285
8358
|
time: {
|
|
8286
8359
|
start: number;
|
|
@@ -8306,7 +8379,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8306
8379
|
details?: any;
|
|
8307
8380
|
isError: true;
|
|
8308
8381
|
};
|
|
8309
|
-
status: "
|
|
8382
|
+
status: "error";
|
|
8310
8383
|
thoughtSignature?: string;
|
|
8311
8384
|
time: {
|
|
8312
8385
|
start: number;
|
|
@@ -8332,26 +8405,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8332
8405
|
details?: any;
|
|
8333
8406
|
isError: true;
|
|
8334
8407
|
};
|
|
8335
|
-
status: "
|
|
8408
|
+
status: "skipped";
|
|
8336
8409
|
thoughtSignature?: string;
|
|
8337
8410
|
time: {
|
|
8338
8411
|
start: number;
|
|
8339
8412
|
end: number;
|
|
8340
8413
|
};
|
|
8341
8414
|
type: "toolCall";
|
|
8342
|
-
} | {
|
|
8343
|
-
type: "thinking";
|
|
8344
|
-
thinking: string;
|
|
8345
|
-
thinkingSignature?: string;
|
|
8346
|
-
redacted?: boolean;
|
|
8347
8415
|
} | {
|
|
8348
8416
|
addedToolNames?: string[];
|
|
8349
8417
|
arguments: Record<string, any>;
|
|
8350
8418
|
callID: string;
|
|
8351
8419
|
name: string;
|
|
8352
8420
|
namespace?: string;
|
|
8353
|
-
|
|
8354
|
-
content
|
|
8421
|
+
result: {
|
|
8422
|
+
content: ({
|
|
8355
8423
|
type: "text";
|
|
8356
8424
|
text: string;
|
|
8357
8425
|
textSignature?: string;
|
|
@@ -8361,8 +8429,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8361
8429
|
mimeType: string;
|
|
8362
8430
|
})[];
|
|
8363
8431
|
details?: any;
|
|
8432
|
+
isError: true;
|
|
8364
8433
|
};
|
|
8365
|
-
status: "
|
|
8434
|
+
status: "aborted";
|
|
8366
8435
|
thoughtSignature?: string;
|
|
8367
8436
|
time: {
|
|
8368
8437
|
start: number;
|
|
@@ -8537,14 +8606,19 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8537
8606
|
type: "image";
|
|
8538
8607
|
data: string;
|
|
8539
8608
|
mimeType: string;
|
|
8609
|
+
} | {
|
|
8610
|
+
type: "thinking";
|
|
8611
|
+
thinking: string;
|
|
8612
|
+
thinkingSignature?: string;
|
|
8613
|
+
redacted?: boolean;
|
|
8540
8614
|
} | {
|
|
8541
8615
|
addedToolNames?: string[];
|
|
8542
8616
|
arguments: Record<string, any>;
|
|
8543
8617
|
callID: string;
|
|
8544
8618
|
name: string;
|
|
8545
8619
|
namespace?: string;
|
|
8546
|
-
|
|
8547
|
-
content
|
|
8620
|
+
partial?: {
|
|
8621
|
+
content?: ({
|
|
8548
8622
|
type: "text";
|
|
8549
8623
|
text: string;
|
|
8550
8624
|
textSignature?: string;
|
|
@@ -8554,9 +8628,8 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8554
8628
|
mimeType: string;
|
|
8555
8629
|
})[];
|
|
8556
8630
|
details?: any;
|
|
8557
|
-
isError: false;
|
|
8558
8631
|
};
|
|
8559
|
-
status: "
|
|
8632
|
+
status: "running";
|
|
8560
8633
|
thoughtSignature?: string;
|
|
8561
8634
|
time: {
|
|
8562
8635
|
start: number;
|
|
@@ -8580,9 +8653,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8580
8653
|
mimeType: string;
|
|
8581
8654
|
})[];
|
|
8582
8655
|
details?: any;
|
|
8583
|
-
isError:
|
|
8656
|
+
isError: false;
|
|
8584
8657
|
};
|
|
8585
|
-
status: "
|
|
8658
|
+
status: "completed";
|
|
8586
8659
|
thoughtSignature?: string;
|
|
8587
8660
|
time: {
|
|
8588
8661
|
start: number;
|
|
@@ -8608,7 +8681,7 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8608
8681
|
details?: any;
|
|
8609
8682
|
isError: true;
|
|
8610
8683
|
};
|
|
8611
|
-
status: "
|
|
8684
|
+
status: "error";
|
|
8612
8685
|
thoughtSignature?: string;
|
|
8613
8686
|
time: {
|
|
8614
8687
|
start: number;
|
|
@@ -8634,26 +8707,21 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8634
8707
|
details?: any;
|
|
8635
8708
|
isError: true;
|
|
8636
8709
|
};
|
|
8637
|
-
status: "
|
|
8710
|
+
status: "skipped";
|
|
8638
8711
|
thoughtSignature?: string;
|
|
8639
8712
|
time: {
|
|
8640
8713
|
start: number;
|
|
8641
8714
|
end: number;
|
|
8642
8715
|
};
|
|
8643
8716
|
type: "toolCall";
|
|
8644
|
-
} | {
|
|
8645
|
-
type: "thinking";
|
|
8646
|
-
thinking: string;
|
|
8647
|
-
thinkingSignature?: string;
|
|
8648
|
-
redacted?: boolean;
|
|
8649
8717
|
} | {
|
|
8650
8718
|
addedToolNames?: string[];
|
|
8651
8719
|
arguments: Record<string, any>;
|
|
8652
8720
|
callID: string;
|
|
8653
8721
|
name: string;
|
|
8654
8722
|
namespace?: string;
|
|
8655
|
-
|
|
8656
|
-
content
|
|
8723
|
+
result: {
|
|
8724
|
+
content: ({
|
|
8657
8725
|
type: "text";
|
|
8658
8726
|
text: string;
|
|
8659
8727
|
textSignature?: string;
|
|
@@ -8663,8 +8731,9 @@ declare const LLMFailed: Schema.Struct<{
|
|
|
8663
8731
|
mimeType: string;
|
|
8664
8732
|
})[];
|
|
8665
8733
|
details?: any;
|
|
8734
|
+
isError: true;
|
|
8666
8735
|
};
|
|
8667
|
-
status: "
|
|
8736
|
+
status: "aborted";
|
|
8668
8737
|
thoughtSignature?: string;
|
|
8669
8738
|
time: {
|
|
8670
8739
|
start: number;
|
|
@@ -10412,14 +10481,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10412
10481
|
type: "image";
|
|
10413
10482
|
data: string;
|
|
10414
10483
|
mimeType: string;
|
|
10484
|
+
} | {
|
|
10485
|
+
type: "thinking";
|
|
10486
|
+
thinking: string;
|
|
10487
|
+
thinkingSignature?: string;
|
|
10488
|
+
redacted?: boolean;
|
|
10415
10489
|
} | {
|
|
10416
10490
|
addedToolNames?: string[];
|
|
10417
10491
|
arguments: Record<string, any>;
|
|
10418
10492
|
callID: string;
|
|
10419
10493
|
name: string;
|
|
10420
10494
|
namespace?: string;
|
|
10421
|
-
|
|
10422
|
-
content
|
|
10495
|
+
partial?: {
|
|
10496
|
+
content?: ({
|
|
10423
10497
|
type: "text";
|
|
10424
10498
|
text: string;
|
|
10425
10499
|
textSignature?: string;
|
|
@@ -10429,9 +10503,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10429
10503
|
mimeType: string;
|
|
10430
10504
|
})[];
|
|
10431
10505
|
details?: any;
|
|
10432
|
-
isError: false;
|
|
10433
10506
|
};
|
|
10434
|
-
status: "
|
|
10507
|
+
status: "running";
|
|
10435
10508
|
thoughtSignature?: string;
|
|
10436
10509
|
time: {
|
|
10437
10510
|
start: number;
|
|
@@ -10455,9 +10528,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10455
10528
|
mimeType: string;
|
|
10456
10529
|
})[];
|
|
10457
10530
|
details?: any;
|
|
10458
|
-
isError:
|
|
10531
|
+
isError: false;
|
|
10459
10532
|
};
|
|
10460
|
-
status: "
|
|
10533
|
+
status: "completed";
|
|
10461
10534
|
thoughtSignature?: string;
|
|
10462
10535
|
time: {
|
|
10463
10536
|
start: number;
|
|
@@ -10483,7 +10556,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10483
10556
|
details?: any;
|
|
10484
10557
|
isError: true;
|
|
10485
10558
|
};
|
|
10486
|
-
status: "
|
|
10559
|
+
status: "error";
|
|
10487
10560
|
thoughtSignature?: string;
|
|
10488
10561
|
time: {
|
|
10489
10562
|
start: number;
|
|
@@ -10509,26 +10582,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10509
10582
|
details?: any;
|
|
10510
10583
|
isError: true;
|
|
10511
10584
|
};
|
|
10512
|
-
status: "
|
|
10585
|
+
status: "skipped";
|
|
10513
10586
|
thoughtSignature?: string;
|
|
10514
10587
|
time: {
|
|
10515
10588
|
start: number;
|
|
10516
10589
|
end: number;
|
|
10517
10590
|
};
|
|
10518
10591
|
type: "toolCall";
|
|
10519
|
-
} | {
|
|
10520
|
-
type: "thinking";
|
|
10521
|
-
thinking: string;
|
|
10522
|
-
thinkingSignature?: string;
|
|
10523
|
-
redacted?: boolean;
|
|
10524
10592
|
} | {
|
|
10525
10593
|
addedToolNames?: string[];
|
|
10526
10594
|
arguments: Record<string, any>;
|
|
10527
10595
|
callID: string;
|
|
10528
10596
|
name: string;
|
|
10529
10597
|
namespace?: string;
|
|
10530
|
-
|
|
10531
|
-
content
|
|
10598
|
+
result: {
|
|
10599
|
+
content: ({
|
|
10532
10600
|
type: "text";
|
|
10533
10601
|
text: string;
|
|
10534
10602
|
textSignature?: string;
|
|
@@ -10538,8 +10606,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10538
10606
|
mimeType: string;
|
|
10539
10607
|
})[];
|
|
10540
10608
|
details?: any;
|
|
10609
|
+
isError: true;
|
|
10541
10610
|
};
|
|
10542
|
-
status: "
|
|
10611
|
+
status: "aborted";
|
|
10543
10612
|
thoughtSignature?: string;
|
|
10544
10613
|
time: {
|
|
10545
10614
|
start: number;
|
|
@@ -10714,14 +10783,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10714
10783
|
type: "image";
|
|
10715
10784
|
data: string;
|
|
10716
10785
|
mimeType: string;
|
|
10786
|
+
} | {
|
|
10787
|
+
type: "thinking";
|
|
10788
|
+
thinking: string;
|
|
10789
|
+
thinkingSignature?: string;
|
|
10790
|
+
redacted?: boolean;
|
|
10717
10791
|
} | {
|
|
10718
10792
|
addedToolNames?: string[];
|
|
10719
10793
|
arguments: Record<string, any>;
|
|
10720
10794
|
callID: string;
|
|
10721
10795
|
name: string;
|
|
10722
10796
|
namespace?: string;
|
|
10723
|
-
|
|
10724
|
-
content
|
|
10797
|
+
partial?: {
|
|
10798
|
+
content?: ({
|
|
10725
10799
|
type: "text";
|
|
10726
10800
|
text: string;
|
|
10727
10801
|
textSignature?: string;
|
|
@@ -10731,9 +10805,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10731
10805
|
mimeType: string;
|
|
10732
10806
|
})[];
|
|
10733
10807
|
details?: any;
|
|
10734
|
-
isError: false;
|
|
10735
10808
|
};
|
|
10736
|
-
status: "
|
|
10809
|
+
status: "running";
|
|
10737
10810
|
thoughtSignature?: string;
|
|
10738
10811
|
time: {
|
|
10739
10812
|
start: number;
|
|
@@ -10757,9 +10830,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10757
10830
|
mimeType: string;
|
|
10758
10831
|
})[];
|
|
10759
10832
|
details?: any;
|
|
10760
|
-
isError:
|
|
10833
|
+
isError: false;
|
|
10761
10834
|
};
|
|
10762
|
-
status: "
|
|
10835
|
+
status: "completed";
|
|
10763
10836
|
thoughtSignature?: string;
|
|
10764
10837
|
time: {
|
|
10765
10838
|
start: number;
|
|
@@ -10785,7 +10858,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10785
10858
|
details?: any;
|
|
10786
10859
|
isError: true;
|
|
10787
10860
|
};
|
|
10788
|
-
status: "
|
|
10861
|
+
status: "error";
|
|
10789
10862
|
thoughtSignature?: string;
|
|
10790
10863
|
time: {
|
|
10791
10864
|
start: number;
|
|
@@ -10811,26 +10884,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10811
10884
|
details?: any;
|
|
10812
10885
|
isError: true;
|
|
10813
10886
|
};
|
|
10814
|
-
status: "
|
|
10887
|
+
status: "skipped";
|
|
10815
10888
|
thoughtSignature?: string;
|
|
10816
10889
|
time: {
|
|
10817
10890
|
start: number;
|
|
10818
10891
|
end: number;
|
|
10819
10892
|
};
|
|
10820
10893
|
type: "toolCall";
|
|
10821
|
-
} | {
|
|
10822
|
-
type: "thinking";
|
|
10823
|
-
thinking: string;
|
|
10824
|
-
thinkingSignature?: string;
|
|
10825
|
-
redacted?: boolean;
|
|
10826
10894
|
} | {
|
|
10827
10895
|
addedToolNames?: string[];
|
|
10828
10896
|
arguments: Record<string, any>;
|
|
10829
10897
|
callID: string;
|
|
10830
10898
|
name: string;
|
|
10831
10899
|
namespace?: string;
|
|
10832
|
-
|
|
10833
|
-
content
|
|
10900
|
+
result: {
|
|
10901
|
+
content: ({
|
|
10834
10902
|
type: "text";
|
|
10835
10903
|
text: string;
|
|
10836
10904
|
textSignature?: string;
|
|
@@ -10840,8 +10908,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
10840
10908
|
mimeType: string;
|
|
10841
10909
|
})[];
|
|
10842
10910
|
details?: any;
|
|
10911
|
+
isError: true;
|
|
10843
10912
|
};
|
|
10844
|
-
status: "
|
|
10913
|
+
status: "aborted";
|
|
10845
10914
|
thoughtSignature?: string;
|
|
10846
10915
|
time: {
|
|
10847
10916
|
start: number;
|
|
@@ -11034,14 +11103,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11034
11103
|
type: "image";
|
|
11035
11104
|
data: string;
|
|
11036
11105
|
mimeType: string;
|
|
11106
|
+
} | {
|
|
11107
|
+
type: "thinking";
|
|
11108
|
+
thinking: string;
|
|
11109
|
+
thinkingSignature?: string;
|
|
11110
|
+
redacted?: boolean;
|
|
11037
11111
|
} | {
|
|
11038
11112
|
addedToolNames?: string[];
|
|
11039
11113
|
arguments: Record<string, any>;
|
|
11040
11114
|
callID: string;
|
|
11041
11115
|
name: string;
|
|
11042
11116
|
namespace?: string;
|
|
11043
|
-
|
|
11044
|
-
content
|
|
11117
|
+
partial?: {
|
|
11118
|
+
content?: ({
|
|
11045
11119
|
type: "text";
|
|
11046
11120
|
text: string;
|
|
11047
11121
|
textSignature?: string;
|
|
@@ -11051,9 +11125,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11051
11125
|
mimeType: string;
|
|
11052
11126
|
})[];
|
|
11053
11127
|
details?: any;
|
|
11054
|
-
isError: false;
|
|
11055
11128
|
};
|
|
11056
|
-
status: "
|
|
11129
|
+
status: "running";
|
|
11057
11130
|
thoughtSignature?: string;
|
|
11058
11131
|
time: {
|
|
11059
11132
|
start: number;
|
|
@@ -11077,9 +11150,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11077
11150
|
mimeType: string;
|
|
11078
11151
|
})[];
|
|
11079
11152
|
details?: any;
|
|
11080
|
-
isError:
|
|
11153
|
+
isError: false;
|
|
11081
11154
|
};
|
|
11082
|
-
status: "
|
|
11155
|
+
status: "completed";
|
|
11083
11156
|
thoughtSignature?: string;
|
|
11084
11157
|
time: {
|
|
11085
11158
|
start: number;
|
|
@@ -11105,7 +11178,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11105
11178
|
details?: any;
|
|
11106
11179
|
isError: true;
|
|
11107
11180
|
};
|
|
11108
|
-
status: "
|
|
11181
|
+
status: "error";
|
|
11109
11182
|
thoughtSignature?: string;
|
|
11110
11183
|
time: {
|
|
11111
11184
|
start: number;
|
|
@@ -11131,26 +11204,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11131
11204
|
details?: any;
|
|
11132
11205
|
isError: true;
|
|
11133
11206
|
};
|
|
11134
|
-
status: "
|
|
11207
|
+
status: "skipped";
|
|
11135
11208
|
thoughtSignature?: string;
|
|
11136
11209
|
time: {
|
|
11137
11210
|
start: number;
|
|
11138
11211
|
end: number;
|
|
11139
11212
|
};
|
|
11140
11213
|
type: "toolCall";
|
|
11141
|
-
} | {
|
|
11142
|
-
type: "thinking";
|
|
11143
|
-
thinking: string;
|
|
11144
|
-
thinkingSignature?: string;
|
|
11145
|
-
redacted?: boolean;
|
|
11146
11214
|
} | {
|
|
11147
11215
|
addedToolNames?: string[];
|
|
11148
11216
|
arguments: Record<string, any>;
|
|
11149
11217
|
callID: string;
|
|
11150
11218
|
name: string;
|
|
11151
11219
|
namespace?: string;
|
|
11152
|
-
|
|
11153
|
-
content
|
|
11220
|
+
result: {
|
|
11221
|
+
content: ({
|
|
11154
11222
|
type: "text";
|
|
11155
11223
|
text: string;
|
|
11156
11224
|
textSignature?: string;
|
|
@@ -11160,8 +11228,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11160
11228
|
mimeType: string;
|
|
11161
11229
|
})[];
|
|
11162
11230
|
details?: any;
|
|
11231
|
+
isError: true;
|
|
11163
11232
|
};
|
|
11164
|
-
status: "
|
|
11233
|
+
status: "aborted";
|
|
11165
11234
|
thoughtSignature?: string;
|
|
11166
11235
|
time: {
|
|
11167
11236
|
start: number;
|
|
@@ -11336,14 +11405,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11336
11405
|
type: "image";
|
|
11337
11406
|
data: string;
|
|
11338
11407
|
mimeType: string;
|
|
11408
|
+
} | {
|
|
11409
|
+
type: "thinking";
|
|
11410
|
+
thinking: string;
|
|
11411
|
+
thinkingSignature?: string;
|
|
11412
|
+
redacted?: boolean;
|
|
11339
11413
|
} | {
|
|
11340
11414
|
addedToolNames?: string[];
|
|
11341
11415
|
arguments: Record<string, any>;
|
|
11342
11416
|
callID: string;
|
|
11343
11417
|
name: string;
|
|
11344
11418
|
namespace?: string;
|
|
11345
|
-
|
|
11346
|
-
content
|
|
11419
|
+
partial?: {
|
|
11420
|
+
content?: ({
|
|
11347
11421
|
type: "text";
|
|
11348
11422
|
text: string;
|
|
11349
11423
|
textSignature?: string;
|
|
@@ -11353,9 +11427,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11353
11427
|
mimeType: string;
|
|
11354
11428
|
})[];
|
|
11355
11429
|
details?: any;
|
|
11356
|
-
isError: false;
|
|
11357
11430
|
};
|
|
11358
|
-
status: "
|
|
11431
|
+
status: "running";
|
|
11359
11432
|
thoughtSignature?: string;
|
|
11360
11433
|
time: {
|
|
11361
11434
|
start: number;
|
|
@@ -11379,9 +11452,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11379
11452
|
mimeType: string;
|
|
11380
11453
|
})[];
|
|
11381
11454
|
details?: any;
|
|
11382
|
-
isError:
|
|
11455
|
+
isError: false;
|
|
11383
11456
|
};
|
|
11384
|
-
status: "
|
|
11457
|
+
status: "completed";
|
|
11385
11458
|
thoughtSignature?: string;
|
|
11386
11459
|
time: {
|
|
11387
11460
|
start: number;
|
|
@@ -11407,7 +11480,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11407
11480
|
details?: any;
|
|
11408
11481
|
isError: true;
|
|
11409
11482
|
};
|
|
11410
|
-
status: "
|
|
11483
|
+
status: "error";
|
|
11411
11484
|
thoughtSignature?: string;
|
|
11412
11485
|
time: {
|
|
11413
11486
|
start: number;
|
|
@@ -11433,26 +11506,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11433
11506
|
details?: any;
|
|
11434
11507
|
isError: true;
|
|
11435
11508
|
};
|
|
11436
|
-
status: "
|
|
11509
|
+
status: "skipped";
|
|
11437
11510
|
thoughtSignature?: string;
|
|
11438
11511
|
time: {
|
|
11439
11512
|
start: number;
|
|
11440
11513
|
end: number;
|
|
11441
11514
|
};
|
|
11442
11515
|
type: "toolCall";
|
|
11443
|
-
} | {
|
|
11444
|
-
type: "thinking";
|
|
11445
|
-
thinking: string;
|
|
11446
|
-
thinkingSignature?: string;
|
|
11447
|
-
redacted?: boolean;
|
|
11448
11516
|
} | {
|
|
11449
11517
|
addedToolNames?: string[];
|
|
11450
11518
|
arguments: Record<string, any>;
|
|
11451
11519
|
callID: string;
|
|
11452
11520
|
name: string;
|
|
11453
11521
|
namespace?: string;
|
|
11454
|
-
|
|
11455
|
-
content
|
|
11522
|
+
result: {
|
|
11523
|
+
content: ({
|
|
11456
11524
|
type: "text";
|
|
11457
11525
|
text: string;
|
|
11458
11526
|
textSignature?: string;
|
|
@@ -11462,8 +11530,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11462
11530
|
mimeType: string;
|
|
11463
11531
|
})[];
|
|
11464
11532
|
details?: any;
|
|
11533
|
+
isError: true;
|
|
11465
11534
|
};
|
|
11466
|
-
status: "
|
|
11535
|
+
status: "aborted";
|
|
11467
11536
|
thoughtSignature?: string;
|
|
11468
11537
|
time: {
|
|
11469
11538
|
start: number;
|
|
@@ -11944,14 +12013,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11944
12013
|
type: "image";
|
|
11945
12014
|
data: string;
|
|
11946
12015
|
mimeType: string;
|
|
12016
|
+
} | {
|
|
12017
|
+
type: "thinking";
|
|
12018
|
+
thinking: string;
|
|
12019
|
+
thinkingSignature?: string;
|
|
12020
|
+
redacted?: boolean;
|
|
11947
12021
|
} | {
|
|
11948
12022
|
addedToolNames?: string[];
|
|
11949
12023
|
arguments: Record<string, any>;
|
|
11950
12024
|
callID: string;
|
|
11951
12025
|
name: string;
|
|
11952
12026
|
namespace?: string;
|
|
11953
|
-
|
|
11954
|
-
content
|
|
12027
|
+
partial?: {
|
|
12028
|
+
content?: ({
|
|
11955
12029
|
type: "text";
|
|
11956
12030
|
text: string;
|
|
11957
12031
|
textSignature?: string;
|
|
@@ -11961,9 +12035,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11961
12035
|
mimeType: string;
|
|
11962
12036
|
})[];
|
|
11963
12037
|
details?: any;
|
|
11964
|
-
isError: false;
|
|
11965
12038
|
};
|
|
11966
|
-
status: "
|
|
12039
|
+
status: "running";
|
|
11967
12040
|
thoughtSignature?: string;
|
|
11968
12041
|
time: {
|
|
11969
12042
|
start: number;
|
|
@@ -11987,9 +12060,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
11987
12060
|
mimeType: string;
|
|
11988
12061
|
})[];
|
|
11989
12062
|
details?: any;
|
|
11990
|
-
isError:
|
|
12063
|
+
isError: false;
|
|
11991
12064
|
};
|
|
11992
|
-
status: "
|
|
12065
|
+
status: "completed";
|
|
11993
12066
|
thoughtSignature?: string;
|
|
11994
12067
|
time: {
|
|
11995
12068
|
start: number;
|
|
@@ -12015,7 +12088,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12015
12088
|
details?: any;
|
|
12016
12089
|
isError: true;
|
|
12017
12090
|
};
|
|
12018
|
-
status: "
|
|
12091
|
+
status: "error";
|
|
12019
12092
|
thoughtSignature?: string;
|
|
12020
12093
|
time: {
|
|
12021
12094
|
start: number;
|
|
@@ -12041,26 +12114,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12041
12114
|
details?: any;
|
|
12042
12115
|
isError: true;
|
|
12043
12116
|
};
|
|
12044
|
-
status: "
|
|
12117
|
+
status: "skipped";
|
|
12045
12118
|
thoughtSignature?: string;
|
|
12046
12119
|
time: {
|
|
12047
12120
|
start: number;
|
|
12048
12121
|
end: number;
|
|
12049
12122
|
};
|
|
12050
12123
|
type: "toolCall";
|
|
12051
|
-
} | {
|
|
12052
|
-
type: "thinking";
|
|
12053
|
-
thinking: string;
|
|
12054
|
-
thinkingSignature?: string;
|
|
12055
|
-
redacted?: boolean;
|
|
12056
12124
|
} | {
|
|
12057
12125
|
addedToolNames?: string[];
|
|
12058
12126
|
arguments: Record<string, any>;
|
|
12059
12127
|
callID: string;
|
|
12060
12128
|
name: string;
|
|
12061
12129
|
namespace?: string;
|
|
12062
|
-
|
|
12063
|
-
content
|
|
12130
|
+
result: {
|
|
12131
|
+
content: ({
|
|
12064
12132
|
type: "text";
|
|
12065
12133
|
text: string;
|
|
12066
12134
|
textSignature?: string;
|
|
@@ -12070,8 +12138,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12070
12138
|
mimeType: string;
|
|
12071
12139
|
})[];
|
|
12072
12140
|
details?: any;
|
|
12141
|
+
isError: true;
|
|
12073
12142
|
};
|
|
12074
|
-
status: "
|
|
12143
|
+
status: "aborted";
|
|
12075
12144
|
thoughtSignature?: string;
|
|
12076
12145
|
time: {
|
|
12077
12146
|
start: number;
|
|
@@ -12246,14 +12315,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12246
12315
|
type: "image";
|
|
12247
12316
|
data: string;
|
|
12248
12317
|
mimeType: string;
|
|
12318
|
+
} | {
|
|
12319
|
+
type: "thinking";
|
|
12320
|
+
thinking: string;
|
|
12321
|
+
thinkingSignature?: string;
|
|
12322
|
+
redacted?: boolean;
|
|
12249
12323
|
} | {
|
|
12250
12324
|
addedToolNames?: string[];
|
|
12251
12325
|
arguments: Record<string, any>;
|
|
12252
12326
|
callID: string;
|
|
12253
12327
|
name: string;
|
|
12254
12328
|
namespace?: string;
|
|
12255
|
-
|
|
12256
|
-
content
|
|
12329
|
+
partial?: {
|
|
12330
|
+
content?: ({
|
|
12257
12331
|
type: "text";
|
|
12258
12332
|
text: string;
|
|
12259
12333
|
textSignature?: string;
|
|
@@ -12263,9 +12337,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12263
12337
|
mimeType: string;
|
|
12264
12338
|
})[];
|
|
12265
12339
|
details?: any;
|
|
12266
|
-
isError: false;
|
|
12267
12340
|
};
|
|
12268
|
-
status: "
|
|
12341
|
+
status: "running";
|
|
12269
12342
|
thoughtSignature?: string;
|
|
12270
12343
|
time: {
|
|
12271
12344
|
start: number;
|
|
@@ -12289,9 +12362,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12289
12362
|
mimeType: string;
|
|
12290
12363
|
})[];
|
|
12291
12364
|
details?: any;
|
|
12292
|
-
isError:
|
|
12365
|
+
isError: false;
|
|
12293
12366
|
};
|
|
12294
|
-
status: "
|
|
12367
|
+
status: "completed";
|
|
12295
12368
|
thoughtSignature?: string;
|
|
12296
12369
|
time: {
|
|
12297
12370
|
start: number;
|
|
@@ -12317,7 +12390,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12317
12390
|
details?: any;
|
|
12318
12391
|
isError: true;
|
|
12319
12392
|
};
|
|
12320
|
-
status: "
|
|
12393
|
+
status: "error";
|
|
12321
12394
|
thoughtSignature?: string;
|
|
12322
12395
|
time: {
|
|
12323
12396
|
start: number;
|
|
@@ -12343,26 +12416,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12343
12416
|
details?: any;
|
|
12344
12417
|
isError: true;
|
|
12345
12418
|
};
|
|
12346
|
-
status: "
|
|
12419
|
+
status: "skipped";
|
|
12347
12420
|
thoughtSignature?: string;
|
|
12348
12421
|
time: {
|
|
12349
12422
|
start: number;
|
|
12350
12423
|
end: number;
|
|
12351
12424
|
};
|
|
12352
12425
|
type: "toolCall";
|
|
12353
|
-
} | {
|
|
12354
|
-
type: "thinking";
|
|
12355
|
-
thinking: string;
|
|
12356
|
-
thinkingSignature?: string;
|
|
12357
|
-
redacted?: boolean;
|
|
12358
12426
|
} | {
|
|
12359
12427
|
addedToolNames?: string[];
|
|
12360
12428
|
arguments: Record<string, any>;
|
|
12361
12429
|
callID: string;
|
|
12362
12430
|
name: string;
|
|
12363
12431
|
namespace?: string;
|
|
12364
|
-
|
|
12365
|
-
content
|
|
12432
|
+
result: {
|
|
12433
|
+
content: ({
|
|
12366
12434
|
type: "text";
|
|
12367
12435
|
text: string;
|
|
12368
12436
|
textSignature?: string;
|
|
@@ -12372,8 +12440,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12372
12440
|
mimeType: string;
|
|
12373
12441
|
})[];
|
|
12374
12442
|
details?: any;
|
|
12443
|
+
isError: true;
|
|
12375
12444
|
};
|
|
12376
|
-
status: "
|
|
12445
|
+
status: "aborted";
|
|
12377
12446
|
thoughtSignature?: string;
|
|
12378
12447
|
time: {
|
|
12379
12448
|
start: number;
|
|
@@ -12567,14 +12636,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12567
12636
|
type: "image";
|
|
12568
12637
|
data: string;
|
|
12569
12638
|
mimeType: string;
|
|
12639
|
+
} | {
|
|
12640
|
+
type: "thinking";
|
|
12641
|
+
thinking: string;
|
|
12642
|
+
thinkingSignature?: string;
|
|
12643
|
+
redacted?: boolean;
|
|
12570
12644
|
} | {
|
|
12571
12645
|
addedToolNames?: string[];
|
|
12572
12646
|
arguments: Record<string, any>;
|
|
12573
12647
|
callID: string;
|
|
12574
12648
|
name: string;
|
|
12575
12649
|
namespace?: string;
|
|
12576
|
-
|
|
12577
|
-
content
|
|
12650
|
+
partial?: {
|
|
12651
|
+
content?: ({
|
|
12578
12652
|
type: "text";
|
|
12579
12653
|
text: string;
|
|
12580
12654
|
textSignature?: string;
|
|
@@ -12584,9 +12658,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12584
12658
|
mimeType: string;
|
|
12585
12659
|
})[];
|
|
12586
12660
|
details?: any;
|
|
12587
|
-
isError: false;
|
|
12588
12661
|
};
|
|
12589
|
-
status: "
|
|
12662
|
+
status: "running";
|
|
12590
12663
|
thoughtSignature?: string;
|
|
12591
12664
|
time: {
|
|
12592
12665
|
start: number;
|
|
@@ -12610,9 +12683,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12610
12683
|
mimeType: string;
|
|
12611
12684
|
})[];
|
|
12612
12685
|
details?: any;
|
|
12613
|
-
isError:
|
|
12686
|
+
isError: false;
|
|
12614
12687
|
};
|
|
12615
|
-
status: "
|
|
12688
|
+
status: "completed";
|
|
12616
12689
|
thoughtSignature?: string;
|
|
12617
12690
|
time: {
|
|
12618
12691
|
start: number;
|
|
@@ -12638,7 +12711,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12638
12711
|
details?: any;
|
|
12639
12712
|
isError: true;
|
|
12640
12713
|
};
|
|
12641
|
-
status: "
|
|
12714
|
+
status: "error";
|
|
12642
12715
|
thoughtSignature?: string;
|
|
12643
12716
|
time: {
|
|
12644
12717
|
start: number;
|
|
@@ -12664,26 +12737,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12664
12737
|
details?: any;
|
|
12665
12738
|
isError: true;
|
|
12666
12739
|
};
|
|
12667
|
-
status: "
|
|
12740
|
+
status: "skipped";
|
|
12668
12741
|
thoughtSignature?: string;
|
|
12669
12742
|
time: {
|
|
12670
12743
|
start: number;
|
|
12671
12744
|
end: number;
|
|
12672
12745
|
};
|
|
12673
12746
|
type: "toolCall";
|
|
12674
|
-
} | {
|
|
12675
|
-
type: "thinking";
|
|
12676
|
-
thinking: string;
|
|
12677
|
-
thinkingSignature?: string;
|
|
12678
|
-
redacted?: boolean;
|
|
12679
12747
|
} | {
|
|
12680
12748
|
addedToolNames?: string[];
|
|
12681
12749
|
arguments: Record<string, any>;
|
|
12682
12750
|
callID: string;
|
|
12683
12751
|
name: string;
|
|
12684
12752
|
namespace?: string;
|
|
12685
|
-
|
|
12686
|
-
content
|
|
12753
|
+
result: {
|
|
12754
|
+
content: ({
|
|
12687
12755
|
type: "text";
|
|
12688
12756
|
text: string;
|
|
12689
12757
|
textSignature?: string;
|
|
@@ -12693,8 +12761,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12693
12761
|
mimeType: string;
|
|
12694
12762
|
})[];
|
|
12695
12763
|
details?: any;
|
|
12764
|
+
isError: true;
|
|
12696
12765
|
};
|
|
12697
|
-
status: "
|
|
12766
|
+
status: "aborted";
|
|
12698
12767
|
thoughtSignature?: string;
|
|
12699
12768
|
time: {
|
|
12700
12769
|
start: number;
|
|
@@ -12869,14 +12938,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12869
12938
|
type: "image";
|
|
12870
12939
|
data: string;
|
|
12871
12940
|
mimeType: string;
|
|
12941
|
+
} | {
|
|
12942
|
+
type: "thinking";
|
|
12943
|
+
thinking: string;
|
|
12944
|
+
thinkingSignature?: string;
|
|
12945
|
+
redacted?: boolean;
|
|
12872
12946
|
} | {
|
|
12873
12947
|
addedToolNames?: string[];
|
|
12874
12948
|
arguments: Record<string, any>;
|
|
12875
12949
|
callID: string;
|
|
12876
12950
|
name: string;
|
|
12877
12951
|
namespace?: string;
|
|
12878
|
-
|
|
12879
|
-
content
|
|
12952
|
+
partial?: {
|
|
12953
|
+
content?: ({
|
|
12880
12954
|
type: "text";
|
|
12881
12955
|
text: string;
|
|
12882
12956
|
textSignature?: string;
|
|
@@ -12886,9 +12960,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12886
12960
|
mimeType: string;
|
|
12887
12961
|
})[];
|
|
12888
12962
|
details?: any;
|
|
12889
|
-
isError: false;
|
|
12890
12963
|
};
|
|
12891
|
-
status: "
|
|
12964
|
+
status: "running";
|
|
12892
12965
|
thoughtSignature?: string;
|
|
12893
12966
|
time: {
|
|
12894
12967
|
start: number;
|
|
@@ -12912,9 +12985,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12912
12985
|
mimeType: string;
|
|
12913
12986
|
})[];
|
|
12914
12987
|
details?: any;
|
|
12915
|
-
isError:
|
|
12988
|
+
isError: false;
|
|
12916
12989
|
};
|
|
12917
|
-
status: "
|
|
12990
|
+
status: "completed";
|
|
12918
12991
|
thoughtSignature?: string;
|
|
12919
12992
|
time: {
|
|
12920
12993
|
start: number;
|
|
@@ -12940,7 +13013,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12940
13013
|
details?: any;
|
|
12941
13014
|
isError: true;
|
|
12942
13015
|
};
|
|
12943
|
-
status: "
|
|
13016
|
+
status: "error";
|
|
12944
13017
|
thoughtSignature?: string;
|
|
12945
13018
|
time: {
|
|
12946
13019
|
start: number;
|
|
@@ -12966,26 +13039,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12966
13039
|
details?: any;
|
|
12967
13040
|
isError: true;
|
|
12968
13041
|
};
|
|
12969
|
-
status: "
|
|
13042
|
+
status: "skipped";
|
|
12970
13043
|
thoughtSignature?: string;
|
|
12971
13044
|
time: {
|
|
12972
13045
|
start: number;
|
|
12973
13046
|
end: number;
|
|
12974
13047
|
};
|
|
12975
13048
|
type: "toolCall";
|
|
12976
|
-
} | {
|
|
12977
|
-
type: "thinking";
|
|
12978
|
-
thinking: string;
|
|
12979
|
-
thinkingSignature?: string;
|
|
12980
|
-
redacted?: boolean;
|
|
12981
13049
|
} | {
|
|
12982
13050
|
addedToolNames?: string[];
|
|
12983
13051
|
arguments: Record<string, any>;
|
|
12984
13052
|
callID: string;
|
|
12985
13053
|
name: string;
|
|
12986
13054
|
namespace?: string;
|
|
12987
|
-
|
|
12988
|
-
content
|
|
13055
|
+
result: {
|
|
13056
|
+
content: ({
|
|
12989
13057
|
type: "text";
|
|
12990
13058
|
text: string;
|
|
12991
13059
|
textSignature?: string;
|
|
@@ -12995,8 +13063,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
12995
13063
|
mimeType: string;
|
|
12996
13064
|
})[];
|
|
12997
13065
|
details?: any;
|
|
13066
|
+
isError: true;
|
|
12998
13067
|
};
|
|
12999
|
-
status: "
|
|
13068
|
+
status: "aborted";
|
|
13000
13069
|
thoughtSignature?: string;
|
|
13001
13070
|
time: {
|
|
13002
13071
|
start: number;
|
|
@@ -13199,14 +13268,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13199
13268
|
type: "image";
|
|
13200
13269
|
data: string;
|
|
13201
13270
|
mimeType: string;
|
|
13271
|
+
} | {
|
|
13272
|
+
type: "thinking";
|
|
13273
|
+
thinking: string;
|
|
13274
|
+
thinkingSignature?: string;
|
|
13275
|
+
redacted?: boolean;
|
|
13202
13276
|
} | {
|
|
13203
13277
|
addedToolNames?: string[];
|
|
13204
13278
|
arguments: Record<string, any>;
|
|
13205
13279
|
callID: string;
|
|
13206
13280
|
name: string;
|
|
13207
13281
|
namespace?: string;
|
|
13208
|
-
|
|
13209
|
-
content
|
|
13282
|
+
partial?: {
|
|
13283
|
+
content?: ({
|
|
13210
13284
|
type: "text";
|
|
13211
13285
|
text: string;
|
|
13212
13286
|
textSignature?: string;
|
|
@@ -13216,9 +13290,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13216
13290
|
mimeType: string;
|
|
13217
13291
|
})[];
|
|
13218
13292
|
details?: any;
|
|
13219
|
-
isError: false;
|
|
13220
13293
|
};
|
|
13221
|
-
status: "
|
|
13294
|
+
status: "running";
|
|
13222
13295
|
thoughtSignature?: string;
|
|
13223
13296
|
time: {
|
|
13224
13297
|
start: number;
|
|
@@ -13242,9 +13315,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13242
13315
|
mimeType: string;
|
|
13243
13316
|
})[];
|
|
13244
13317
|
details?: any;
|
|
13245
|
-
isError:
|
|
13318
|
+
isError: false;
|
|
13246
13319
|
};
|
|
13247
|
-
status: "
|
|
13320
|
+
status: "completed";
|
|
13248
13321
|
thoughtSignature?: string;
|
|
13249
13322
|
time: {
|
|
13250
13323
|
start: number;
|
|
@@ -13270,7 +13343,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13270
13343
|
details?: any;
|
|
13271
13344
|
isError: true;
|
|
13272
13345
|
};
|
|
13273
|
-
status: "
|
|
13346
|
+
status: "error";
|
|
13274
13347
|
thoughtSignature?: string;
|
|
13275
13348
|
time: {
|
|
13276
13349
|
start: number;
|
|
@@ -13296,26 +13369,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13296
13369
|
details?: any;
|
|
13297
13370
|
isError: true;
|
|
13298
13371
|
};
|
|
13299
|
-
status: "
|
|
13372
|
+
status: "skipped";
|
|
13300
13373
|
thoughtSignature?: string;
|
|
13301
13374
|
time: {
|
|
13302
13375
|
start: number;
|
|
13303
13376
|
end: number;
|
|
13304
13377
|
};
|
|
13305
13378
|
type: "toolCall";
|
|
13306
|
-
} | {
|
|
13307
|
-
type: "thinking";
|
|
13308
|
-
thinking: string;
|
|
13309
|
-
thinkingSignature?: string;
|
|
13310
|
-
redacted?: boolean;
|
|
13311
13379
|
} | {
|
|
13312
13380
|
addedToolNames?: string[];
|
|
13313
13381
|
arguments: Record<string, any>;
|
|
13314
13382
|
callID: string;
|
|
13315
13383
|
name: string;
|
|
13316
13384
|
namespace?: string;
|
|
13317
|
-
|
|
13318
|
-
content
|
|
13385
|
+
result: {
|
|
13386
|
+
content: ({
|
|
13319
13387
|
type: "text";
|
|
13320
13388
|
text: string;
|
|
13321
13389
|
textSignature?: string;
|
|
@@ -13325,8 +13393,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13325
13393
|
mimeType: string;
|
|
13326
13394
|
})[];
|
|
13327
13395
|
details?: any;
|
|
13396
|
+
isError: true;
|
|
13328
13397
|
};
|
|
13329
|
-
status: "
|
|
13398
|
+
status: "aborted";
|
|
13330
13399
|
thoughtSignature?: string;
|
|
13331
13400
|
time: {
|
|
13332
13401
|
start: number;
|
|
@@ -13501,14 +13570,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13501
13570
|
type: "image";
|
|
13502
13571
|
data: string;
|
|
13503
13572
|
mimeType: string;
|
|
13573
|
+
} | {
|
|
13574
|
+
type: "thinking";
|
|
13575
|
+
thinking: string;
|
|
13576
|
+
thinkingSignature?: string;
|
|
13577
|
+
redacted?: boolean;
|
|
13504
13578
|
} | {
|
|
13505
13579
|
addedToolNames?: string[];
|
|
13506
13580
|
arguments: Record<string, any>;
|
|
13507
13581
|
callID: string;
|
|
13508
13582
|
name: string;
|
|
13509
13583
|
namespace?: string;
|
|
13510
|
-
|
|
13511
|
-
content
|
|
13584
|
+
partial?: {
|
|
13585
|
+
content?: ({
|
|
13512
13586
|
type: "text";
|
|
13513
13587
|
text: string;
|
|
13514
13588
|
textSignature?: string;
|
|
@@ -13518,9 +13592,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13518
13592
|
mimeType: string;
|
|
13519
13593
|
})[];
|
|
13520
13594
|
details?: any;
|
|
13521
|
-
isError: false;
|
|
13522
13595
|
};
|
|
13523
|
-
status: "
|
|
13596
|
+
status: "running";
|
|
13524
13597
|
thoughtSignature?: string;
|
|
13525
13598
|
time: {
|
|
13526
13599
|
start: number;
|
|
@@ -13544,9 +13617,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13544
13617
|
mimeType: string;
|
|
13545
13618
|
})[];
|
|
13546
13619
|
details?: any;
|
|
13547
|
-
isError:
|
|
13620
|
+
isError: false;
|
|
13548
13621
|
};
|
|
13549
|
-
status: "
|
|
13622
|
+
status: "completed";
|
|
13550
13623
|
thoughtSignature?: string;
|
|
13551
13624
|
time: {
|
|
13552
13625
|
start: number;
|
|
@@ -13572,7 +13645,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13572
13645
|
details?: any;
|
|
13573
13646
|
isError: true;
|
|
13574
13647
|
};
|
|
13575
|
-
status: "
|
|
13648
|
+
status: "error";
|
|
13576
13649
|
thoughtSignature?: string;
|
|
13577
13650
|
time: {
|
|
13578
13651
|
start: number;
|
|
@@ -13598,26 +13671,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13598
13671
|
details?: any;
|
|
13599
13672
|
isError: true;
|
|
13600
13673
|
};
|
|
13601
|
-
status: "
|
|
13674
|
+
status: "skipped";
|
|
13602
13675
|
thoughtSignature?: string;
|
|
13603
13676
|
time: {
|
|
13604
13677
|
start: number;
|
|
13605
13678
|
end: number;
|
|
13606
13679
|
};
|
|
13607
13680
|
type: "toolCall";
|
|
13608
|
-
} | {
|
|
13609
|
-
type: "thinking";
|
|
13610
|
-
thinking: string;
|
|
13611
|
-
thinkingSignature?: string;
|
|
13612
|
-
redacted?: boolean;
|
|
13613
13681
|
} | {
|
|
13614
13682
|
addedToolNames?: string[];
|
|
13615
13683
|
arguments: Record<string, any>;
|
|
13616
13684
|
callID: string;
|
|
13617
13685
|
name: string;
|
|
13618
13686
|
namespace?: string;
|
|
13619
|
-
|
|
13620
|
-
content
|
|
13687
|
+
result: {
|
|
13688
|
+
content: ({
|
|
13621
13689
|
type: "text";
|
|
13622
13690
|
text: string;
|
|
13623
13691
|
textSignature?: string;
|
|
@@ -13627,8 +13695,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13627
13695
|
mimeType: string;
|
|
13628
13696
|
})[];
|
|
13629
13697
|
details?: any;
|
|
13698
|
+
isError: true;
|
|
13630
13699
|
};
|
|
13631
|
-
status: "
|
|
13700
|
+
status: "aborted";
|
|
13632
13701
|
thoughtSignature?: string;
|
|
13633
13702
|
time: {
|
|
13634
13703
|
start: number;
|
|
@@ -13822,14 +13891,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13822
13891
|
type: "image";
|
|
13823
13892
|
data: string;
|
|
13824
13893
|
mimeType: string;
|
|
13894
|
+
} | {
|
|
13895
|
+
type: "thinking";
|
|
13896
|
+
thinking: string;
|
|
13897
|
+
thinkingSignature?: string;
|
|
13898
|
+
redacted?: boolean;
|
|
13825
13899
|
} | {
|
|
13826
13900
|
addedToolNames?: string[];
|
|
13827
13901
|
arguments: Record<string, any>;
|
|
13828
13902
|
callID: string;
|
|
13829
13903
|
name: string;
|
|
13830
13904
|
namespace?: string;
|
|
13831
|
-
|
|
13832
|
-
content
|
|
13905
|
+
partial?: {
|
|
13906
|
+
content?: ({
|
|
13833
13907
|
type: "text";
|
|
13834
13908
|
text: string;
|
|
13835
13909
|
textSignature?: string;
|
|
@@ -13839,9 +13913,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13839
13913
|
mimeType: string;
|
|
13840
13914
|
})[];
|
|
13841
13915
|
details?: any;
|
|
13842
|
-
isError: false;
|
|
13843
13916
|
};
|
|
13844
|
-
status: "
|
|
13917
|
+
status: "running";
|
|
13845
13918
|
thoughtSignature?: string;
|
|
13846
13919
|
time: {
|
|
13847
13920
|
start: number;
|
|
@@ -13865,9 +13938,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13865
13938
|
mimeType: string;
|
|
13866
13939
|
})[];
|
|
13867
13940
|
details?: any;
|
|
13868
|
-
isError:
|
|
13941
|
+
isError: false;
|
|
13869
13942
|
};
|
|
13870
|
-
status: "
|
|
13943
|
+
status: "completed";
|
|
13871
13944
|
thoughtSignature?: string;
|
|
13872
13945
|
time: {
|
|
13873
13946
|
start: number;
|
|
@@ -13893,7 +13966,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13893
13966
|
details?: any;
|
|
13894
13967
|
isError: true;
|
|
13895
13968
|
};
|
|
13896
|
-
status: "
|
|
13969
|
+
status: "error";
|
|
13897
13970
|
thoughtSignature?: string;
|
|
13898
13971
|
time: {
|
|
13899
13972
|
start: number;
|
|
@@ -13919,26 +13992,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13919
13992
|
details?: any;
|
|
13920
13993
|
isError: true;
|
|
13921
13994
|
};
|
|
13922
|
-
status: "
|
|
13995
|
+
status: "skipped";
|
|
13923
13996
|
thoughtSignature?: string;
|
|
13924
13997
|
time: {
|
|
13925
13998
|
start: number;
|
|
13926
13999
|
end: number;
|
|
13927
14000
|
};
|
|
13928
14001
|
type: "toolCall";
|
|
13929
|
-
} | {
|
|
13930
|
-
type: "thinking";
|
|
13931
|
-
thinking: string;
|
|
13932
|
-
thinkingSignature?: string;
|
|
13933
|
-
redacted?: boolean;
|
|
13934
14002
|
} | {
|
|
13935
14003
|
addedToolNames?: string[];
|
|
13936
14004
|
arguments: Record<string, any>;
|
|
13937
14005
|
callID: string;
|
|
13938
14006
|
name: string;
|
|
13939
14007
|
namespace?: string;
|
|
13940
|
-
|
|
13941
|
-
content
|
|
14008
|
+
result: {
|
|
14009
|
+
content: ({
|
|
13942
14010
|
type: "text";
|
|
13943
14011
|
text: string;
|
|
13944
14012
|
textSignature?: string;
|
|
@@ -13948,8 +14016,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
13948
14016
|
mimeType: string;
|
|
13949
14017
|
})[];
|
|
13950
14018
|
details?: any;
|
|
14019
|
+
isError: true;
|
|
13951
14020
|
};
|
|
13952
|
-
status: "
|
|
14021
|
+
status: "aborted";
|
|
13953
14022
|
thoughtSignature?: string;
|
|
13954
14023
|
time: {
|
|
13955
14024
|
start: number;
|
|
@@ -14124,14 +14193,19 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14124
14193
|
type: "image";
|
|
14125
14194
|
data: string;
|
|
14126
14195
|
mimeType: string;
|
|
14196
|
+
} | {
|
|
14197
|
+
type: "thinking";
|
|
14198
|
+
thinking: string;
|
|
14199
|
+
thinkingSignature?: string;
|
|
14200
|
+
redacted?: boolean;
|
|
14127
14201
|
} | {
|
|
14128
14202
|
addedToolNames?: string[];
|
|
14129
14203
|
arguments: Record<string, any>;
|
|
14130
14204
|
callID: string;
|
|
14131
14205
|
name: string;
|
|
14132
14206
|
namespace?: string;
|
|
14133
|
-
|
|
14134
|
-
content
|
|
14207
|
+
partial?: {
|
|
14208
|
+
content?: ({
|
|
14135
14209
|
type: "text";
|
|
14136
14210
|
text: string;
|
|
14137
14211
|
textSignature?: string;
|
|
@@ -14141,9 +14215,8 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14141
14215
|
mimeType: string;
|
|
14142
14216
|
})[];
|
|
14143
14217
|
details?: any;
|
|
14144
|
-
isError: false;
|
|
14145
14218
|
};
|
|
14146
|
-
status: "
|
|
14219
|
+
status: "running";
|
|
14147
14220
|
thoughtSignature?: string;
|
|
14148
14221
|
time: {
|
|
14149
14222
|
start: number;
|
|
@@ -14167,9 +14240,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14167
14240
|
mimeType: string;
|
|
14168
14241
|
})[];
|
|
14169
14242
|
details?: any;
|
|
14170
|
-
isError:
|
|
14243
|
+
isError: false;
|
|
14171
14244
|
};
|
|
14172
|
-
status: "
|
|
14245
|
+
status: "completed";
|
|
14173
14246
|
thoughtSignature?: string;
|
|
14174
14247
|
time: {
|
|
14175
14248
|
start: number;
|
|
@@ -14195,7 +14268,7 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14195
14268
|
details?: any;
|
|
14196
14269
|
isError: true;
|
|
14197
14270
|
};
|
|
14198
|
-
status: "
|
|
14271
|
+
status: "error";
|
|
14199
14272
|
thoughtSignature?: string;
|
|
14200
14273
|
time: {
|
|
14201
14274
|
start: number;
|
|
@@ -14221,26 +14294,21 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14221
14294
|
details?: any;
|
|
14222
14295
|
isError: true;
|
|
14223
14296
|
};
|
|
14224
|
-
status: "
|
|
14297
|
+
status: "skipped";
|
|
14225
14298
|
thoughtSignature?: string;
|
|
14226
14299
|
time: {
|
|
14227
14300
|
start: number;
|
|
14228
14301
|
end: number;
|
|
14229
14302
|
};
|
|
14230
14303
|
type: "toolCall";
|
|
14231
|
-
} | {
|
|
14232
|
-
type: "thinking";
|
|
14233
|
-
thinking: string;
|
|
14234
|
-
thinkingSignature?: string;
|
|
14235
|
-
redacted?: boolean;
|
|
14236
14304
|
} | {
|
|
14237
14305
|
addedToolNames?: string[];
|
|
14238
14306
|
arguments: Record<string, any>;
|
|
14239
14307
|
callID: string;
|
|
14240
14308
|
name: string;
|
|
14241
14309
|
namespace?: string;
|
|
14242
|
-
|
|
14243
|
-
content
|
|
14310
|
+
result: {
|
|
14311
|
+
content: ({
|
|
14244
14312
|
type: "text";
|
|
14245
14313
|
text: string;
|
|
14246
14314
|
textSignature?: string;
|
|
@@ -14250,8 +14318,9 @@ declare const Definitions: readonly [Schema.Struct<{
|
|
|
14250
14318
|
mimeType: string;
|
|
14251
14319
|
})[];
|
|
14252
14320
|
details?: any;
|
|
14321
|
+
isError: true;
|
|
14253
14322
|
};
|
|
14254
|
-
status: "
|
|
14323
|
+
status: "aborted";
|
|
14255
14324
|
thoughtSignature?: string;
|
|
14256
14325
|
time: {
|
|
14257
14326
|
start: number;
|
|
@@ -15760,14 +15829,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15760
15829
|
type: "image";
|
|
15761
15830
|
data: string;
|
|
15762
15831
|
mimeType: string;
|
|
15832
|
+
} | {
|
|
15833
|
+
type: "thinking";
|
|
15834
|
+
thinking: string;
|
|
15835
|
+
thinkingSignature?: string;
|
|
15836
|
+
redacted?: boolean;
|
|
15763
15837
|
} | {
|
|
15764
15838
|
addedToolNames?: string[];
|
|
15765
15839
|
arguments: Record<string, any>;
|
|
15766
15840
|
callID: string;
|
|
15767
15841
|
name: string;
|
|
15768
15842
|
namespace?: string;
|
|
15769
|
-
|
|
15770
|
-
content
|
|
15843
|
+
partial?: {
|
|
15844
|
+
content?: ({
|
|
15771
15845
|
type: "text";
|
|
15772
15846
|
text: string;
|
|
15773
15847
|
textSignature?: string;
|
|
@@ -15777,9 +15851,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15777
15851
|
mimeType: string;
|
|
15778
15852
|
})[];
|
|
15779
15853
|
details?: any;
|
|
15780
|
-
isError: false;
|
|
15781
15854
|
};
|
|
15782
|
-
status: "
|
|
15855
|
+
status: "running";
|
|
15783
15856
|
thoughtSignature?: string;
|
|
15784
15857
|
time: {
|
|
15785
15858
|
start: number;
|
|
@@ -15803,9 +15876,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15803
15876
|
mimeType: string;
|
|
15804
15877
|
})[];
|
|
15805
15878
|
details?: any;
|
|
15806
|
-
isError:
|
|
15879
|
+
isError: false;
|
|
15807
15880
|
};
|
|
15808
|
-
status: "
|
|
15881
|
+
status: "completed";
|
|
15809
15882
|
thoughtSignature?: string;
|
|
15810
15883
|
time: {
|
|
15811
15884
|
start: number;
|
|
@@ -15831,7 +15904,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15831
15904
|
details?: any;
|
|
15832
15905
|
isError: true;
|
|
15833
15906
|
};
|
|
15834
|
-
status: "
|
|
15907
|
+
status: "error";
|
|
15835
15908
|
thoughtSignature?: string;
|
|
15836
15909
|
time: {
|
|
15837
15910
|
start: number;
|
|
@@ -15857,26 +15930,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15857
15930
|
details?: any;
|
|
15858
15931
|
isError: true;
|
|
15859
15932
|
};
|
|
15860
|
-
status: "
|
|
15933
|
+
status: "skipped";
|
|
15861
15934
|
thoughtSignature?: string;
|
|
15862
15935
|
time: {
|
|
15863
15936
|
start: number;
|
|
15864
15937
|
end: number;
|
|
15865
15938
|
};
|
|
15866
15939
|
type: "toolCall";
|
|
15867
|
-
} | {
|
|
15868
|
-
type: "thinking";
|
|
15869
|
-
thinking: string;
|
|
15870
|
-
thinkingSignature?: string;
|
|
15871
|
-
redacted?: boolean;
|
|
15872
15940
|
} | {
|
|
15873
15941
|
addedToolNames?: string[];
|
|
15874
15942
|
arguments: Record<string, any>;
|
|
15875
15943
|
callID: string;
|
|
15876
15944
|
name: string;
|
|
15877
15945
|
namespace?: string;
|
|
15878
|
-
|
|
15879
|
-
content
|
|
15946
|
+
result: {
|
|
15947
|
+
content: ({
|
|
15880
15948
|
type: "text";
|
|
15881
15949
|
text: string;
|
|
15882
15950
|
textSignature?: string;
|
|
@@ -15886,8 +15954,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
15886
15954
|
mimeType: string;
|
|
15887
15955
|
})[];
|
|
15888
15956
|
details?: any;
|
|
15957
|
+
isError: true;
|
|
15889
15958
|
};
|
|
15890
|
-
status: "
|
|
15959
|
+
status: "aborted";
|
|
15891
15960
|
thoughtSignature?: string;
|
|
15892
15961
|
time: {
|
|
15893
15962
|
start: number;
|
|
@@ -16062,14 +16131,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16062
16131
|
type: "image";
|
|
16063
16132
|
data: string;
|
|
16064
16133
|
mimeType: string;
|
|
16134
|
+
} | {
|
|
16135
|
+
type: "thinking";
|
|
16136
|
+
thinking: string;
|
|
16137
|
+
thinkingSignature?: string;
|
|
16138
|
+
redacted?: boolean;
|
|
16065
16139
|
} | {
|
|
16066
16140
|
addedToolNames?: string[];
|
|
16067
16141
|
arguments: Record<string, any>;
|
|
16068
16142
|
callID: string;
|
|
16069
16143
|
name: string;
|
|
16070
16144
|
namespace?: string;
|
|
16071
|
-
|
|
16072
|
-
content
|
|
16145
|
+
partial?: {
|
|
16146
|
+
content?: ({
|
|
16073
16147
|
type: "text";
|
|
16074
16148
|
text: string;
|
|
16075
16149
|
textSignature?: string;
|
|
@@ -16079,9 +16153,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16079
16153
|
mimeType: string;
|
|
16080
16154
|
})[];
|
|
16081
16155
|
details?: any;
|
|
16082
|
-
isError: false;
|
|
16083
16156
|
};
|
|
16084
|
-
status: "
|
|
16157
|
+
status: "running";
|
|
16085
16158
|
thoughtSignature?: string;
|
|
16086
16159
|
time: {
|
|
16087
16160
|
start: number;
|
|
@@ -16105,9 +16178,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16105
16178
|
mimeType: string;
|
|
16106
16179
|
})[];
|
|
16107
16180
|
details?: any;
|
|
16108
|
-
isError:
|
|
16181
|
+
isError: false;
|
|
16109
16182
|
};
|
|
16110
|
-
status: "
|
|
16183
|
+
status: "completed";
|
|
16111
16184
|
thoughtSignature?: string;
|
|
16112
16185
|
time: {
|
|
16113
16186
|
start: number;
|
|
@@ -16133,7 +16206,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16133
16206
|
details?: any;
|
|
16134
16207
|
isError: true;
|
|
16135
16208
|
};
|
|
16136
|
-
status: "
|
|
16209
|
+
status: "error";
|
|
16137
16210
|
thoughtSignature?: string;
|
|
16138
16211
|
time: {
|
|
16139
16212
|
start: number;
|
|
@@ -16159,26 +16232,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16159
16232
|
details?: any;
|
|
16160
16233
|
isError: true;
|
|
16161
16234
|
};
|
|
16162
|
-
status: "
|
|
16235
|
+
status: "skipped";
|
|
16163
16236
|
thoughtSignature?: string;
|
|
16164
16237
|
time: {
|
|
16165
16238
|
start: number;
|
|
16166
16239
|
end: number;
|
|
16167
16240
|
};
|
|
16168
16241
|
type: "toolCall";
|
|
16169
|
-
} | {
|
|
16170
|
-
type: "thinking";
|
|
16171
|
-
thinking: string;
|
|
16172
|
-
thinkingSignature?: string;
|
|
16173
|
-
redacted?: boolean;
|
|
16174
16242
|
} | {
|
|
16175
16243
|
addedToolNames?: string[];
|
|
16176
16244
|
arguments: Record<string, any>;
|
|
16177
16245
|
callID: string;
|
|
16178
16246
|
name: string;
|
|
16179
16247
|
namespace?: string;
|
|
16180
|
-
|
|
16181
|
-
content
|
|
16248
|
+
result: {
|
|
16249
|
+
content: ({
|
|
16182
16250
|
type: "text";
|
|
16183
16251
|
text: string;
|
|
16184
16252
|
textSignature?: string;
|
|
@@ -16188,8 +16256,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16188
16256
|
mimeType: string;
|
|
16189
16257
|
})[];
|
|
16190
16258
|
details?: any;
|
|
16259
|
+
isError: true;
|
|
16191
16260
|
};
|
|
16192
|
-
status: "
|
|
16261
|
+
status: "aborted";
|
|
16193
16262
|
thoughtSignature?: string;
|
|
16194
16263
|
time: {
|
|
16195
16264
|
start: number;
|
|
@@ -16382,14 +16451,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16382
16451
|
type: "image";
|
|
16383
16452
|
data: string;
|
|
16384
16453
|
mimeType: string;
|
|
16454
|
+
} | {
|
|
16455
|
+
type: "thinking";
|
|
16456
|
+
thinking: string;
|
|
16457
|
+
thinkingSignature?: string;
|
|
16458
|
+
redacted?: boolean;
|
|
16385
16459
|
} | {
|
|
16386
16460
|
addedToolNames?: string[];
|
|
16387
16461
|
arguments: Record<string, any>;
|
|
16388
16462
|
callID: string;
|
|
16389
16463
|
name: string;
|
|
16390
16464
|
namespace?: string;
|
|
16391
|
-
|
|
16392
|
-
content
|
|
16465
|
+
partial?: {
|
|
16466
|
+
content?: ({
|
|
16393
16467
|
type: "text";
|
|
16394
16468
|
text: string;
|
|
16395
16469
|
textSignature?: string;
|
|
@@ -16399,9 +16473,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16399
16473
|
mimeType: string;
|
|
16400
16474
|
})[];
|
|
16401
16475
|
details?: any;
|
|
16402
|
-
isError: false;
|
|
16403
16476
|
};
|
|
16404
|
-
status: "
|
|
16477
|
+
status: "running";
|
|
16405
16478
|
thoughtSignature?: string;
|
|
16406
16479
|
time: {
|
|
16407
16480
|
start: number;
|
|
@@ -16425,9 +16498,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16425
16498
|
mimeType: string;
|
|
16426
16499
|
})[];
|
|
16427
16500
|
details?: any;
|
|
16428
|
-
isError:
|
|
16501
|
+
isError: false;
|
|
16429
16502
|
};
|
|
16430
|
-
status: "
|
|
16503
|
+
status: "completed";
|
|
16431
16504
|
thoughtSignature?: string;
|
|
16432
16505
|
time: {
|
|
16433
16506
|
start: number;
|
|
@@ -16453,7 +16526,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16453
16526
|
details?: any;
|
|
16454
16527
|
isError: true;
|
|
16455
16528
|
};
|
|
16456
|
-
status: "
|
|
16529
|
+
status: "error";
|
|
16457
16530
|
thoughtSignature?: string;
|
|
16458
16531
|
time: {
|
|
16459
16532
|
start: number;
|
|
@@ -16479,26 +16552,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16479
16552
|
details?: any;
|
|
16480
16553
|
isError: true;
|
|
16481
16554
|
};
|
|
16482
|
-
status: "
|
|
16555
|
+
status: "skipped";
|
|
16483
16556
|
thoughtSignature?: string;
|
|
16484
16557
|
time: {
|
|
16485
16558
|
start: number;
|
|
16486
16559
|
end: number;
|
|
16487
16560
|
};
|
|
16488
16561
|
type: "toolCall";
|
|
16489
|
-
} | {
|
|
16490
|
-
type: "thinking";
|
|
16491
|
-
thinking: string;
|
|
16492
|
-
thinkingSignature?: string;
|
|
16493
|
-
redacted?: boolean;
|
|
16494
16562
|
} | {
|
|
16495
16563
|
addedToolNames?: string[];
|
|
16496
16564
|
arguments: Record<string, any>;
|
|
16497
16565
|
callID: string;
|
|
16498
16566
|
name: string;
|
|
16499
16567
|
namespace?: string;
|
|
16500
|
-
|
|
16501
|
-
content
|
|
16568
|
+
result: {
|
|
16569
|
+
content: ({
|
|
16502
16570
|
type: "text";
|
|
16503
16571
|
text: string;
|
|
16504
16572
|
textSignature?: string;
|
|
@@ -16508,8 +16576,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16508
16576
|
mimeType: string;
|
|
16509
16577
|
})[];
|
|
16510
16578
|
details?: any;
|
|
16579
|
+
isError: true;
|
|
16511
16580
|
};
|
|
16512
|
-
status: "
|
|
16581
|
+
status: "aborted";
|
|
16513
16582
|
thoughtSignature?: string;
|
|
16514
16583
|
time: {
|
|
16515
16584
|
start: number;
|
|
@@ -16684,14 +16753,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16684
16753
|
type: "image";
|
|
16685
16754
|
data: string;
|
|
16686
16755
|
mimeType: string;
|
|
16756
|
+
} | {
|
|
16757
|
+
type: "thinking";
|
|
16758
|
+
thinking: string;
|
|
16759
|
+
thinkingSignature?: string;
|
|
16760
|
+
redacted?: boolean;
|
|
16687
16761
|
} | {
|
|
16688
16762
|
addedToolNames?: string[];
|
|
16689
16763
|
arguments: Record<string, any>;
|
|
16690
16764
|
callID: string;
|
|
16691
16765
|
name: string;
|
|
16692
16766
|
namespace?: string;
|
|
16693
|
-
|
|
16694
|
-
content
|
|
16767
|
+
partial?: {
|
|
16768
|
+
content?: ({
|
|
16695
16769
|
type: "text";
|
|
16696
16770
|
text: string;
|
|
16697
16771
|
textSignature?: string;
|
|
@@ -16701,9 +16775,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16701
16775
|
mimeType: string;
|
|
16702
16776
|
})[];
|
|
16703
16777
|
details?: any;
|
|
16704
|
-
isError: false;
|
|
16705
16778
|
};
|
|
16706
|
-
status: "
|
|
16779
|
+
status: "running";
|
|
16707
16780
|
thoughtSignature?: string;
|
|
16708
16781
|
time: {
|
|
16709
16782
|
start: number;
|
|
@@ -16727,9 +16800,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16727
16800
|
mimeType: string;
|
|
16728
16801
|
})[];
|
|
16729
16802
|
details?: any;
|
|
16730
|
-
isError:
|
|
16803
|
+
isError: false;
|
|
16731
16804
|
};
|
|
16732
|
-
status: "
|
|
16805
|
+
status: "completed";
|
|
16733
16806
|
thoughtSignature?: string;
|
|
16734
16807
|
time: {
|
|
16735
16808
|
start: number;
|
|
@@ -16755,7 +16828,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16755
16828
|
details?: any;
|
|
16756
16829
|
isError: true;
|
|
16757
16830
|
};
|
|
16758
|
-
status: "
|
|
16831
|
+
status: "error";
|
|
16759
16832
|
thoughtSignature?: string;
|
|
16760
16833
|
time: {
|
|
16761
16834
|
start: number;
|
|
@@ -16781,26 +16854,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16781
16854
|
details?: any;
|
|
16782
16855
|
isError: true;
|
|
16783
16856
|
};
|
|
16784
|
-
status: "
|
|
16857
|
+
status: "skipped";
|
|
16785
16858
|
thoughtSignature?: string;
|
|
16786
16859
|
time: {
|
|
16787
16860
|
start: number;
|
|
16788
16861
|
end: number;
|
|
16789
16862
|
};
|
|
16790
16863
|
type: "toolCall";
|
|
16791
|
-
} | {
|
|
16792
|
-
type: "thinking";
|
|
16793
|
-
thinking: string;
|
|
16794
|
-
thinkingSignature?: string;
|
|
16795
|
-
redacted?: boolean;
|
|
16796
16864
|
} | {
|
|
16797
16865
|
addedToolNames?: string[];
|
|
16798
16866
|
arguments: Record<string, any>;
|
|
16799
16867
|
callID: string;
|
|
16800
16868
|
name: string;
|
|
16801
16869
|
namespace?: string;
|
|
16802
|
-
|
|
16803
|
-
content
|
|
16870
|
+
result: {
|
|
16871
|
+
content: ({
|
|
16804
16872
|
type: "text";
|
|
16805
16873
|
text: string;
|
|
16806
16874
|
textSignature?: string;
|
|
@@ -16810,8 +16878,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
16810
16878
|
mimeType: string;
|
|
16811
16879
|
})[];
|
|
16812
16880
|
details?: any;
|
|
16881
|
+
isError: true;
|
|
16813
16882
|
};
|
|
16814
|
-
status: "
|
|
16883
|
+
status: "aborted";
|
|
16815
16884
|
thoughtSignature?: string;
|
|
16816
16885
|
time: {
|
|
16817
16886
|
start: number;
|
|
@@ -17292,14 +17361,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17292
17361
|
type: "image";
|
|
17293
17362
|
data: string;
|
|
17294
17363
|
mimeType: string;
|
|
17364
|
+
} | {
|
|
17365
|
+
type: "thinking";
|
|
17366
|
+
thinking: string;
|
|
17367
|
+
thinkingSignature?: string;
|
|
17368
|
+
redacted?: boolean;
|
|
17295
17369
|
} | {
|
|
17296
17370
|
addedToolNames?: string[];
|
|
17297
17371
|
arguments: Record<string, any>;
|
|
17298
17372
|
callID: string;
|
|
17299
17373
|
name: string;
|
|
17300
17374
|
namespace?: string;
|
|
17301
|
-
|
|
17302
|
-
content
|
|
17375
|
+
partial?: {
|
|
17376
|
+
content?: ({
|
|
17303
17377
|
type: "text";
|
|
17304
17378
|
text: string;
|
|
17305
17379
|
textSignature?: string;
|
|
@@ -17309,9 +17383,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17309
17383
|
mimeType: string;
|
|
17310
17384
|
})[];
|
|
17311
17385
|
details?: any;
|
|
17312
|
-
isError: false;
|
|
17313
17386
|
};
|
|
17314
|
-
status: "
|
|
17387
|
+
status: "running";
|
|
17315
17388
|
thoughtSignature?: string;
|
|
17316
17389
|
time: {
|
|
17317
17390
|
start: number;
|
|
@@ -17335,9 +17408,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17335
17408
|
mimeType: string;
|
|
17336
17409
|
})[];
|
|
17337
17410
|
details?: any;
|
|
17338
|
-
isError:
|
|
17411
|
+
isError: false;
|
|
17339
17412
|
};
|
|
17340
|
-
status: "
|
|
17413
|
+
status: "completed";
|
|
17341
17414
|
thoughtSignature?: string;
|
|
17342
17415
|
time: {
|
|
17343
17416
|
start: number;
|
|
@@ -17363,7 +17436,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17363
17436
|
details?: any;
|
|
17364
17437
|
isError: true;
|
|
17365
17438
|
};
|
|
17366
|
-
status: "
|
|
17439
|
+
status: "error";
|
|
17367
17440
|
thoughtSignature?: string;
|
|
17368
17441
|
time: {
|
|
17369
17442
|
start: number;
|
|
@@ -17389,26 +17462,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17389
17462
|
details?: any;
|
|
17390
17463
|
isError: true;
|
|
17391
17464
|
};
|
|
17392
|
-
status: "
|
|
17465
|
+
status: "skipped";
|
|
17393
17466
|
thoughtSignature?: string;
|
|
17394
17467
|
time: {
|
|
17395
17468
|
start: number;
|
|
17396
17469
|
end: number;
|
|
17397
17470
|
};
|
|
17398
17471
|
type: "toolCall";
|
|
17399
|
-
} | {
|
|
17400
|
-
type: "thinking";
|
|
17401
|
-
thinking: string;
|
|
17402
|
-
thinkingSignature?: string;
|
|
17403
|
-
redacted?: boolean;
|
|
17404
17472
|
} | {
|
|
17405
17473
|
addedToolNames?: string[];
|
|
17406
17474
|
arguments: Record<string, any>;
|
|
17407
17475
|
callID: string;
|
|
17408
17476
|
name: string;
|
|
17409
17477
|
namespace?: string;
|
|
17410
|
-
|
|
17411
|
-
content
|
|
17478
|
+
result: {
|
|
17479
|
+
content: ({
|
|
17412
17480
|
type: "text";
|
|
17413
17481
|
text: string;
|
|
17414
17482
|
textSignature?: string;
|
|
@@ -17418,8 +17486,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17418
17486
|
mimeType: string;
|
|
17419
17487
|
})[];
|
|
17420
17488
|
details?: any;
|
|
17489
|
+
isError: true;
|
|
17421
17490
|
};
|
|
17422
|
-
status: "
|
|
17491
|
+
status: "aborted";
|
|
17423
17492
|
thoughtSignature?: string;
|
|
17424
17493
|
time: {
|
|
17425
17494
|
start: number;
|
|
@@ -17594,14 +17663,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17594
17663
|
type: "image";
|
|
17595
17664
|
data: string;
|
|
17596
17665
|
mimeType: string;
|
|
17666
|
+
} | {
|
|
17667
|
+
type: "thinking";
|
|
17668
|
+
thinking: string;
|
|
17669
|
+
thinkingSignature?: string;
|
|
17670
|
+
redacted?: boolean;
|
|
17597
17671
|
} | {
|
|
17598
17672
|
addedToolNames?: string[];
|
|
17599
17673
|
arguments: Record<string, any>;
|
|
17600
17674
|
callID: string;
|
|
17601
17675
|
name: string;
|
|
17602
17676
|
namespace?: string;
|
|
17603
|
-
|
|
17604
|
-
content
|
|
17677
|
+
partial?: {
|
|
17678
|
+
content?: ({
|
|
17605
17679
|
type: "text";
|
|
17606
17680
|
text: string;
|
|
17607
17681
|
textSignature?: string;
|
|
@@ -17611,9 +17685,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17611
17685
|
mimeType: string;
|
|
17612
17686
|
})[];
|
|
17613
17687
|
details?: any;
|
|
17614
|
-
isError: false;
|
|
17615
17688
|
};
|
|
17616
|
-
status: "
|
|
17689
|
+
status: "running";
|
|
17617
17690
|
thoughtSignature?: string;
|
|
17618
17691
|
time: {
|
|
17619
17692
|
start: number;
|
|
@@ -17637,9 +17710,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17637
17710
|
mimeType: string;
|
|
17638
17711
|
})[];
|
|
17639
17712
|
details?: any;
|
|
17640
|
-
isError:
|
|
17713
|
+
isError: false;
|
|
17641
17714
|
};
|
|
17642
|
-
status: "
|
|
17715
|
+
status: "completed";
|
|
17643
17716
|
thoughtSignature?: string;
|
|
17644
17717
|
time: {
|
|
17645
17718
|
start: number;
|
|
@@ -17665,7 +17738,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17665
17738
|
details?: any;
|
|
17666
17739
|
isError: true;
|
|
17667
17740
|
};
|
|
17668
|
-
status: "
|
|
17741
|
+
status: "error";
|
|
17669
17742
|
thoughtSignature?: string;
|
|
17670
17743
|
time: {
|
|
17671
17744
|
start: number;
|
|
@@ -17691,26 +17764,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17691
17764
|
details?: any;
|
|
17692
17765
|
isError: true;
|
|
17693
17766
|
};
|
|
17694
|
-
status: "
|
|
17767
|
+
status: "skipped";
|
|
17695
17768
|
thoughtSignature?: string;
|
|
17696
17769
|
time: {
|
|
17697
17770
|
start: number;
|
|
17698
17771
|
end: number;
|
|
17699
17772
|
};
|
|
17700
17773
|
type: "toolCall";
|
|
17701
|
-
} | {
|
|
17702
|
-
type: "thinking";
|
|
17703
|
-
thinking: string;
|
|
17704
|
-
thinkingSignature?: string;
|
|
17705
|
-
redacted?: boolean;
|
|
17706
17774
|
} | {
|
|
17707
17775
|
addedToolNames?: string[];
|
|
17708
17776
|
arguments: Record<string, any>;
|
|
17709
17777
|
callID: string;
|
|
17710
17778
|
name: string;
|
|
17711
17779
|
namespace?: string;
|
|
17712
|
-
|
|
17713
|
-
content
|
|
17780
|
+
result: {
|
|
17781
|
+
content: ({
|
|
17714
17782
|
type: "text";
|
|
17715
17783
|
text: string;
|
|
17716
17784
|
textSignature?: string;
|
|
@@ -17720,8 +17788,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17720
17788
|
mimeType: string;
|
|
17721
17789
|
})[];
|
|
17722
17790
|
details?: any;
|
|
17791
|
+
isError: true;
|
|
17723
17792
|
};
|
|
17724
|
-
status: "
|
|
17793
|
+
status: "aborted";
|
|
17725
17794
|
thoughtSignature?: string;
|
|
17726
17795
|
time: {
|
|
17727
17796
|
start: number;
|
|
@@ -17915,14 +17984,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17915
17984
|
type: "image";
|
|
17916
17985
|
data: string;
|
|
17917
17986
|
mimeType: string;
|
|
17987
|
+
} | {
|
|
17988
|
+
type: "thinking";
|
|
17989
|
+
thinking: string;
|
|
17990
|
+
thinkingSignature?: string;
|
|
17991
|
+
redacted?: boolean;
|
|
17918
17992
|
} | {
|
|
17919
17993
|
addedToolNames?: string[];
|
|
17920
17994
|
arguments: Record<string, any>;
|
|
17921
17995
|
callID: string;
|
|
17922
17996
|
name: string;
|
|
17923
17997
|
namespace?: string;
|
|
17924
|
-
|
|
17925
|
-
content
|
|
17998
|
+
partial?: {
|
|
17999
|
+
content?: ({
|
|
17926
18000
|
type: "text";
|
|
17927
18001
|
text: string;
|
|
17928
18002
|
textSignature?: string;
|
|
@@ -17932,9 +18006,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17932
18006
|
mimeType: string;
|
|
17933
18007
|
})[];
|
|
17934
18008
|
details?: any;
|
|
17935
|
-
isError: false;
|
|
17936
18009
|
};
|
|
17937
|
-
status: "
|
|
18010
|
+
status: "running";
|
|
17938
18011
|
thoughtSignature?: string;
|
|
17939
18012
|
time: {
|
|
17940
18013
|
start: number;
|
|
@@ -17958,9 +18031,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17958
18031
|
mimeType: string;
|
|
17959
18032
|
})[];
|
|
17960
18033
|
details?: any;
|
|
17961
|
-
isError:
|
|
18034
|
+
isError: false;
|
|
17962
18035
|
};
|
|
17963
|
-
status: "
|
|
18036
|
+
status: "completed";
|
|
17964
18037
|
thoughtSignature?: string;
|
|
17965
18038
|
time: {
|
|
17966
18039
|
start: number;
|
|
@@ -17986,7 +18059,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
17986
18059
|
details?: any;
|
|
17987
18060
|
isError: true;
|
|
17988
18061
|
};
|
|
17989
|
-
status: "
|
|
18062
|
+
status: "error";
|
|
17990
18063
|
thoughtSignature?: string;
|
|
17991
18064
|
time: {
|
|
17992
18065
|
start: number;
|
|
@@ -18012,26 +18085,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18012
18085
|
details?: any;
|
|
18013
18086
|
isError: true;
|
|
18014
18087
|
};
|
|
18015
|
-
status: "
|
|
18088
|
+
status: "skipped";
|
|
18016
18089
|
thoughtSignature?: string;
|
|
18017
18090
|
time: {
|
|
18018
18091
|
start: number;
|
|
18019
18092
|
end: number;
|
|
18020
18093
|
};
|
|
18021
18094
|
type: "toolCall";
|
|
18022
|
-
} | {
|
|
18023
|
-
type: "thinking";
|
|
18024
|
-
thinking: string;
|
|
18025
|
-
thinkingSignature?: string;
|
|
18026
|
-
redacted?: boolean;
|
|
18027
18095
|
} | {
|
|
18028
18096
|
addedToolNames?: string[];
|
|
18029
18097
|
arguments: Record<string, any>;
|
|
18030
18098
|
callID: string;
|
|
18031
18099
|
name: string;
|
|
18032
18100
|
namespace?: string;
|
|
18033
|
-
|
|
18034
|
-
content
|
|
18101
|
+
result: {
|
|
18102
|
+
content: ({
|
|
18035
18103
|
type: "text";
|
|
18036
18104
|
text: string;
|
|
18037
18105
|
textSignature?: string;
|
|
@@ -18041,8 +18109,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18041
18109
|
mimeType: string;
|
|
18042
18110
|
})[];
|
|
18043
18111
|
details?: any;
|
|
18112
|
+
isError: true;
|
|
18044
18113
|
};
|
|
18045
|
-
status: "
|
|
18114
|
+
status: "aborted";
|
|
18046
18115
|
thoughtSignature?: string;
|
|
18047
18116
|
time: {
|
|
18048
18117
|
start: number;
|
|
@@ -18217,14 +18286,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18217
18286
|
type: "image";
|
|
18218
18287
|
data: string;
|
|
18219
18288
|
mimeType: string;
|
|
18289
|
+
} | {
|
|
18290
|
+
type: "thinking";
|
|
18291
|
+
thinking: string;
|
|
18292
|
+
thinkingSignature?: string;
|
|
18293
|
+
redacted?: boolean;
|
|
18220
18294
|
} | {
|
|
18221
18295
|
addedToolNames?: string[];
|
|
18222
18296
|
arguments: Record<string, any>;
|
|
18223
18297
|
callID: string;
|
|
18224
18298
|
name: string;
|
|
18225
18299
|
namespace?: string;
|
|
18226
|
-
|
|
18227
|
-
content
|
|
18300
|
+
partial?: {
|
|
18301
|
+
content?: ({
|
|
18228
18302
|
type: "text";
|
|
18229
18303
|
text: string;
|
|
18230
18304
|
textSignature?: string;
|
|
@@ -18234,9 +18308,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18234
18308
|
mimeType: string;
|
|
18235
18309
|
})[];
|
|
18236
18310
|
details?: any;
|
|
18237
|
-
isError: false;
|
|
18238
18311
|
};
|
|
18239
|
-
status: "
|
|
18312
|
+
status: "running";
|
|
18240
18313
|
thoughtSignature?: string;
|
|
18241
18314
|
time: {
|
|
18242
18315
|
start: number;
|
|
@@ -18260,9 +18333,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18260
18333
|
mimeType: string;
|
|
18261
18334
|
})[];
|
|
18262
18335
|
details?: any;
|
|
18263
|
-
isError:
|
|
18336
|
+
isError: false;
|
|
18264
18337
|
};
|
|
18265
|
-
status: "
|
|
18338
|
+
status: "completed";
|
|
18266
18339
|
thoughtSignature?: string;
|
|
18267
18340
|
time: {
|
|
18268
18341
|
start: number;
|
|
@@ -18288,7 +18361,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18288
18361
|
details?: any;
|
|
18289
18362
|
isError: true;
|
|
18290
18363
|
};
|
|
18291
|
-
status: "
|
|
18364
|
+
status: "error";
|
|
18292
18365
|
thoughtSignature?: string;
|
|
18293
18366
|
time: {
|
|
18294
18367
|
start: number;
|
|
@@ -18314,26 +18387,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18314
18387
|
details?: any;
|
|
18315
18388
|
isError: true;
|
|
18316
18389
|
};
|
|
18317
|
-
status: "
|
|
18390
|
+
status: "skipped";
|
|
18318
18391
|
thoughtSignature?: string;
|
|
18319
18392
|
time: {
|
|
18320
18393
|
start: number;
|
|
18321
18394
|
end: number;
|
|
18322
18395
|
};
|
|
18323
18396
|
type: "toolCall";
|
|
18324
|
-
} | {
|
|
18325
|
-
type: "thinking";
|
|
18326
|
-
thinking: string;
|
|
18327
|
-
thinkingSignature?: string;
|
|
18328
|
-
redacted?: boolean;
|
|
18329
18397
|
} | {
|
|
18330
18398
|
addedToolNames?: string[];
|
|
18331
18399
|
arguments: Record<string, any>;
|
|
18332
18400
|
callID: string;
|
|
18333
18401
|
name: string;
|
|
18334
18402
|
namespace?: string;
|
|
18335
|
-
|
|
18336
|
-
content
|
|
18403
|
+
result: {
|
|
18404
|
+
content: ({
|
|
18337
18405
|
type: "text";
|
|
18338
18406
|
text: string;
|
|
18339
18407
|
textSignature?: string;
|
|
@@ -18343,8 +18411,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18343
18411
|
mimeType: string;
|
|
18344
18412
|
})[];
|
|
18345
18413
|
details?: any;
|
|
18414
|
+
isError: true;
|
|
18346
18415
|
};
|
|
18347
|
-
status: "
|
|
18416
|
+
status: "aborted";
|
|
18348
18417
|
thoughtSignature?: string;
|
|
18349
18418
|
time: {
|
|
18350
18419
|
start: number;
|
|
@@ -18547,14 +18616,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18547
18616
|
type: "image";
|
|
18548
18617
|
data: string;
|
|
18549
18618
|
mimeType: string;
|
|
18619
|
+
} | {
|
|
18620
|
+
type: "thinking";
|
|
18621
|
+
thinking: string;
|
|
18622
|
+
thinkingSignature?: string;
|
|
18623
|
+
redacted?: boolean;
|
|
18550
18624
|
} | {
|
|
18551
18625
|
addedToolNames?: string[];
|
|
18552
18626
|
arguments: Record<string, any>;
|
|
18553
18627
|
callID: string;
|
|
18554
18628
|
name: string;
|
|
18555
18629
|
namespace?: string;
|
|
18556
|
-
|
|
18557
|
-
content
|
|
18630
|
+
partial?: {
|
|
18631
|
+
content?: ({
|
|
18558
18632
|
type: "text";
|
|
18559
18633
|
text: string;
|
|
18560
18634
|
textSignature?: string;
|
|
@@ -18564,9 +18638,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18564
18638
|
mimeType: string;
|
|
18565
18639
|
})[];
|
|
18566
18640
|
details?: any;
|
|
18567
|
-
isError: false;
|
|
18568
18641
|
};
|
|
18569
|
-
status: "
|
|
18642
|
+
status: "running";
|
|
18570
18643
|
thoughtSignature?: string;
|
|
18571
18644
|
time: {
|
|
18572
18645
|
start: number;
|
|
@@ -18590,9 +18663,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18590
18663
|
mimeType: string;
|
|
18591
18664
|
})[];
|
|
18592
18665
|
details?: any;
|
|
18593
|
-
isError:
|
|
18666
|
+
isError: false;
|
|
18594
18667
|
};
|
|
18595
|
-
status: "
|
|
18668
|
+
status: "completed";
|
|
18596
18669
|
thoughtSignature?: string;
|
|
18597
18670
|
time: {
|
|
18598
18671
|
start: number;
|
|
@@ -18618,7 +18691,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18618
18691
|
details?: any;
|
|
18619
18692
|
isError: true;
|
|
18620
18693
|
};
|
|
18621
|
-
status: "
|
|
18694
|
+
status: "error";
|
|
18622
18695
|
thoughtSignature?: string;
|
|
18623
18696
|
time: {
|
|
18624
18697
|
start: number;
|
|
@@ -18644,26 +18717,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18644
18717
|
details?: any;
|
|
18645
18718
|
isError: true;
|
|
18646
18719
|
};
|
|
18647
|
-
status: "
|
|
18720
|
+
status: "skipped";
|
|
18648
18721
|
thoughtSignature?: string;
|
|
18649
18722
|
time: {
|
|
18650
18723
|
start: number;
|
|
18651
18724
|
end: number;
|
|
18652
18725
|
};
|
|
18653
18726
|
type: "toolCall";
|
|
18654
|
-
} | {
|
|
18655
|
-
type: "thinking";
|
|
18656
|
-
thinking: string;
|
|
18657
|
-
thinkingSignature?: string;
|
|
18658
|
-
redacted?: boolean;
|
|
18659
18727
|
} | {
|
|
18660
18728
|
addedToolNames?: string[];
|
|
18661
18729
|
arguments: Record<string, any>;
|
|
18662
18730
|
callID: string;
|
|
18663
18731
|
name: string;
|
|
18664
18732
|
namespace?: string;
|
|
18665
|
-
|
|
18666
|
-
content
|
|
18733
|
+
result: {
|
|
18734
|
+
content: ({
|
|
18667
18735
|
type: "text";
|
|
18668
18736
|
text: string;
|
|
18669
18737
|
textSignature?: string;
|
|
@@ -18673,8 +18741,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18673
18741
|
mimeType: string;
|
|
18674
18742
|
})[];
|
|
18675
18743
|
details?: any;
|
|
18744
|
+
isError: true;
|
|
18676
18745
|
};
|
|
18677
|
-
status: "
|
|
18746
|
+
status: "aborted";
|
|
18678
18747
|
thoughtSignature?: string;
|
|
18679
18748
|
time: {
|
|
18680
18749
|
start: number;
|
|
@@ -18849,14 +18918,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18849
18918
|
type: "image";
|
|
18850
18919
|
data: string;
|
|
18851
18920
|
mimeType: string;
|
|
18921
|
+
} | {
|
|
18922
|
+
type: "thinking";
|
|
18923
|
+
thinking: string;
|
|
18924
|
+
thinkingSignature?: string;
|
|
18925
|
+
redacted?: boolean;
|
|
18852
18926
|
} | {
|
|
18853
18927
|
addedToolNames?: string[];
|
|
18854
18928
|
arguments: Record<string, any>;
|
|
18855
18929
|
callID: string;
|
|
18856
18930
|
name: string;
|
|
18857
18931
|
namespace?: string;
|
|
18858
|
-
|
|
18859
|
-
content
|
|
18932
|
+
partial?: {
|
|
18933
|
+
content?: ({
|
|
18860
18934
|
type: "text";
|
|
18861
18935
|
text: string;
|
|
18862
18936
|
textSignature?: string;
|
|
@@ -18866,9 +18940,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18866
18940
|
mimeType: string;
|
|
18867
18941
|
})[];
|
|
18868
18942
|
details?: any;
|
|
18869
|
-
isError: false;
|
|
18870
18943
|
};
|
|
18871
|
-
status: "
|
|
18944
|
+
status: "running";
|
|
18872
18945
|
thoughtSignature?: string;
|
|
18873
18946
|
time: {
|
|
18874
18947
|
start: number;
|
|
@@ -18892,9 +18965,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18892
18965
|
mimeType: string;
|
|
18893
18966
|
})[];
|
|
18894
18967
|
details?: any;
|
|
18895
|
-
isError:
|
|
18968
|
+
isError: false;
|
|
18896
18969
|
};
|
|
18897
|
-
status: "
|
|
18970
|
+
status: "completed";
|
|
18898
18971
|
thoughtSignature?: string;
|
|
18899
18972
|
time: {
|
|
18900
18973
|
start: number;
|
|
@@ -18920,7 +18993,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18920
18993
|
details?: any;
|
|
18921
18994
|
isError: true;
|
|
18922
18995
|
};
|
|
18923
|
-
status: "
|
|
18996
|
+
status: "error";
|
|
18924
18997
|
thoughtSignature?: string;
|
|
18925
18998
|
time: {
|
|
18926
18999
|
start: number;
|
|
@@ -18946,26 +19019,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18946
19019
|
details?: any;
|
|
18947
19020
|
isError: true;
|
|
18948
19021
|
};
|
|
18949
|
-
status: "
|
|
19022
|
+
status: "skipped";
|
|
18950
19023
|
thoughtSignature?: string;
|
|
18951
19024
|
time: {
|
|
18952
19025
|
start: number;
|
|
18953
19026
|
end: number;
|
|
18954
19027
|
};
|
|
18955
19028
|
type: "toolCall";
|
|
18956
|
-
} | {
|
|
18957
|
-
type: "thinking";
|
|
18958
|
-
thinking: string;
|
|
18959
|
-
thinkingSignature?: string;
|
|
18960
|
-
redacted?: boolean;
|
|
18961
19029
|
} | {
|
|
18962
19030
|
addedToolNames?: string[];
|
|
18963
19031
|
arguments: Record<string, any>;
|
|
18964
19032
|
callID: string;
|
|
18965
19033
|
name: string;
|
|
18966
19034
|
namespace?: string;
|
|
18967
|
-
|
|
18968
|
-
content
|
|
19035
|
+
result: {
|
|
19036
|
+
content: ({
|
|
18969
19037
|
type: "text";
|
|
18970
19038
|
text: string;
|
|
18971
19039
|
textSignature?: string;
|
|
@@ -18975,8 +19043,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
18975
19043
|
mimeType: string;
|
|
18976
19044
|
})[];
|
|
18977
19045
|
details?: any;
|
|
19046
|
+
isError: true;
|
|
18978
19047
|
};
|
|
18979
|
-
status: "
|
|
19048
|
+
status: "aborted";
|
|
18980
19049
|
thoughtSignature?: string;
|
|
18981
19050
|
time: {
|
|
18982
19051
|
start: number;
|
|
@@ -19170,14 +19239,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19170
19239
|
type: "image";
|
|
19171
19240
|
data: string;
|
|
19172
19241
|
mimeType: string;
|
|
19242
|
+
} | {
|
|
19243
|
+
type: "thinking";
|
|
19244
|
+
thinking: string;
|
|
19245
|
+
thinkingSignature?: string;
|
|
19246
|
+
redacted?: boolean;
|
|
19173
19247
|
} | {
|
|
19174
19248
|
addedToolNames?: string[];
|
|
19175
19249
|
arguments: Record<string, any>;
|
|
19176
19250
|
callID: string;
|
|
19177
19251
|
name: string;
|
|
19178
19252
|
namespace?: string;
|
|
19179
|
-
|
|
19180
|
-
content
|
|
19253
|
+
partial?: {
|
|
19254
|
+
content?: ({
|
|
19181
19255
|
type: "text";
|
|
19182
19256
|
text: string;
|
|
19183
19257
|
textSignature?: string;
|
|
@@ -19187,9 +19261,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19187
19261
|
mimeType: string;
|
|
19188
19262
|
})[];
|
|
19189
19263
|
details?: any;
|
|
19190
|
-
isError: false;
|
|
19191
19264
|
};
|
|
19192
|
-
status: "
|
|
19265
|
+
status: "running";
|
|
19193
19266
|
thoughtSignature?: string;
|
|
19194
19267
|
time: {
|
|
19195
19268
|
start: number;
|
|
@@ -19213,9 +19286,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19213
19286
|
mimeType: string;
|
|
19214
19287
|
})[];
|
|
19215
19288
|
details?: any;
|
|
19216
|
-
isError:
|
|
19289
|
+
isError: false;
|
|
19217
19290
|
};
|
|
19218
|
-
status: "
|
|
19291
|
+
status: "completed";
|
|
19219
19292
|
thoughtSignature?: string;
|
|
19220
19293
|
time: {
|
|
19221
19294
|
start: number;
|
|
@@ -19241,7 +19314,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19241
19314
|
details?: any;
|
|
19242
19315
|
isError: true;
|
|
19243
19316
|
};
|
|
19244
|
-
status: "
|
|
19317
|
+
status: "error";
|
|
19245
19318
|
thoughtSignature?: string;
|
|
19246
19319
|
time: {
|
|
19247
19320
|
start: number;
|
|
@@ -19267,26 +19340,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19267
19340
|
details?: any;
|
|
19268
19341
|
isError: true;
|
|
19269
19342
|
};
|
|
19270
|
-
status: "
|
|
19343
|
+
status: "skipped";
|
|
19271
19344
|
thoughtSignature?: string;
|
|
19272
19345
|
time: {
|
|
19273
19346
|
start: number;
|
|
19274
19347
|
end: number;
|
|
19275
19348
|
};
|
|
19276
19349
|
type: "toolCall";
|
|
19277
|
-
} | {
|
|
19278
|
-
type: "thinking";
|
|
19279
|
-
thinking: string;
|
|
19280
|
-
thinkingSignature?: string;
|
|
19281
|
-
redacted?: boolean;
|
|
19282
19350
|
} | {
|
|
19283
19351
|
addedToolNames?: string[];
|
|
19284
19352
|
arguments: Record<string, any>;
|
|
19285
19353
|
callID: string;
|
|
19286
19354
|
name: string;
|
|
19287
19355
|
namespace?: string;
|
|
19288
|
-
|
|
19289
|
-
content
|
|
19356
|
+
result: {
|
|
19357
|
+
content: ({
|
|
19290
19358
|
type: "text";
|
|
19291
19359
|
text: string;
|
|
19292
19360
|
textSignature?: string;
|
|
@@ -19296,8 +19364,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19296
19364
|
mimeType: string;
|
|
19297
19365
|
})[];
|
|
19298
19366
|
details?: any;
|
|
19367
|
+
isError: true;
|
|
19299
19368
|
};
|
|
19300
|
-
status: "
|
|
19369
|
+
status: "aborted";
|
|
19301
19370
|
thoughtSignature?: string;
|
|
19302
19371
|
time: {
|
|
19303
19372
|
start: number;
|
|
@@ -19472,14 +19541,19 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19472
19541
|
type: "image";
|
|
19473
19542
|
data: string;
|
|
19474
19543
|
mimeType: string;
|
|
19544
|
+
} | {
|
|
19545
|
+
type: "thinking";
|
|
19546
|
+
thinking: string;
|
|
19547
|
+
thinkingSignature?: string;
|
|
19548
|
+
redacted?: boolean;
|
|
19475
19549
|
} | {
|
|
19476
19550
|
addedToolNames?: string[];
|
|
19477
19551
|
arguments: Record<string, any>;
|
|
19478
19552
|
callID: string;
|
|
19479
19553
|
name: string;
|
|
19480
19554
|
namespace?: string;
|
|
19481
|
-
|
|
19482
|
-
content
|
|
19555
|
+
partial?: {
|
|
19556
|
+
content?: ({
|
|
19483
19557
|
type: "text";
|
|
19484
19558
|
text: string;
|
|
19485
19559
|
textSignature?: string;
|
|
@@ -19489,9 +19563,8 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19489
19563
|
mimeType: string;
|
|
19490
19564
|
})[];
|
|
19491
19565
|
details?: any;
|
|
19492
|
-
isError: false;
|
|
19493
19566
|
};
|
|
19494
|
-
status: "
|
|
19567
|
+
status: "running";
|
|
19495
19568
|
thoughtSignature?: string;
|
|
19496
19569
|
time: {
|
|
19497
19570
|
start: number;
|
|
@@ -19515,9 +19588,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19515
19588
|
mimeType: string;
|
|
19516
19589
|
})[];
|
|
19517
19590
|
details?: any;
|
|
19518
|
-
isError:
|
|
19591
|
+
isError: false;
|
|
19519
19592
|
};
|
|
19520
|
-
status: "
|
|
19593
|
+
status: "completed";
|
|
19521
19594
|
thoughtSignature?: string;
|
|
19522
19595
|
time: {
|
|
19523
19596
|
start: number;
|
|
@@ -19543,7 +19616,7 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19543
19616
|
details?: any;
|
|
19544
19617
|
isError: true;
|
|
19545
19618
|
};
|
|
19546
|
-
status: "
|
|
19619
|
+
status: "error";
|
|
19547
19620
|
thoughtSignature?: string;
|
|
19548
19621
|
time: {
|
|
19549
19622
|
start: number;
|
|
@@ -19569,26 +19642,21 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19569
19642
|
details?: any;
|
|
19570
19643
|
isError: true;
|
|
19571
19644
|
};
|
|
19572
|
-
status: "
|
|
19645
|
+
status: "skipped";
|
|
19573
19646
|
thoughtSignature?: string;
|
|
19574
19647
|
time: {
|
|
19575
19648
|
start: number;
|
|
19576
19649
|
end: number;
|
|
19577
19650
|
};
|
|
19578
19651
|
type: "toolCall";
|
|
19579
|
-
} | {
|
|
19580
|
-
type: "thinking";
|
|
19581
|
-
thinking: string;
|
|
19582
|
-
thinkingSignature?: string;
|
|
19583
|
-
redacted?: boolean;
|
|
19584
19652
|
} | {
|
|
19585
19653
|
addedToolNames?: string[];
|
|
19586
19654
|
arguments: Record<string, any>;
|
|
19587
19655
|
callID: string;
|
|
19588
19656
|
name: string;
|
|
19589
19657
|
namespace?: string;
|
|
19590
|
-
|
|
19591
|
-
content
|
|
19658
|
+
result: {
|
|
19659
|
+
content: ({
|
|
19592
19660
|
type: "text";
|
|
19593
19661
|
text: string;
|
|
19594
19662
|
textSignature?: string;
|
|
@@ -19598,8 +19666,9 @@ declare const PublicDefinitions: readonly [Schema.Struct<{
|
|
|
19598
19666
|
mimeType: string;
|
|
19599
19667
|
})[];
|
|
19600
19668
|
details?: any;
|
|
19669
|
+
isError: true;
|
|
19601
19670
|
};
|
|
19602
|
-
status: "
|
|
19671
|
+
status: "aborted";
|
|
19603
19672
|
thoughtSignature?: string;
|
|
19604
19673
|
time: {
|
|
19605
19674
|
start: number;
|
|
@@ -20787,14 +20856,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20787
20856
|
type: "image";
|
|
20788
20857
|
data: string;
|
|
20789
20858
|
mimeType: string;
|
|
20859
|
+
} | {
|
|
20860
|
+
type: "thinking";
|
|
20861
|
+
thinking: string;
|
|
20862
|
+
thinkingSignature?: string;
|
|
20863
|
+
redacted?: boolean;
|
|
20790
20864
|
} | {
|
|
20791
20865
|
addedToolNames?: string[];
|
|
20792
20866
|
arguments: Record<string, any>;
|
|
20793
20867
|
callID: string;
|
|
20794
20868
|
name: string;
|
|
20795
20869
|
namespace?: string;
|
|
20796
|
-
|
|
20797
|
-
content
|
|
20870
|
+
partial?: {
|
|
20871
|
+
content?: ({
|
|
20798
20872
|
type: "text";
|
|
20799
20873
|
text: string;
|
|
20800
20874
|
textSignature?: string;
|
|
@@ -20804,9 +20878,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20804
20878
|
mimeType: string;
|
|
20805
20879
|
})[];
|
|
20806
20880
|
details?: any;
|
|
20807
|
-
isError: false;
|
|
20808
20881
|
};
|
|
20809
|
-
status: "
|
|
20882
|
+
status: "running";
|
|
20810
20883
|
thoughtSignature?: string;
|
|
20811
20884
|
time: {
|
|
20812
20885
|
start: number;
|
|
@@ -20830,9 +20903,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20830
20903
|
mimeType: string;
|
|
20831
20904
|
})[];
|
|
20832
20905
|
details?: any;
|
|
20833
|
-
isError:
|
|
20906
|
+
isError: false;
|
|
20834
20907
|
};
|
|
20835
|
-
status: "
|
|
20908
|
+
status: "completed";
|
|
20836
20909
|
thoughtSignature?: string;
|
|
20837
20910
|
time: {
|
|
20838
20911
|
start: number;
|
|
@@ -20858,7 +20931,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20858
20931
|
details?: any;
|
|
20859
20932
|
isError: true;
|
|
20860
20933
|
};
|
|
20861
|
-
status: "
|
|
20934
|
+
status: "error";
|
|
20862
20935
|
thoughtSignature?: string;
|
|
20863
20936
|
time: {
|
|
20864
20937
|
start: number;
|
|
@@ -20884,26 +20957,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20884
20957
|
details?: any;
|
|
20885
20958
|
isError: true;
|
|
20886
20959
|
};
|
|
20887
|
-
status: "
|
|
20960
|
+
status: "skipped";
|
|
20888
20961
|
thoughtSignature?: string;
|
|
20889
20962
|
time: {
|
|
20890
20963
|
start: number;
|
|
20891
20964
|
end: number;
|
|
20892
20965
|
};
|
|
20893
20966
|
type: "toolCall";
|
|
20894
|
-
} | {
|
|
20895
|
-
type: "thinking";
|
|
20896
|
-
thinking: string;
|
|
20897
|
-
thinkingSignature?: string;
|
|
20898
|
-
redacted?: boolean;
|
|
20899
20967
|
} | {
|
|
20900
20968
|
addedToolNames?: string[];
|
|
20901
20969
|
arguments: Record<string, any>;
|
|
20902
20970
|
callID: string;
|
|
20903
20971
|
name: string;
|
|
20904
20972
|
namespace?: string;
|
|
20905
|
-
|
|
20906
|
-
content
|
|
20973
|
+
result: {
|
|
20974
|
+
content: ({
|
|
20907
20975
|
type: "text";
|
|
20908
20976
|
text: string;
|
|
20909
20977
|
textSignature?: string;
|
|
@@ -20913,8 +20981,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
20913
20981
|
mimeType: string;
|
|
20914
20982
|
})[];
|
|
20915
20983
|
details?: any;
|
|
20984
|
+
isError: true;
|
|
20916
20985
|
};
|
|
20917
|
-
status: "
|
|
20986
|
+
status: "aborted";
|
|
20918
20987
|
thoughtSignature?: string;
|
|
20919
20988
|
time: {
|
|
20920
20989
|
start: number;
|
|
@@ -21089,14 +21158,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21089
21158
|
type: "image";
|
|
21090
21159
|
data: string;
|
|
21091
21160
|
mimeType: string;
|
|
21161
|
+
} | {
|
|
21162
|
+
type: "thinking";
|
|
21163
|
+
thinking: string;
|
|
21164
|
+
thinkingSignature?: string;
|
|
21165
|
+
redacted?: boolean;
|
|
21092
21166
|
} | {
|
|
21093
21167
|
addedToolNames?: string[];
|
|
21094
21168
|
arguments: Record<string, any>;
|
|
21095
21169
|
callID: string;
|
|
21096
21170
|
name: string;
|
|
21097
21171
|
namespace?: string;
|
|
21098
|
-
|
|
21099
|
-
content
|
|
21172
|
+
partial?: {
|
|
21173
|
+
content?: ({
|
|
21100
21174
|
type: "text";
|
|
21101
21175
|
text: string;
|
|
21102
21176
|
textSignature?: string;
|
|
@@ -21106,9 +21180,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21106
21180
|
mimeType: string;
|
|
21107
21181
|
})[];
|
|
21108
21182
|
details?: any;
|
|
21109
|
-
isError: false;
|
|
21110
21183
|
};
|
|
21111
|
-
status: "
|
|
21184
|
+
status: "running";
|
|
21112
21185
|
thoughtSignature?: string;
|
|
21113
21186
|
time: {
|
|
21114
21187
|
start: number;
|
|
@@ -21132,9 +21205,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21132
21205
|
mimeType: string;
|
|
21133
21206
|
})[];
|
|
21134
21207
|
details?: any;
|
|
21135
|
-
isError:
|
|
21208
|
+
isError: false;
|
|
21136
21209
|
};
|
|
21137
|
-
status: "
|
|
21210
|
+
status: "completed";
|
|
21138
21211
|
thoughtSignature?: string;
|
|
21139
21212
|
time: {
|
|
21140
21213
|
start: number;
|
|
@@ -21160,7 +21233,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21160
21233
|
details?: any;
|
|
21161
21234
|
isError: true;
|
|
21162
21235
|
};
|
|
21163
|
-
status: "
|
|
21236
|
+
status: "error";
|
|
21164
21237
|
thoughtSignature?: string;
|
|
21165
21238
|
time: {
|
|
21166
21239
|
start: number;
|
|
@@ -21186,26 +21259,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21186
21259
|
details?: any;
|
|
21187
21260
|
isError: true;
|
|
21188
21261
|
};
|
|
21189
|
-
status: "
|
|
21262
|
+
status: "skipped";
|
|
21190
21263
|
thoughtSignature?: string;
|
|
21191
21264
|
time: {
|
|
21192
21265
|
start: number;
|
|
21193
21266
|
end: number;
|
|
21194
21267
|
};
|
|
21195
21268
|
type: "toolCall";
|
|
21196
|
-
} | {
|
|
21197
|
-
type: "thinking";
|
|
21198
|
-
thinking: string;
|
|
21199
|
-
thinkingSignature?: string;
|
|
21200
|
-
redacted?: boolean;
|
|
21201
21269
|
} | {
|
|
21202
21270
|
addedToolNames?: string[];
|
|
21203
21271
|
arguments: Record<string, any>;
|
|
21204
21272
|
callID: string;
|
|
21205
21273
|
name: string;
|
|
21206
21274
|
namespace?: string;
|
|
21207
|
-
|
|
21208
|
-
content
|
|
21275
|
+
result: {
|
|
21276
|
+
content: ({
|
|
21209
21277
|
type: "text";
|
|
21210
21278
|
text: string;
|
|
21211
21279
|
textSignature?: string;
|
|
@@ -21215,8 +21283,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21215
21283
|
mimeType: string;
|
|
21216
21284
|
})[];
|
|
21217
21285
|
details?: any;
|
|
21286
|
+
isError: true;
|
|
21218
21287
|
};
|
|
21219
|
-
status: "
|
|
21288
|
+
status: "aborted";
|
|
21220
21289
|
thoughtSignature?: string;
|
|
21221
21290
|
time: {
|
|
21222
21291
|
start: number;
|
|
@@ -21409,14 +21478,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21409
21478
|
type: "image";
|
|
21410
21479
|
data: string;
|
|
21411
21480
|
mimeType: string;
|
|
21481
|
+
} | {
|
|
21482
|
+
type: "thinking";
|
|
21483
|
+
thinking: string;
|
|
21484
|
+
thinkingSignature?: string;
|
|
21485
|
+
redacted?: boolean;
|
|
21412
21486
|
} | {
|
|
21413
21487
|
addedToolNames?: string[];
|
|
21414
21488
|
arguments: Record<string, any>;
|
|
21415
21489
|
callID: string;
|
|
21416
21490
|
name: string;
|
|
21417
21491
|
namespace?: string;
|
|
21418
|
-
|
|
21419
|
-
content
|
|
21492
|
+
partial?: {
|
|
21493
|
+
content?: ({
|
|
21420
21494
|
type: "text";
|
|
21421
21495
|
text: string;
|
|
21422
21496
|
textSignature?: string;
|
|
@@ -21426,9 +21500,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21426
21500
|
mimeType: string;
|
|
21427
21501
|
})[];
|
|
21428
21502
|
details?: any;
|
|
21429
|
-
isError: false;
|
|
21430
21503
|
};
|
|
21431
|
-
status: "
|
|
21504
|
+
status: "running";
|
|
21432
21505
|
thoughtSignature?: string;
|
|
21433
21506
|
time: {
|
|
21434
21507
|
start: number;
|
|
@@ -21452,9 +21525,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21452
21525
|
mimeType: string;
|
|
21453
21526
|
})[];
|
|
21454
21527
|
details?: any;
|
|
21455
|
-
isError:
|
|
21528
|
+
isError: false;
|
|
21456
21529
|
};
|
|
21457
|
-
status: "
|
|
21530
|
+
status: "completed";
|
|
21458
21531
|
thoughtSignature?: string;
|
|
21459
21532
|
time: {
|
|
21460
21533
|
start: number;
|
|
@@ -21480,7 +21553,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21480
21553
|
details?: any;
|
|
21481
21554
|
isError: true;
|
|
21482
21555
|
};
|
|
21483
|
-
status: "
|
|
21556
|
+
status: "error";
|
|
21484
21557
|
thoughtSignature?: string;
|
|
21485
21558
|
time: {
|
|
21486
21559
|
start: number;
|
|
@@ -21506,26 +21579,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21506
21579
|
details?: any;
|
|
21507
21580
|
isError: true;
|
|
21508
21581
|
};
|
|
21509
|
-
status: "
|
|
21582
|
+
status: "skipped";
|
|
21510
21583
|
thoughtSignature?: string;
|
|
21511
21584
|
time: {
|
|
21512
21585
|
start: number;
|
|
21513
21586
|
end: number;
|
|
21514
21587
|
};
|
|
21515
21588
|
type: "toolCall";
|
|
21516
|
-
} | {
|
|
21517
|
-
type: "thinking";
|
|
21518
|
-
thinking: string;
|
|
21519
|
-
thinkingSignature?: string;
|
|
21520
|
-
redacted?: boolean;
|
|
21521
21589
|
} | {
|
|
21522
21590
|
addedToolNames?: string[];
|
|
21523
21591
|
arguments: Record<string, any>;
|
|
21524
21592
|
callID: string;
|
|
21525
21593
|
name: string;
|
|
21526
21594
|
namespace?: string;
|
|
21527
|
-
|
|
21528
|
-
content
|
|
21595
|
+
result: {
|
|
21596
|
+
content: ({
|
|
21529
21597
|
type: "text";
|
|
21530
21598
|
text: string;
|
|
21531
21599
|
textSignature?: string;
|
|
@@ -21535,8 +21603,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21535
21603
|
mimeType: string;
|
|
21536
21604
|
})[];
|
|
21537
21605
|
details?: any;
|
|
21606
|
+
isError: true;
|
|
21538
21607
|
};
|
|
21539
|
-
status: "
|
|
21608
|
+
status: "aborted";
|
|
21540
21609
|
thoughtSignature?: string;
|
|
21541
21610
|
time: {
|
|
21542
21611
|
start: number;
|
|
@@ -21711,14 +21780,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21711
21780
|
type: "image";
|
|
21712
21781
|
data: string;
|
|
21713
21782
|
mimeType: string;
|
|
21783
|
+
} | {
|
|
21784
|
+
type: "thinking";
|
|
21785
|
+
thinking: string;
|
|
21786
|
+
thinkingSignature?: string;
|
|
21787
|
+
redacted?: boolean;
|
|
21714
21788
|
} | {
|
|
21715
21789
|
addedToolNames?: string[];
|
|
21716
21790
|
arguments: Record<string, any>;
|
|
21717
21791
|
callID: string;
|
|
21718
21792
|
name: string;
|
|
21719
21793
|
namespace?: string;
|
|
21720
|
-
|
|
21721
|
-
content
|
|
21794
|
+
partial?: {
|
|
21795
|
+
content?: ({
|
|
21722
21796
|
type: "text";
|
|
21723
21797
|
text: string;
|
|
21724
21798
|
textSignature?: string;
|
|
@@ -21728,9 +21802,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21728
21802
|
mimeType: string;
|
|
21729
21803
|
})[];
|
|
21730
21804
|
details?: any;
|
|
21731
|
-
isError: false;
|
|
21732
21805
|
};
|
|
21733
|
-
status: "
|
|
21806
|
+
status: "running";
|
|
21734
21807
|
thoughtSignature?: string;
|
|
21735
21808
|
time: {
|
|
21736
21809
|
start: number;
|
|
@@ -21754,9 +21827,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21754
21827
|
mimeType: string;
|
|
21755
21828
|
})[];
|
|
21756
21829
|
details?: any;
|
|
21757
|
-
isError:
|
|
21830
|
+
isError: false;
|
|
21758
21831
|
};
|
|
21759
|
-
status: "
|
|
21832
|
+
status: "completed";
|
|
21760
21833
|
thoughtSignature?: string;
|
|
21761
21834
|
time: {
|
|
21762
21835
|
start: number;
|
|
@@ -21782,7 +21855,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21782
21855
|
details?: any;
|
|
21783
21856
|
isError: true;
|
|
21784
21857
|
};
|
|
21785
|
-
status: "
|
|
21858
|
+
status: "error";
|
|
21786
21859
|
thoughtSignature?: string;
|
|
21787
21860
|
time: {
|
|
21788
21861
|
start: number;
|
|
@@ -21808,26 +21881,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21808
21881
|
details?: any;
|
|
21809
21882
|
isError: true;
|
|
21810
21883
|
};
|
|
21811
|
-
status: "
|
|
21884
|
+
status: "skipped";
|
|
21812
21885
|
thoughtSignature?: string;
|
|
21813
21886
|
time: {
|
|
21814
21887
|
start: number;
|
|
21815
21888
|
end: number;
|
|
21816
21889
|
};
|
|
21817
21890
|
type: "toolCall";
|
|
21818
|
-
} | {
|
|
21819
|
-
type: "thinking";
|
|
21820
|
-
thinking: string;
|
|
21821
|
-
thinkingSignature?: string;
|
|
21822
|
-
redacted?: boolean;
|
|
21823
21891
|
} | {
|
|
21824
21892
|
addedToolNames?: string[];
|
|
21825
21893
|
arguments: Record<string, any>;
|
|
21826
21894
|
callID: string;
|
|
21827
21895
|
name: string;
|
|
21828
21896
|
namespace?: string;
|
|
21829
|
-
|
|
21830
|
-
content
|
|
21897
|
+
result: {
|
|
21898
|
+
content: ({
|
|
21831
21899
|
type: "text";
|
|
21832
21900
|
text: string;
|
|
21833
21901
|
textSignature?: string;
|
|
@@ -21837,8 +21905,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
21837
21905
|
mimeType: string;
|
|
21838
21906
|
})[];
|
|
21839
21907
|
details?: any;
|
|
21908
|
+
isError: true;
|
|
21840
21909
|
};
|
|
21841
|
-
status: "
|
|
21910
|
+
status: "aborted";
|
|
21842
21911
|
thoughtSignature?: string;
|
|
21843
21912
|
time: {
|
|
21844
21913
|
start: number;
|
|
@@ -22041,14 +22110,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22041
22110
|
type: "image";
|
|
22042
22111
|
data: string;
|
|
22043
22112
|
mimeType: string;
|
|
22113
|
+
} | {
|
|
22114
|
+
type: "thinking";
|
|
22115
|
+
thinking: string;
|
|
22116
|
+
thinkingSignature?: string;
|
|
22117
|
+
redacted?: boolean;
|
|
22044
22118
|
} | {
|
|
22045
22119
|
addedToolNames?: string[];
|
|
22046
22120
|
arguments: Record<string, any>;
|
|
22047
22121
|
callID: string;
|
|
22048
22122
|
name: string;
|
|
22049
22123
|
namespace?: string;
|
|
22050
|
-
|
|
22051
|
-
content
|
|
22124
|
+
partial?: {
|
|
22125
|
+
content?: ({
|
|
22052
22126
|
type: "text";
|
|
22053
22127
|
text: string;
|
|
22054
22128
|
textSignature?: string;
|
|
@@ -22058,9 +22132,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22058
22132
|
mimeType: string;
|
|
22059
22133
|
})[];
|
|
22060
22134
|
details?: any;
|
|
22061
|
-
isError: false;
|
|
22062
22135
|
};
|
|
22063
|
-
status: "
|
|
22136
|
+
status: "running";
|
|
22064
22137
|
thoughtSignature?: string;
|
|
22065
22138
|
time: {
|
|
22066
22139
|
start: number;
|
|
@@ -22084,9 +22157,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22084
22157
|
mimeType: string;
|
|
22085
22158
|
})[];
|
|
22086
22159
|
details?: any;
|
|
22087
|
-
isError:
|
|
22160
|
+
isError: false;
|
|
22088
22161
|
};
|
|
22089
|
-
status: "
|
|
22162
|
+
status: "completed";
|
|
22090
22163
|
thoughtSignature?: string;
|
|
22091
22164
|
time: {
|
|
22092
22165
|
start: number;
|
|
@@ -22112,7 +22185,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22112
22185
|
details?: any;
|
|
22113
22186
|
isError: true;
|
|
22114
22187
|
};
|
|
22115
|
-
status: "
|
|
22188
|
+
status: "error";
|
|
22116
22189
|
thoughtSignature?: string;
|
|
22117
22190
|
time: {
|
|
22118
22191
|
start: number;
|
|
@@ -22138,26 +22211,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22138
22211
|
details?: any;
|
|
22139
22212
|
isError: true;
|
|
22140
22213
|
};
|
|
22141
|
-
status: "
|
|
22214
|
+
status: "skipped";
|
|
22142
22215
|
thoughtSignature?: string;
|
|
22143
22216
|
time: {
|
|
22144
22217
|
start: number;
|
|
22145
22218
|
end: number;
|
|
22146
22219
|
};
|
|
22147
22220
|
type: "toolCall";
|
|
22148
|
-
} | {
|
|
22149
|
-
type: "thinking";
|
|
22150
|
-
thinking: string;
|
|
22151
|
-
thinkingSignature?: string;
|
|
22152
|
-
redacted?: boolean;
|
|
22153
22221
|
} | {
|
|
22154
22222
|
addedToolNames?: string[];
|
|
22155
22223
|
arguments: Record<string, any>;
|
|
22156
22224
|
callID: string;
|
|
22157
22225
|
name: string;
|
|
22158
22226
|
namespace?: string;
|
|
22159
|
-
|
|
22160
|
-
content
|
|
22227
|
+
result: {
|
|
22228
|
+
content: ({
|
|
22161
22229
|
type: "text";
|
|
22162
22230
|
text: string;
|
|
22163
22231
|
textSignature?: string;
|
|
@@ -22167,8 +22235,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22167
22235
|
mimeType: string;
|
|
22168
22236
|
})[];
|
|
22169
22237
|
details?: any;
|
|
22238
|
+
isError: true;
|
|
22170
22239
|
};
|
|
22171
|
-
status: "
|
|
22240
|
+
status: "aborted";
|
|
22172
22241
|
thoughtSignature?: string;
|
|
22173
22242
|
time: {
|
|
22174
22243
|
start: number;
|
|
@@ -22343,14 +22412,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22343
22412
|
type: "image";
|
|
22344
22413
|
data: string;
|
|
22345
22414
|
mimeType: string;
|
|
22415
|
+
} | {
|
|
22416
|
+
type: "thinking";
|
|
22417
|
+
thinking: string;
|
|
22418
|
+
thinkingSignature?: string;
|
|
22419
|
+
redacted?: boolean;
|
|
22346
22420
|
} | {
|
|
22347
22421
|
addedToolNames?: string[];
|
|
22348
22422
|
arguments: Record<string, any>;
|
|
22349
22423
|
callID: string;
|
|
22350
22424
|
name: string;
|
|
22351
22425
|
namespace?: string;
|
|
22352
|
-
|
|
22353
|
-
content
|
|
22426
|
+
partial?: {
|
|
22427
|
+
content?: ({
|
|
22354
22428
|
type: "text";
|
|
22355
22429
|
text: string;
|
|
22356
22430
|
textSignature?: string;
|
|
@@ -22360,9 +22434,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22360
22434
|
mimeType: string;
|
|
22361
22435
|
})[];
|
|
22362
22436
|
details?: any;
|
|
22363
|
-
isError: false;
|
|
22364
22437
|
};
|
|
22365
|
-
status: "
|
|
22438
|
+
status: "running";
|
|
22366
22439
|
thoughtSignature?: string;
|
|
22367
22440
|
time: {
|
|
22368
22441
|
start: number;
|
|
@@ -22386,9 +22459,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22386
22459
|
mimeType: string;
|
|
22387
22460
|
})[];
|
|
22388
22461
|
details?: any;
|
|
22389
|
-
isError:
|
|
22462
|
+
isError: false;
|
|
22390
22463
|
};
|
|
22391
|
-
status: "
|
|
22464
|
+
status: "completed";
|
|
22392
22465
|
thoughtSignature?: string;
|
|
22393
22466
|
time: {
|
|
22394
22467
|
start: number;
|
|
@@ -22414,7 +22487,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22414
22487
|
details?: any;
|
|
22415
22488
|
isError: true;
|
|
22416
22489
|
};
|
|
22417
|
-
status: "
|
|
22490
|
+
status: "error";
|
|
22418
22491
|
thoughtSignature?: string;
|
|
22419
22492
|
time: {
|
|
22420
22493
|
start: number;
|
|
@@ -22440,26 +22513,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22440
22513
|
details?: any;
|
|
22441
22514
|
isError: true;
|
|
22442
22515
|
};
|
|
22443
|
-
status: "
|
|
22516
|
+
status: "skipped";
|
|
22444
22517
|
thoughtSignature?: string;
|
|
22445
22518
|
time: {
|
|
22446
22519
|
start: number;
|
|
22447
22520
|
end: number;
|
|
22448
22521
|
};
|
|
22449
22522
|
type: "toolCall";
|
|
22450
|
-
} | {
|
|
22451
|
-
type: "thinking";
|
|
22452
|
-
thinking: string;
|
|
22453
|
-
thinkingSignature?: string;
|
|
22454
|
-
redacted?: boolean;
|
|
22455
22523
|
} | {
|
|
22456
22524
|
addedToolNames?: string[];
|
|
22457
22525
|
arguments: Record<string, any>;
|
|
22458
22526
|
callID: string;
|
|
22459
22527
|
name: string;
|
|
22460
22528
|
namespace?: string;
|
|
22461
|
-
|
|
22462
|
-
content
|
|
22529
|
+
result: {
|
|
22530
|
+
content: ({
|
|
22463
22531
|
type: "text";
|
|
22464
22532
|
text: string;
|
|
22465
22533
|
textSignature?: string;
|
|
@@ -22469,8 +22537,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22469
22537
|
mimeType: string;
|
|
22470
22538
|
})[];
|
|
22471
22539
|
details?: any;
|
|
22540
|
+
isError: true;
|
|
22472
22541
|
};
|
|
22473
|
-
status: "
|
|
22542
|
+
status: "aborted";
|
|
22474
22543
|
thoughtSignature?: string;
|
|
22475
22544
|
time: {
|
|
22476
22545
|
start: number;
|
|
@@ -22664,14 +22733,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22664
22733
|
type: "image";
|
|
22665
22734
|
data: string;
|
|
22666
22735
|
mimeType: string;
|
|
22736
|
+
} | {
|
|
22737
|
+
type: "thinking";
|
|
22738
|
+
thinking: string;
|
|
22739
|
+
thinkingSignature?: string;
|
|
22740
|
+
redacted?: boolean;
|
|
22667
22741
|
} | {
|
|
22668
22742
|
addedToolNames?: string[];
|
|
22669
22743
|
arguments: Record<string, any>;
|
|
22670
22744
|
callID: string;
|
|
22671
22745
|
name: string;
|
|
22672
22746
|
namespace?: string;
|
|
22673
|
-
|
|
22674
|
-
content
|
|
22747
|
+
partial?: {
|
|
22748
|
+
content?: ({
|
|
22675
22749
|
type: "text";
|
|
22676
22750
|
text: string;
|
|
22677
22751
|
textSignature?: string;
|
|
@@ -22681,9 +22755,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22681
22755
|
mimeType: string;
|
|
22682
22756
|
})[];
|
|
22683
22757
|
details?: any;
|
|
22684
|
-
isError: false;
|
|
22685
22758
|
};
|
|
22686
|
-
status: "
|
|
22759
|
+
status: "running";
|
|
22687
22760
|
thoughtSignature?: string;
|
|
22688
22761
|
time: {
|
|
22689
22762
|
start: number;
|
|
@@ -22707,9 +22780,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22707
22780
|
mimeType: string;
|
|
22708
22781
|
})[];
|
|
22709
22782
|
details?: any;
|
|
22710
|
-
isError:
|
|
22783
|
+
isError: false;
|
|
22711
22784
|
};
|
|
22712
|
-
status: "
|
|
22785
|
+
status: "completed";
|
|
22713
22786
|
thoughtSignature?: string;
|
|
22714
22787
|
time: {
|
|
22715
22788
|
start: number;
|
|
@@ -22735,7 +22808,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22735
22808
|
details?: any;
|
|
22736
22809
|
isError: true;
|
|
22737
22810
|
};
|
|
22738
|
-
status: "
|
|
22811
|
+
status: "error";
|
|
22739
22812
|
thoughtSignature?: string;
|
|
22740
22813
|
time: {
|
|
22741
22814
|
start: number;
|
|
@@ -22761,26 +22834,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22761
22834
|
details?: any;
|
|
22762
22835
|
isError: true;
|
|
22763
22836
|
};
|
|
22764
|
-
status: "
|
|
22837
|
+
status: "skipped";
|
|
22765
22838
|
thoughtSignature?: string;
|
|
22766
22839
|
time: {
|
|
22767
22840
|
start: number;
|
|
22768
22841
|
end: number;
|
|
22769
22842
|
};
|
|
22770
22843
|
type: "toolCall";
|
|
22771
|
-
} | {
|
|
22772
|
-
type: "thinking";
|
|
22773
|
-
thinking: string;
|
|
22774
|
-
thinkingSignature?: string;
|
|
22775
|
-
redacted?: boolean;
|
|
22776
22844
|
} | {
|
|
22777
22845
|
addedToolNames?: string[];
|
|
22778
22846
|
arguments: Record<string, any>;
|
|
22779
22847
|
callID: string;
|
|
22780
22848
|
name: string;
|
|
22781
22849
|
namespace?: string;
|
|
22782
|
-
|
|
22783
|
-
content
|
|
22850
|
+
result: {
|
|
22851
|
+
content: ({
|
|
22784
22852
|
type: "text";
|
|
22785
22853
|
text: string;
|
|
22786
22854
|
textSignature?: string;
|
|
@@ -22790,8 +22858,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22790
22858
|
mimeType: string;
|
|
22791
22859
|
})[];
|
|
22792
22860
|
details?: any;
|
|
22861
|
+
isError: true;
|
|
22793
22862
|
};
|
|
22794
|
-
status: "
|
|
22863
|
+
status: "aborted";
|
|
22795
22864
|
thoughtSignature?: string;
|
|
22796
22865
|
time: {
|
|
22797
22866
|
start: number;
|
|
@@ -22966,14 +23035,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22966
23035
|
type: "image";
|
|
22967
23036
|
data: string;
|
|
22968
23037
|
mimeType: string;
|
|
23038
|
+
} | {
|
|
23039
|
+
type: "thinking";
|
|
23040
|
+
thinking: string;
|
|
23041
|
+
thinkingSignature?: string;
|
|
23042
|
+
redacted?: boolean;
|
|
22969
23043
|
} | {
|
|
22970
23044
|
addedToolNames?: string[];
|
|
22971
23045
|
arguments: Record<string, any>;
|
|
22972
23046
|
callID: string;
|
|
22973
23047
|
name: string;
|
|
22974
23048
|
namespace?: string;
|
|
22975
|
-
|
|
22976
|
-
content
|
|
23049
|
+
partial?: {
|
|
23050
|
+
content?: ({
|
|
22977
23051
|
type: "text";
|
|
22978
23052
|
text: string;
|
|
22979
23053
|
textSignature?: string;
|
|
@@ -22983,9 +23057,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
22983
23057
|
mimeType: string;
|
|
22984
23058
|
})[];
|
|
22985
23059
|
details?: any;
|
|
22986
|
-
isError: false;
|
|
22987
23060
|
};
|
|
22988
|
-
status: "
|
|
23061
|
+
status: "running";
|
|
22989
23062
|
thoughtSignature?: string;
|
|
22990
23063
|
time: {
|
|
22991
23064
|
start: number;
|
|
@@ -23009,9 +23082,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23009
23082
|
mimeType: string;
|
|
23010
23083
|
})[];
|
|
23011
23084
|
details?: any;
|
|
23012
|
-
isError:
|
|
23085
|
+
isError: false;
|
|
23013
23086
|
};
|
|
23014
|
-
status: "
|
|
23087
|
+
status: "completed";
|
|
23015
23088
|
thoughtSignature?: string;
|
|
23016
23089
|
time: {
|
|
23017
23090
|
start: number;
|
|
@@ -23037,7 +23110,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23037
23110
|
details?: any;
|
|
23038
23111
|
isError: true;
|
|
23039
23112
|
};
|
|
23040
|
-
status: "
|
|
23113
|
+
status: "error";
|
|
23041
23114
|
thoughtSignature?: string;
|
|
23042
23115
|
time: {
|
|
23043
23116
|
start: number;
|
|
@@ -23063,26 +23136,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23063
23136
|
details?: any;
|
|
23064
23137
|
isError: true;
|
|
23065
23138
|
};
|
|
23066
|
-
status: "
|
|
23139
|
+
status: "skipped";
|
|
23067
23140
|
thoughtSignature?: string;
|
|
23068
23141
|
time: {
|
|
23069
23142
|
start: number;
|
|
23070
23143
|
end: number;
|
|
23071
23144
|
};
|
|
23072
23145
|
type: "toolCall";
|
|
23073
|
-
} | {
|
|
23074
|
-
type: "thinking";
|
|
23075
|
-
thinking: string;
|
|
23076
|
-
thinkingSignature?: string;
|
|
23077
|
-
redacted?: boolean;
|
|
23078
23146
|
} | {
|
|
23079
23147
|
addedToolNames?: string[];
|
|
23080
23148
|
arguments: Record<string, any>;
|
|
23081
23149
|
callID: string;
|
|
23082
23150
|
name: string;
|
|
23083
23151
|
namespace?: string;
|
|
23084
|
-
|
|
23085
|
-
content
|
|
23152
|
+
result: {
|
|
23153
|
+
content: ({
|
|
23086
23154
|
type: "text";
|
|
23087
23155
|
text: string;
|
|
23088
23156
|
textSignature?: string;
|
|
@@ -23092,8 +23160,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23092
23160
|
mimeType: string;
|
|
23093
23161
|
})[];
|
|
23094
23162
|
details?: any;
|
|
23163
|
+
isError: true;
|
|
23095
23164
|
};
|
|
23096
|
-
status: "
|
|
23165
|
+
status: "aborted";
|
|
23097
23166
|
thoughtSignature?: string;
|
|
23098
23167
|
time: {
|
|
23099
23168
|
start: number;
|
|
@@ -23296,14 +23365,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23296
23365
|
type: "image";
|
|
23297
23366
|
data: string;
|
|
23298
23367
|
mimeType: string;
|
|
23368
|
+
} | {
|
|
23369
|
+
type: "thinking";
|
|
23370
|
+
thinking: string;
|
|
23371
|
+
thinkingSignature?: string;
|
|
23372
|
+
redacted?: boolean;
|
|
23299
23373
|
} | {
|
|
23300
23374
|
addedToolNames?: string[];
|
|
23301
23375
|
arguments: Record<string, any>;
|
|
23302
23376
|
callID: string;
|
|
23303
23377
|
name: string;
|
|
23304
23378
|
namespace?: string;
|
|
23305
|
-
|
|
23306
|
-
content
|
|
23379
|
+
partial?: {
|
|
23380
|
+
content?: ({
|
|
23307
23381
|
type: "text";
|
|
23308
23382
|
text: string;
|
|
23309
23383
|
textSignature?: string;
|
|
@@ -23313,9 +23387,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23313
23387
|
mimeType: string;
|
|
23314
23388
|
})[];
|
|
23315
23389
|
details?: any;
|
|
23316
|
-
isError: false;
|
|
23317
23390
|
};
|
|
23318
|
-
status: "
|
|
23391
|
+
status: "running";
|
|
23319
23392
|
thoughtSignature?: string;
|
|
23320
23393
|
time: {
|
|
23321
23394
|
start: number;
|
|
@@ -23339,9 +23412,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23339
23412
|
mimeType: string;
|
|
23340
23413
|
})[];
|
|
23341
23414
|
details?: any;
|
|
23342
|
-
isError:
|
|
23415
|
+
isError: false;
|
|
23343
23416
|
};
|
|
23344
|
-
status: "
|
|
23417
|
+
status: "completed";
|
|
23345
23418
|
thoughtSignature?: string;
|
|
23346
23419
|
time: {
|
|
23347
23420
|
start: number;
|
|
@@ -23367,7 +23440,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23367
23440
|
details?: any;
|
|
23368
23441
|
isError: true;
|
|
23369
23442
|
};
|
|
23370
|
-
status: "
|
|
23443
|
+
status: "error";
|
|
23371
23444
|
thoughtSignature?: string;
|
|
23372
23445
|
time: {
|
|
23373
23446
|
start: number;
|
|
@@ -23393,26 +23466,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23393
23466
|
details?: any;
|
|
23394
23467
|
isError: true;
|
|
23395
23468
|
};
|
|
23396
|
-
status: "
|
|
23469
|
+
status: "skipped";
|
|
23397
23470
|
thoughtSignature?: string;
|
|
23398
23471
|
time: {
|
|
23399
23472
|
start: number;
|
|
23400
23473
|
end: number;
|
|
23401
23474
|
};
|
|
23402
23475
|
type: "toolCall";
|
|
23403
|
-
} | {
|
|
23404
|
-
type: "thinking";
|
|
23405
|
-
thinking: string;
|
|
23406
|
-
thinkingSignature?: string;
|
|
23407
|
-
redacted?: boolean;
|
|
23408
23476
|
} | {
|
|
23409
23477
|
addedToolNames?: string[];
|
|
23410
23478
|
arguments: Record<string, any>;
|
|
23411
23479
|
callID: string;
|
|
23412
23480
|
name: string;
|
|
23413
23481
|
namespace?: string;
|
|
23414
|
-
|
|
23415
|
-
content
|
|
23482
|
+
result: {
|
|
23483
|
+
content: ({
|
|
23416
23484
|
type: "text";
|
|
23417
23485
|
text: string;
|
|
23418
23486
|
textSignature?: string;
|
|
@@ -23422,8 +23490,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23422
23490
|
mimeType: string;
|
|
23423
23491
|
})[];
|
|
23424
23492
|
details?: any;
|
|
23493
|
+
isError: true;
|
|
23425
23494
|
};
|
|
23426
|
-
status: "
|
|
23495
|
+
status: "aborted";
|
|
23427
23496
|
thoughtSignature?: string;
|
|
23428
23497
|
time: {
|
|
23429
23498
|
start: number;
|
|
@@ -23598,14 +23667,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23598
23667
|
type: "image";
|
|
23599
23668
|
data: string;
|
|
23600
23669
|
mimeType: string;
|
|
23670
|
+
} | {
|
|
23671
|
+
type: "thinking";
|
|
23672
|
+
thinking: string;
|
|
23673
|
+
thinkingSignature?: string;
|
|
23674
|
+
redacted?: boolean;
|
|
23601
23675
|
} | {
|
|
23602
23676
|
addedToolNames?: string[];
|
|
23603
23677
|
arguments: Record<string, any>;
|
|
23604
23678
|
callID: string;
|
|
23605
23679
|
name: string;
|
|
23606
23680
|
namespace?: string;
|
|
23607
|
-
|
|
23608
|
-
content
|
|
23681
|
+
partial?: {
|
|
23682
|
+
content?: ({
|
|
23609
23683
|
type: "text";
|
|
23610
23684
|
text: string;
|
|
23611
23685
|
textSignature?: string;
|
|
@@ -23615,9 +23689,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23615
23689
|
mimeType: string;
|
|
23616
23690
|
})[];
|
|
23617
23691
|
details?: any;
|
|
23618
|
-
isError: false;
|
|
23619
23692
|
};
|
|
23620
|
-
status: "
|
|
23693
|
+
status: "running";
|
|
23621
23694
|
thoughtSignature?: string;
|
|
23622
23695
|
time: {
|
|
23623
23696
|
start: number;
|
|
@@ -23641,9 +23714,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23641
23714
|
mimeType: string;
|
|
23642
23715
|
})[];
|
|
23643
23716
|
details?: any;
|
|
23644
|
-
isError:
|
|
23717
|
+
isError: false;
|
|
23645
23718
|
};
|
|
23646
|
-
status: "
|
|
23719
|
+
status: "completed";
|
|
23647
23720
|
thoughtSignature?: string;
|
|
23648
23721
|
time: {
|
|
23649
23722
|
start: number;
|
|
@@ -23669,7 +23742,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23669
23742
|
details?: any;
|
|
23670
23743
|
isError: true;
|
|
23671
23744
|
};
|
|
23672
|
-
status: "
|
|
23745
|
+
status: "error";
|
|
23673
23746
|
thoughtSignature?: string;
|
|
23674
23747
|
time: {
|
|
23675
23748
|
start: number;
|
|
@@ -23695,26 +23768,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23695
23768
|
details?: any;
|
|
23696
23769
|
isError: true;
|
|
23697
23770
|
};
|
|
23698
|
-
status: "
|
|
23771
|
+
status: "skipped";
|
|
23699
23772
|
thoughtSignature?: string;
|
|
23700
23773
|
time: {
|
|
23701
23774
|
start: number;
|
|
23702
23775
|
end: number;
|
|
23703
23776
|
};
|
|
23704
23777
|
type: "toolCall";
|
|
23705
|
-
} | {
|
|
23706
|
-
type: "thinking";
|
|
23707
|
-
thinking: string;
|
|
23708
|
-
thinkingSignature?: string;
|
|
23709
|
-
redacted?: boolean;
|
|
23710
23778
|
} | {
|
|
23711
23779
|
addedToolNames?: string[];
|
|
23712
23780
|
arguments: Record<string, any>;
|
|
23713
23781
|
callID: string;
|
|
23714
23782
|
name: string;
|
|
23715
23783
|
namespace?: string;
|
|
23716
|
-
|
|
23717
|
-
content
|
|
23784
|
+
result: {
|
|
23785
|
+
content: ({
|
|
23718
23786
|
type: "text";
|
|
23719
23787
|
text: string;
|
|
23720
23788
|
textSignature?: string;
|
|
@@ -23724,8 +23792,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23724
23792
|
mimeType: string;
|
|
23725
23793
|
})[];
|
|
23726
23794
|
details?: any;
|
|
23795
|
+
isError: true;
|
|
23727
23796
|
};
|
|
23728
|
-
status: "
|
|
23797
|
+
status: "aborted";
|
|
23729
23798
|
thoughtSignature?: string;
|
|
23730
23799
|
time: {
|
|
23731
23800
|
start: number;
|
|
@@ -23919,14 +23988,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23919
23988
|
type: "image";
|
|
23920
23989
|
data: string;
|
|
23921
23990
|
mimeType: string;
|
|
23991
|
+
} | {
|
|
23992
|
+
type: "thinking";
|
|
23993
|
+
thinking: string;
|
|
23994
|
+
thinkingSignature?: string;
|
|
23995
|
+
redacted?: boolean;
|
|
23922
23996
|
} | {
|
|
23923
23997
|
addedToolNames?: string[];
|
|
23924
23998
|
arguments: Record<string, any>;
|
|
23925
23999
|
callID: string;
|
|
23926
24000
|
name: string;
|
|
23927
24001
|
namespace?: string;
|
|
23928
|
-
|
|
23929
|
-
content
|
|
24002
|
+
partial?: {
|
|
24003
|
+
content?: ({
|
|
23930
24004
|
type: "text";
|
|
23931
24005
|
text: string;
|
|
23932
24006
|
textSignature?: string;
|
|
@@ -23936,9 +24010,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23936
24010
|
mimeType: string;
|
|
23937
24011
|
})[];
|
|
23938
24012
|
details?: any;
|
|
23939
|
-
isError: false;
|
|
23940
24013
|
};
|
|
23941
|
-
status: "
|
|
24014
|
+
status: "running";
|
|
23942
24015
|
thoughtSignature?: string;
|
|
23943
24016
|
time: {
|
|
23944
24017
|
start: number;
|
|
@@ -23962,9 +24035,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23962
24035
|
mimeType: string;
|
|
23963
24036
|
})[];
|
|
23964
24037
|
details?: any;
|
|
23965
|
-
isError:
|
|
24038
|
+
isError: false;
|
|
23966
24039
|
};
|
|
23967
|
-
status: "
|
|
24040
|
+
status: "completed";
|
|
23968
24041
|
thoughtSignature?: string;
|
|
23969
24042
|
time: {
|
|
23970
24043
|
start: number;
|
|
@@ -23990,7 +24063,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
23990
24063
|
details?: any;
|
|
23991
24064
|
isError: true;
|
|
23992
24065
|
};
|
|
23993
|
-
status: "
|
|
24066
|
+
status: "error";
|
|
23994
24067
|
thoughtSignature?: string;
|
|
23995
24068
|
time: {
|
|
23996
24069
|
start: number;
|
|
@@ -24016,26 +24089,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24016
24089
|
details?: any;
|
|
24017
24090
|
isError: true;
|
|
24018
24091
|
};
|
|
24019
|
-
status: "
|
|
24092
|
+
status: "skipped";
|
|
24020
24093
|
thoughtSignature?: string;
|
|
24021
24094
|
time: {
|
|
24022
24095
|
start: number;
|
|
24023
24096
|
end: number;
|
|
24024
24097
|
};
|
|
24025
24098
|
type: "toolCall";
|
|
24026
|
-
} | {
|
|
24027
|
-
type: "thinking";
|
|
24028
|
-
thinking: string;
|
|
24029
|
-
thinkingSignature?: string;
|
|
24030
|
-
redacted?: boolean;
|
|
24031
24099
|
} | {
|
|
24032
24100
|
addedToolNames?: string[];
|
|
24033
24101
|
arguments: Record<string, any>;
|
|
24034
24102
|
callID: string;
|
|
24035
24103
|
name: string;
|
|
24036
24104
|
namespace?: string;
|
|
24037
|
-
|
|
24038
|
-
content
|
|
24105
|
+
result: {
|
|
24106
|
+
content: ({
|
|
24039
24107
|
type: "text";
|
|
24040
24108
|
text: string;
|
|
24041
24109
|
textSignature?: string;
|
|
@@ -24045,8 +24113,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24045
24113
|
mimeType: string;
|
|
24046
24114
|
})[];
|
|
24047
24115
|
details?: any;
|
|
24116
|
+
isError: true;
|
|
24048
24117
|
};
|
|
24049
|
-
status: "
|
|
24118
|
+
status: "aborted";
|
|
24050
24119
|
thoughtSignature?: string;
|
|
24051
24120
|
time: {
|
|
24052
24121
|
start: number;
|
|
@@ -24221,14 +24290,19 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24221
24290
|
type: "image";
|
|
24222
24291
|
data: string;
|
|
24223
24292
|
mimeType: string;
|
|
24293
|
+
} | {
|
|
24294
|
+
type: "thinking";
|
|
24295
|
+
thinking: string;
|
|
24296
|
+
thinkingSignature?: string;
|
|
24297
|
+
redacted?: boolean;
|
|
24224
24298
|
} | {
|
|
24225
24299
|
addedToolNames?: string[];
|
|
24226
24300
|
arguments: Record<string, any>;
|
|
24227
24301
|
callID: string;
|
|
24228
24302
|
name: string;
|
|
24229
24303
|
namespace?: string;
|
|
24230
|
-
|
|
24231
|
-
content
|
|
24304
|
+
partial?: {
|
|
24305
|
+
content?: ({
|
|
24232
24306
|
type: "text";
|
|
24233
24307
|
text: string;
|
|
24234
24308
|
textSignature?: string;
|
|
@@ -24238,9 +24312,8 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24238
24312
|
mimeType: string;
|
|
24239
24313
|
})[];
|
|
24240
24314
|
details?: any;
|
|
24241
|
-
isError: false;
|
|
24242
24315
|
};
|
|
24243
|
-
status: "
|
|
24316
|
+
status: "running";
|
|
24244
24317
|
thoughtSignature?: string;
|
|
24245
24318
|
time: {
|
|
24246
24319
|
start: number;
|
|
@@ -24264,9 +24337,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24264
24337
|
mimeType: string;
|
|
24265
24338
|
})[];
|
|
24266
24339
|
details?: any;
|
|
24267
|
-
isError:
|
|
24340
|
+
isError: false;
|
|
24268
24341
|
};
|
|
24269
|
-
status: "
|
|
24342
|
+
status: "completed";
|
|
24270
24343
|
thoughtSignature?: string;
|
|
24271
24344
|
time: {
|
|
24272
24345
|
start: number;
|
|
@@ -24292,7 +24365,7 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24292
24365
|
details?: any;
|
|
24293
24366
|
isError: true;
|
|
24294
24367
|
};
|
|
24295
|
-
status: "
|
|
24368
|
+
status: "error";
|
|
24296
24369
|
thoughtSignature?: string;
|
|
24297
24370
|
time: {
|
|
24298
24371
|
start: number;
|
|
@@ -24318,26 +24391,21 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24318
24391
|
details?: any;
|
|
24319
24392
|
isError: true;
|
|
24320
24393
|
};
|
|
24321
|
-
status: "
|
|
24394
|
+
status: "skipped";
|
|
24322
24395
|
thoughtSignature?: string;
|
|
24323
24396
|
time: {
|
|
24324
24397
|
start: number;
|
|
24325
24398
|
end: number;
|
|
24326
24399
|
};
|
|
24327
24400
|
type: "toolCall";
|
|
24328
|
-
} | {
|
|
24329
|
-
type: "thinking";
|
|
24330
|
-
thinking: string;
|
|
24331
|
-
thinkingSignature?: string;
|
|
24332
|
-
redacted?: boolean;
|
|
24333
24401
|
} | {
|
|
24334
24402
|
addedToolNames?: string[];
|
|
24335
24403
|
arguments: Record<string, any>;
|
|
24336
24404
|
callID: string;
|
|
24337
24405
|
name: string;
|
|
24338
24406
|
namespace?: string;
|
|
24339
|
-
|
|
24340
|
-
content
|
|
24407
|
+
result: {
|
|
24408
|
+
content: ({
|
|
24341
24409
|
type: "text";
|
|
24342
24410
|
text: string;
|
|
24343
24411
|
textSignature?: string;
|
|
@@ -24347,8 +24415,9 @@ declare const DurableDefinitions: readonly [Schema.Struct<{
|
|
|
24347
24415
|
mimeType: string;
|
|
24348
24416
|
})[];
|
|
24349
24417
|
details?: any;
|
|
24418
|
+
isError: true;
|
|
24350
24419
|
};
|
|
24351
|
-
status: "
|
|
24420
|
+
status: "aborted";
|
|
24352
24421
|
thoughtSignature?: string;
|
|
24353
24422
|
time: {
|
|
24354
24423
|
start: number;
|
|
@@ -25063,5 +25132,5 @@ type DateTimeUtcFromMillis = import__codeworksh_plugin_schema.DateTimeUtcFromMil
|
|
|
25063
25132
|
type EventSchema = import__codeworksh_plugin_event.EventSchema;
|
|
25064
25133
|
type SandboxError = import__codeworksh_plugin_sandbox_errors.SandboxError;
|
|
25065
25134
|
type optional = import__codeworksh_plugin_schema.optional;
|
|
25066
|
-
export { control_d_exports as Control, db_d_exports as Database, DateTimeUtcFromMillis, event_d_exports as Event, list_d_exports as EventList, registry_d_exports as EventRegistry, EventSchema, global_d_exports as Global, harness_d_exports as Harness, location_d_exports as Location, catalog_d_exports as ModelCatalog, index_d_exports as Plugin, schema_d_exports as PromptSchema, run_d_exports as Runner, sandbox_d_exports as Sandbox, SandboxError, session_d_exports as Session, session_d_exports$1 as SessionStore, settings_d_exports as Settings, state_d_exports as State, tool_d_exports as Tool, optional };
|
|
25135
|
+
export { control_d_exports as Control, db_d_exports as Database, DateTimeUtcFromMillis, event_d_exports as Event, list_d_exports as EventList, registry_d_exports as EventRegistry, EventSchema, global_d_exports as Global, harness_d_exports as Harness, location_d_exports as Location, catalog_d_exports as ModelCatalog, index_d_exports as Plugin, project_d_exports as Project, schema_d_exports as PromptSchema, run_d_exports as Runner, sandbox_d_exports as Sandbox, SandboxError, session_d_exports as Session, session_d_exports$1 as SessionStore, settings_d_exports as Settings, state_d_exports as State, tool_d_exports as Tool, optional };
|
|
25067
25136
|
//# sourceMappingURL=effect.d.mts.map
|