@codeworksh/harness 0.3.0 → 0.4.0-dev.20261020131429

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/effect.d.mts 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 ["missing", "unreadable", "empty", "invalid"]>;
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
- result: {
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: "completed";
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: true;
2933
+ isError: false;
2926
2934
  };
2927
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- }) => Effect.Effect<EncodedMessage, ContextEncodeError, never>;
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
- }, ContextDecodeError, never>;
3051
- declare const decodeMessage: (hydrated: HydratedEntry) => Effect.Effect<{
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
- result: {
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: "completed";
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: true;
3267
+ isError: false;
3260
3268
  };
3261
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
4926
+ isError: false;
4854
4927
  };
4855
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
5228
+ isError: false;
5156
5229
  };
5157
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
5548
+ isError: false;
5476
5549
  };
5477
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
5850
+ isError: false;
5778
5851
  };
5779
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- addedToolNames?: string[];
6359
- arguments: Record<string, any>;
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
- result: {
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: "completed";
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: true;
6473
+ isError: false;
6401
6474
  };
6402
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
6775
+ isError: false;
6703
6776
  };
6704
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
7096
+ isError: false;
7024
7097
  };
7025
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
7398
+ isError: false;
7326
7399
  };
7327
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
7731
+ isError: false;
7659
7732
  };
7660
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
8033
+ isError: false;
7961
8034
  };
7962
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
8354
+ isError: false;
8282
8355
  };
8283
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
8656
+ isError: false;
8584
8657
  };
8585
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
10531
+ isError: false;
10459
10532
  };
10460
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
10833
+ isError: false;
10761
10834
  };
10762
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
11153
+ isError: false;
11081
11154
  };
11082
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
11455
+ isError: false;
11383
11456
  };
11384
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12063
+ isError: false;
11991
12064
  };
11992
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12365
+ isError: false;
12293
12366
  };
12294
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12686
+ isError: false;
12614
12687
  };
12615
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
12988
+ isError: false;
12916
12989
  };
12917
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
13318
+ isError: false;
13246
13319
  };
13247
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
13620
+ isError: false;
13548
13621
  };
13549
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
13941
+ isError: false;
13869
13942
  };
13870
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
14243
+ isError: false;
14171
14244
  };
14172
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
15879
+ isError: false;
15807
15880
  };
15808
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
16181
+ isError: false;
16109
16182
  };
16110
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
16501
+ isError: false;
16429
16502
  };
16430
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
16803
+ isError: false;
16731
16804
  };
16732
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
17411
+ isError: false;
17339
17412
  };
17340
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
17713
+ isError: false;
17641
17714
  };
17642
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18034
+ isError: false;
17962
18035
  };
17963
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18336
+ isError: false;
18264
18337
  };
18265
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18666
+ isError: false;
18594
18667
  };
18595
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
18968
+ isError: false;
18896
18969
  };
18897
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
19289
+ isError: false;
19217
19290
  };
19218
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
19591
+ isError: false;
19519
19592
  };
19520
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
20906
+ isError: false;
20834
20907
  };
20835
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
21208
+ isError: false;
21136
21209
  };
21137
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
21528
+ isError: false;
21456
21529
  };
21457
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
21830
+ isError: false;
21758
21831
  };
21759
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
22160
+ isError: false;
22088
22161
  };
22089
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
22462
+ isError: false;
22390
22463
  };
22391
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
22783
+ isError: false;
22711
22784
  };
22712
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
23085
+ isError: false;
23013
23086
  };
23014
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
23415
+ isError: false;
23343
23416
  };
23344
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
23717
+ isError: false;
23645
23718
  };
23646
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
24038
+ isError: false;
23966
24039
  };
23967
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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
- result: {
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: "completed";
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: true;
24340
+ isError: false;
24268
24341
  };
24269
- status: "error";
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: "skipped";
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: "aborted";
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
- partial?: {
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: "running";
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