@opencode/schema 0.0.0-beta-19507 → 0.0.0-dev-19274

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.
Files changed (17) hide show
  1. package/dist/config/provider.d.ts +0 -2
  2. package/dist/config/provider.js +0 -6
  3. package/dist/config/worktree.js +1 -1
  4. package/dist/event-manifest.d.ts +416 -332
  5. package/dist/instruction-entry.js +1 -1
  6. package/dist/model.d.ts +0 -2
  7. package/dist/model.js +0 -2
  8. package/dist/provider.d.ts +0 -2
  9. package/dist/provider.js +0 -2
  10. package/dist/session-event.d.ts +754 -1378
  11. package/dist/session-event.js +3 -20
  12. package/dist/session-message.d.ts +0 -132
  13. package/dist/session-message.js +0 -7
  14. package/dist/session-transfer.d.ts +0 -53
  15. package/dist/session.d.ts +0 -10
  16. package/dist/session.js +0 -3
  17. package/package.json +1 -1
package/dist/session-event.d.ts CHANGED
@@ -113,15 +113,6 @@ export declare const Created: Schema.Struct<{
113
113
  }>, never, never>;
114
114
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
115
115
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
116
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
117
- readonly action: Schema.String;
118
- readonly resource: Schema.String;
119
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
120
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
121
- readonly action: Schema.String;
122
- readonly resource: Schema.String;
123
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
124
- }>>>, never, never>;
125
116
  readonly version: Schema.String;
126
117
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
127
118
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -207,15 +198,6 @@ export declare const Created: Schema.Struct<{
207
198
  }>, never, never>;
208
199
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
209
200
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
210
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
211
- readonly action: Schema.String;
212
- readonly resource: Schema.String;
213
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
214
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
215
- readonly action: Schema.String;
216
- readonly resource: Schema.String;
217
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
218
- }>>>, never, never>;
219
201
  readonly version: Schema.String;
220
202
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
221
203
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -602,68 +584,6 @@ export declare const Renamed: Schema.Struct<{
602
584
  }>;
603
585
  };
604
586
  export type Renamed = typeof Renamed.Type;
605
- export declare const PermissionsUpdated: Schema.Struct<{
606
- readonly id: Schema.brand<Schema.String, "Event.ID"> & {
607
- create: () => string & import("effect/Brand").Brand<"Event.ID">;
608
- };
609
- readonly created: Schema.Finite;
610
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
611
- readonly type: Schema.Literal<"session.permissions.updated">;
612
- readonly durable: Schema.Struct<{
613
- readonly aggregateID: Schema.String;
614
- readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
615
- readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
616
- }>;
617
- readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
618
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
619
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
620
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
621
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
622
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
623
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
624
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
625
- }>, never, never>;
626
- }>>>, Schema.optionalKey<Schema.Struct<{
627
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
628
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
629
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
630
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
631
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
632
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
633
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
634
- }>, never, never>;
635
- }>>, never, never>;
636
- readonly data: Schema.Struct<{
637
- readonly permissions: Schema.$Array<Schema.Struct<{
638
- readonly action: Schema.String;
639
- readonly resource: Schema.String;
640
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
641
- }>>;
642
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
643
- create: () => string & import("effect/Brand").Brand<"SessionID">;
644
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
645
- };
646
- }>;
647
- }> & {
648
- type: "session.permissions.updated";
649
- durability: "durable";
650
- durable: {
651
- readonly version: number;
652
- readonly aggregate: string;
653
- };
654
- data: Schema.Struct<{
655
- readonly permissions: Schema.$Array<Schema.Struct<{
656
- readonly action: Schema.String;
657
- readonly resource: Schema.String;
658
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
659
- }>>;
660
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
661
- create: () => string & import("effect/Brand").Brand<"SessionID">;
662
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
663
- };
664
- }>;
665
- };
666
- export type PermissionsUpdated = typeof PermissionsUpdated.Type;
667
587
  export declare const Viewed: Schema.Struct<{
668
588
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
669
589
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -4003,28 +3923,6 @@ export declare namespace Compaction {
4003
3923
  }>>, never, never>;
4004
3924
  readonly text: Schema.String;
4005
3925
  readonly recent: Schema.String;
4006
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
4007
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4008
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
4009
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4010
- }>, never, never>;
4011
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4012
- readonly input: Schema.Finite;
4013
- readonly output: Schema.Finite;
4014
- readonly reasoning: Schema.Finite;
4015
- readonly cache: Schema.Struct<{
4016
- readonly read: Schema.Finite;
4017
- readonly write: Schema.Finite;
4018
- }>;
4019
- }>>>, Schema.optionalKey<Schema.Struct<{
4020
- readonly input: Schema.Finite;
4021
- readonly output: Schema.Finite;
4022
- readonly reasoning: Schema.Finite;
4023
- readonly cache: Schema.Struct<{
4024
- readonly read: Schema.Finite;
4025
- readonly write: Schema.Finite;
4026
- }>;
4027
- }>>, never, never>;
4028
3926
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4029
3927
  create: () => string & import("effect/Brand").Brand<"SessionID">;
4030
3928
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -4134,28 +4032,6 @@ export declare namespace Compaction {
4134
4032
  }>>, never, never>;
4135
4033
  readonly text: Schema.String;
4136
4034
  readonly recent: Schema.String;
4137
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
4138
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4139
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
4140
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4141
- }>, never, never>;
4142
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4143
- readonly input: Schema.Finite;
4144
- readonly output: Schema.Finite;
4145
- readonly reasoning: Schema.Finite;
4146
- readonly cache: Schema.Struct<{
4147
- readonly read: Schema.Finite;
4148
- readonly write: Schema.Finite;
4149
- }>;
4150
- }>>>, Schema.optionalKey<Schema.Struct<{
4151
- readonly input: Schema.Finite;
4152
- readonly output: Schema.Finite;
4153
- readonly reasoning: Schema.Finite;
4154
- readonly cache: Schema.Struct<{
4155
- readonly read: Schema.Finite;
4156
- readonly write: Schema.Finite;
4157
- }>;
4158
- }>>, never, never>;
4159
4035
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4160
4036
  create: () => string & import("effect/Brand").Brand<"SessionID">;
4161
4037
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -4208,28 +4084,6 @@ export declare namespace Compaction {
4208
4084
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
4209
4085
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
4210
4086
  }>, never, never>;
4211
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
4212
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4213
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
4214
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4215
- }>, never, never>;
4216
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4217
- readonly input: Schema.Finite;
4218
- readonly output: Schema.Finite;
4219
- readonly reasoning: Schema.Finite;
4220
- readonly cache: Schema.Struct<{
4221
- readonly read: Schema.Finite;
4222
- readonly write: Schema.Finite;
4223
- }>;
4224
- }>>>, Schema.optionalKey<Schema.Struct<{
4225
- readonly input: Schema.Finite;
4226
- readonly output: Schema.Finite;
4227
- readonly reasoning: Schema.Finite;
4228
- readonly cache: Schema.Struct<{
4229
- readonly read: Schema.Finite;
4230
- readonly write: Schema.Finite;
4231
- }>;
4232
- }>>, never, never>;
4233
4087
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4234
4088
  create: () => string & import("effect/Brand").Brand<"SessionID">;
4235
4089
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -4256,28 +4110,6 @@ export declare namespace Compaction {
4256
4110
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
4257
4111
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
4258
4112
  }>, never, never>;
4259
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
4260
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4261
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
4262
- zero: number & import("effect/Brand").Brand<"Money.USD">;
4263
- }>, never, never>;
4264
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4265
- readonly input: Schema.Finite;
4266
- readonly output: Schema.Finite;
4267
- readonly reasoning: Schema.Finite;
4268
- readonly cache: Schema.Struct<{
4269
- readonly read: Schema.Finite;
4270
- readonly write: Schema.Finite;
4271
- }>;
4272
- }>>>, Schema.optionalKey<Schema.Struct<{
4273
- readonly input: Schema.Finite;
4274
- readonly output: Schema.Finite;
4275
- readonly reasoning: Schema.Finite;
4276
- readonly cache: Schema.Struct<{
4277
- readonly read: Schema.Finite;
4278
- readonly write: Schema.Finite;
4279
- }>;
4280
- }>>, never, never>;
4281
4113
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4282
4114
  create: () => string & import("effect/Brand").Brand<"SessionID">;
4283
4115
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -4594,15 +4426,6 @@ export declare const Definitions: readonly [Schema.Struct<{
4594
4426
  }>, never, never>;
4595
4427
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
4596
4428
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
4597
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
4598
- readonly action: Schema.String;
4599
- readonly resource: Schema.String;
4600
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
4601
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
4602
- readonly action: Schema.String;
4603
- readonly resource: Schema.String;
4604
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
4605
- }>>>, never, never>;
4606
4429
  readonly version: Schema.String;
4607
4430
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4608
4431
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -4688,15 +4511,6 @@ export declare const Definitions: readonly [Schema.Struct<{
4688
4511
  }>, never, never>;
4689
4512
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
4690
4513
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
4691
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
4692
- readonly action: Schema.String;
4693
- readonly resource: Schema.String;
4694
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
4695
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
4696
- readonly action: Schema.String;
4697
- readonly resource: Schema.String;
4698
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
4699
- }>>>, never, never>;
4700
4514
  readonly version: Schema.String;
4701
4515
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4702
4516
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -5073,66 +4887,6 @@ export declare const Definitions: readonly [Schema.Struct<{
5073
4887
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5074
4888
  };
5075
4889
  }>;
5076
- }, Schema.Struct<{
5077
- readonly id: Schema.brand<Schema.String, "Event.ID"> & {
5078
- create: () => string & import("effect/Brand").Brand<"Event.ID">;
5079
- };
5080
- readonly created: Schema.Finite;
5081
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
5082
- readonly type: Schema.Literal<"session.permissions.updated">;
5083
- readonly durable: Schema.Struct<{
5084
- readonly aggregateID: Schema.String;
5085
- readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5086
- readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5087
- }>;
5088
- readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
5089
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
5090
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
5091
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
5092
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
5093
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
5094
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
5095
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
5096
- }>, never, never>;
5097
- }>>>, Schema.optionalKey<Schema.Struct<{
5098
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
5099
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
5100
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
5101
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
5102
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
5103
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
5104
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
5105
- }>, never, never>;
5106
- }>>, never, never>;
5107
- readonly data: Schema.Struct<{
5108
- readonly permissions: Schema.$Array<Schema.Struct<{
5109
- readonly action: Schema.String;
5110
- readonly resource: Schema.String;
5111
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
5112
- }>>;
5113
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5114
- create: () => string & import("effect/Brand").Brand<"SessionID">;
5115
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5116
- };
5117
- }>;
5118
- }> & {
5119
- type: "session.permissions.updated";
5120
- durability: "durable";
5121
- durable: {
5122
- readonly version: number;
5123
- readonly aggregate: string;
5124
- };
5125
- data: Schema.Struct<{
5126
- readonly permissions: Schema.$Array<Schema.Struct<{
5127
- readonly action: Schema.String;
5128
- readonly resource: Schema.String;
5129
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
5130
- }>>;
5131
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5132
- create: () => string & import("effect/Brand").Brand<"SessionID">;
5133
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5134
- };
5135
- }>;
5136
4890
  }, Schema.Struct<{
5137
4891
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
5138
4892
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
@@ -8085,28 +7839,6 @@ export declare const Definitions: readonly [Schema.Struct<{
8085
7839
  }>>, never, never>;
8086
7840
  readonly text: Schema.String;
8087
7841
  readonly recent: Schema.String;
8088
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
8089
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8090
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
8091
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8092
- }>, never, never>;
8093
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8094
- readonly input: Schema.Finite;
8095
- readonly output: Schema.Finite;
8096
- readonly reasoning: Schema.Finite;
8097
- readonly cache: Schema.Struct<{
8098
- readonly read: Schema.Finite;
8099
- readonly write: Schema.Finite;
8100
- }>;
8101
- }>>>, Schema.optionalKey<Schema.Struct<{
8102
- readonly input: Schema.Finite;
8103
- readonly output: Schema.Finite;
8104
- readonly reasoning: Schema.Finite;
8105
- readonly cache: Schema.Struct<{
8106
- readonly read: Schema.Finite;
8107
- readonly write: Schema.Finite;
8108
- }>;
8109
- }>>, never, never>;
8110
7842
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8111
7843
  create: () => string & import("effect/Brand").Brand<"SessionID">;
8112
7844
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -8216,28 +7948,6 @@ export declare const Definitions: readonly [Schema.Struct<{
8216
7948
  }>>, never, never>;
8217
7949
  readonly text: Schema.String;
8218
7950
  readonly recent: Schema.String;
8219
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
8220
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8221
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
8222
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8223
- }>, never, never>;
8224
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8225
- readonly input: Schema.Finite;
8226
- readonly output: Schema.Finite;
8227
- readonly reasoning: Schema.Finite;
8228
- readonly cache: Schema.Struct<{
8229
- readonly read: Schema.Finite;
8230
- readonly write: Schema.Finite;
8231
- }>;
8232
- }>>>, Schema.optionalKey<Schema.Struct<{
8233
- readonly input: Schema.Finite;
8234
- readonly output: Schema.Finite;
8235
- readonly reasoning: Schema.Finite;
8236
- readonly cache: Schema.Struct<{
8237
- readonly read: Schema.Finite;
8238
- readonly write: Schema.Finite;
8239
- }>;
8240
- }>>, never, never>;
8241
7951
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8242
7952
  create: () => string & import("effect/Brand").Brand<"SessionID">;
8243
7953
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -8288,28 +7998,6 @@ export declare const Definitions: readonly [Schema.Struct<{
8288
7998
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
8289
7999
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
8290
8000
  }>, never, never>;
8291
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
8292
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8293
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
8294
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8295
- }>, never, never>;
8296
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8297
- readonly input: Schema.Finite;
8298
- readonly output: Schema.Finite;
8299
- readonly reasoning: Schema.Finite;
8300
- readonly cache: Schema.Struct<{
8301
- readonly read: Schema.Finite;
8302
- readonly write: Schema.Finite;
8303
- }>;
8304
- }>>>, Schema.optionalKey<Schema.Struct<{
8305
- readonly input: Schema.Finite;
8306
- readonly output: Schema.Finite;
8307
- readonly reasoning: Schema.Finite;
8308
- readonly cache: Schema.Struct<{
8309
- readonly read: Schema.Finite;
8310
- readonly write: Schema.Finite;
8311
- }>;
8312
- }>>, never, never>;
8313
8001
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8314
8002
  create: () => string & import("effect/Brand").Brand<"SessionID">;
8315
8003
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -8336,28 +8024,6 @@ export declare const Definitions: readonly [Schema.Struct<{
8336
8024
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
8337
8025
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
8338
8026
  }>, never, never>;
8339
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
8340
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8341
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
8342
- zero: number & import("effect/Brand").Brand<"Money.USD">;
8343
- }>, never, never>;
8344
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8345
- readonly input: Schema.Finite;
8346
- readonly output: Schema.Finite;
8347
- readonly reasoning: Schema.Finite;
8348
- readonly cache: Schema.Struct<{
8349
- readonly read: Schema.Finite;
8350
- readonly write: Schema.Finite;
8351
- }>;
8352
- }>>>, Schema.optionalKey<Schema.Struct<{
8353
- readonly input: Schema.Finite;
8354
- readonly output: Schema.Finite;
8355
- readonly reasoning: Schema.Finite;
8356
- readonly cache: Schema.Struct<{
8357
- readonly read: Schema.Finite;
8358
- readonly write: Schema.Finite;
8359
- }>;
8360
- }>>, never, never>;
8361
8027
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8362
8028
  create: () => string & import("effect/Brand").Brand<"SessionID">;
8363
8029
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -8563,6 +8229,214 @@ export declare const Definitions: readonly [Schema.Struct<{
8563
8229
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
8564
8230
  };
8565
8231
  }>;
8232
+ }, Schema.Struct<{
8233
+ readonly id: Schema.brand<Schema.String, "Event.ID"> & {
8234
+ create: () => string & import("effect/Brand").Brand<"Event.ID">;
8235
+ };
8236
+ readonly created: Schema.Finite;
8237
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8238
+ readonly type: Schema.Literal<"session.message.content.updated">;
8239
+ readonly durable: Schema.Struct<{
8240
+ readonly aggregateID: Schema.String;
8241
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
8242
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
8243
+ }>;
8244
+ readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8245
+ readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
8246
+ readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
8247
+ ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
8248
+ create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
8249
+ }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
8250
+ ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
8251
+ create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
8252
+ }>, never, never>;
8253
+ }>>>, Schema.optionalKey<Schema.Struct<{
8254
+ readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
8255
+ readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
8256
+ ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
8257
+ create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
8258
+ }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
8259
+ ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
8260
+ create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
8261
+ }>, never, never>;
8262
+ }>>, never, never>;
8263
+ readonly data: Schema.Struct<{
8264
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
8265
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
8266
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
8267
+ };
8268
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
8269
+ readonly type: Schema.tag<"text">;
8270
+ readonly text: Schema.String;
8271
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8272
+ }>, Schema.Struct<{
8273
+ readonly type: Schema.tag<"reasoning">;
8274
+ readonly text: Schema.String;
8275
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8276
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8277
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
8278
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8279
+ }>>>, Schema.optionalKey<Schema.Struct<{
8280
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
8281
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8282
+ }>>, never, never>;
8283
+ }>, Schema.Struct<{
8284
+ readonly type: Schema.tag<"tool">;
8285
+ readonly id: Schema.String;
8286
+ readonly name: Schema.String;
8287
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
8288
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8289
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8290
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
8291
+ readonly status: Schema.tag<"streaming">;
8292
+ readonly input: Schema.String;
8293
+ }>, Schema.Struct<{
8294
+ readonly status: Schema.tag<"running">;
8295
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
8296
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
8297
+ }>, Schema.Struct<{
8298
+ readonly status: Schema.tag<"completed">;
8299
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
8300
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
8301
+ readonly type: Schema.Literal<"text">;
8302
+ readonly text: Schema.String;
8303
+ }>, Schema.Struct<{
8304
+ readonly type: Schema.Literal<"file">;
8305
+ readonly uri: Schema.String;
8306
+ readonly mime: Schema.String;
8307
+ readonly name: Schema.optional<Schema.String>;
8308
+ }>]>>;
8309
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
8310
+ }>, Schema.Struct<{
8311
+ readonly status: Schema.tag<"error">;
8312
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
8313
+ readonly error: Schema.Struct<{
8314
+ readonly type: Schema.String;
8315
+ readonly message: Schema.String;
8316
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
8317
+ }>;
8318
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
8319
+ readonly type: Schema.Literal<"text">;
8320
+ readonly text: Schema.String;
8321
+ }>, Schema.Struct<{
8322
+ readonly type: Schema.Literal<"file">;
8323
+ readonly uri: Schema.String;
8324
+ readonly mime: Schema.String;
8325
+ readonly name: Schema.optional<Schema.String>;
8326
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
8327
+ readonly type: Schema.Literal<"text">;
8328
+ readonly text: Schema.String;
8329
+ }>, Schema.Struct<{
8330
+ readonly type: Schema.Literal<"file">;
8331
+ readonly uri: Schema.String;
8332
+ readonly mime: Schema.String;
8333
+ readonly name: Schema.optional<Schema.String>;
8334
+ }>]>>>, never, never>;
8335
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
8336
+ }>]>;
8337
+ readonly time: Schema.Struct<{
8338
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
8339
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8340
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8341
+ }>;
8342
+ }>]>>>;
8343
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8344
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
8345
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
8346
+ };
8347
+ }>;
8348
+ }> & {
8349
+ type: "session.message.content.updated";
8350
+ durability: "durable";
8351
+ durable: {
8352
+ readonly version: number;
8353
+ readonly aggregate: string;
8354
+ };
8355
+ data: Schema.Struct<{
8356
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
8357
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
8358
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
8359
+ };
8360
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
8361
+ readonly type: Schema.tag<"text">;
8362
+ readonly text: Schema.String;
8363
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8364
+ }>, Schema.Struct<{
8365
+ readonly type: Schema.tag<"reasoning">;
8366
+ readonly text: Schema.String;
8367
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8368
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
8369
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
8370
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8371
+ }>>>, Schema.optionalKey<Schema.Struct<{
8372
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
8373
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8374
+ }>>, never, never>;
8375
+ }>, Schema.Struct<{
8376
+ readonly type: Schema.tag<"tool">;
8377
+ readonly id: Schema.String;
8378
+ readonly name: Schema.String;
8379
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
8380
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8381
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
8382
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
8383
+ readonly status: Schema.tag<"streaming">;
8384
+ readonly input: Schema.String;
8385
+ }>, Schema.Struct<{
8386
+ readonly status: Schema.tag<"running">;
8387
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
8388
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
8389
+ }>, Schema.Struct<{
8390
+ readonly status: Schema.tag<"completed">;
8391
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
8392
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
8393
+ readonly type: Schema.Literal<"text">;
8394
+ readonly text: Schema.String;
8395
+ }>, Schema.Struct<{
8396
+ readonly type: Schema.Literal<"file">;
8397
+ readonly uri: Schema.String;
8398
+ readonly mime: Schema.String;
8399
+ readonly name: Schema.optional<Schema.String>;
8400
+ }>]>>;
8401
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
8402
+ }>, Schema.Struct<{
8403
+ readonly status: Schema.tag<"error">;
8404
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
8405
+ readonly error: Schema.Struct<{
8406
+ readonly type: Schema.String;
8407
+ readonly message: Schema.String;
8408
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
8409
+ }>;
8410
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
8411
+ readonly type: Schema.Literal<"text">;
8412
+ readonly text: Schema.String;
8413
+ }>, Schema.Struct<{
8414
+ readonly type: Schema.Literal<"file">;
8415
+ readonly uri: Schema.String;
8416
+ readonly mime: Schema.String;
8417
+ readonly name: Schema.optional<Schema.String>;
8418
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
8419
+ readonly type: Schema.Literal<"text">;
8420
+ readonly text: Schema.String;
8421
+ }>, Schema.Struct<{
8422
+ readonly type: Schema.Literal<"file">;
8423
+ readonly uri: Schema.String;
8424
+ readonly mime: Schema.String;
8425
+ readonly name: Schema.optional<Schema.String>;
8426
+ }>]>>>, never, never>;
8427
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
8428
+ }>]>;
8429
+ readonly time: Schema.Struct<{
8430
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
8431
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8432
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
8433
+ }>;
8434
+ }>]>>>;
8435
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8436
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
8437
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
8438
+ };
8439
+ }>;
8566
8440
  }];
8567
8441
  export declare const DurableDefinitions: readonly [...((Schema.Struct<{
8568
8442
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -8667,15 +8541,6 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
8667
8541
  }>, never, never>;
8668
8542
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
8669
8543
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
8670
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
8671
- readonly action: Schema.String;
8672
- readonly resource: Schema.String;
8673
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
8674
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
8675
- readonly action: Schema.String;
8676
- readonly resource: Schema.String;
8677
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
8678
- }>>>, never, never>;
8679
8544
  readonly version: Schema.String;
8680
8545
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8681
8546
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -8761,15 +8626,6 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
8761
8626
  }>, never, never>;
8762
8627
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
8763
8628
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
8764
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
8765
- readonly action: Schema.String;
8766
- readonly resource: Schema.String;
8767
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
8768
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
8769
- readonly action: Schema.String;
8770
- readonly resource: Schema.String;
8771
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
8772
- }>>>, never, never>;
8773
8629
  readonly version: Schema.String;
8774
8630
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
8775
8631
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -9152,7 +9008,7 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
9152
9008
  };
9153
9009
  readonly created: Schema.Finite;
9154
9010
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9155
- readonly type: Schema.Literal<"session.permissions.updated">;
9011
+ readonly type: Schema.Literal<"session.viewed">;
9156
9012
  readonly durable: Schema.Struct<{
9157
9013
  readonly aggregateID: Schema.String;
9158
9014
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -9178,29 +9034,23 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
9178
9034
  }>, never, never>;
9179
9035
  }>>, never, never>;
9180
9036
  readonly data: Schema.Struct<{
9181
- readonly permissions: Schema.$Array<Schema.Struct<{
9182
- readonly action: Schema.String;
9183
- readonly resource: Schema.String;
9184
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
9185
- }>>;
9037
+ /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
9038
+ readonly idle: Schema.Finite;
9186
9039
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
9187
9040
  create: () => string & import("effect/Brand").Brand<"SessionID">;
9188
9041
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
9189
9042
  };
9190
9043
  }>;
9191
9044
  }> & {
9192
- type: "session.permissions.updated";
9045
+ type: "session.viewed";
9193
9046
  durability: "durable";
9194
9047
  durable: {
9195
9048
  readonly version: number;
9196
9049
  readonly aggregate: string;
9197
9050
  };
9198
9051
  data: Schema.Struct<{
9199
- readonly permissions: Schema.$Array<Schema.Struct<{
9200
- readonly action: Schema.String;
9201
- readonly resource: Schema.String;
9202
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
9203
- }>>;
9052
+ /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
9053
+ readonly idle: Schema.Finite;
9204
9054
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
9205
9055
  create: () => string & import("effect/Brand").Brand<"SessionID">;
9206
9056
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -9212,7 +9062,7 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
9212
9062
  };
9213
9063
  readonly created: Schema.Finite;
9214
9064
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9215
- readonly type: Schema.Literal<"session.viewed">;
9065
+ readonly type: Schema.Literal<"session.message.content.updated">;
9216
9066
  readonly durable: Schema.Struct<{
9217
9067
  readonly aggregateID: Schema.String;
9218
9068
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -9238,23 +9088,177 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
9238
9088
  }>, never, never>;
9239
9089
  }>>, never, never>;
9240
9090
  readonly data: Schema.Struct<{
9241
- /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
9242
- readonly idle: Schema.Finite;
9243
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
9244
- create: () => string & import("effect/Brand").Brand<"SessionID">;
9245
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
9091
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
9092
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
9093
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
9246
9094
  };
9247
- }>;
9248
- }> & {
9249
- type: "session.viewed";
9250
- durability: "durable";
9095
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
9096
+ readonly type: Schema.tag<"text">;
9097
+ readonly text: Schema.String;
9098
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9099
+ }>, Schema.Struct<{
9100
+ readonly type: Schema.tag<"reasoning">;
9101
+ readonly text: Schema.String;
9102
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9103
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9104
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9105
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9106
+ }>>>, Schema.optionalKey<Schema.Struct<{
9107
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9108
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9109
+ }>>, never, never>;
9110
+ }>, Schema.Struct<{
9111
+ readonly type: Schema.tag<"tool">;
9112
+ readonly id: Schema.String;
9113
+ readonly name: Schema.String;
9114
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
9115
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9116
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9117
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
9118
+ readonly status: Schema.tag<"streaming">;
9119
+ readonly input: Schema.String;
9120
+ }>, Schema.Struct<{
9121
+ readonly status: Schema.tag<"running">;
9122
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
9123
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
9124
+ }>, Schema.Struct<{
9125
+ readonly status: Schema.tag<"completed">;
9126
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
9127
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
9128
+ readonly type: Schema.Literal<"text">;
9129
+ readonly text: Schema.String;
9130
+ }>, Schema.Struct<{
9131
+ readonly type: Schema.Literal<"file">;
9132
+ readonly uri: Schema.String;
9133
+ readonly mime: Schema.String;
9134
+ readonly name: Schema.optional<Schema.String>;
9135
+ }>]>>;
9136
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
9137
+ }>, Schema.Struct<{
9138
+ readonly status: Schema.tag<"error">;
9139
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
9140
+ readonly error: Schema.Struct<{
9141
+ readonly type: Schema.String;
9142
+ readonly message: Schema.String;
9143
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
9144
+ }>;
9145
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
9146
+ readonly type: Schema.Literal<"text">;
9147
+ readonly text: Schema.String;
9148
+ }>, Schema.Struct<{
9149
+ readonly type: Schema.Literal<"file">;
9150
+ readonly uri: Schema.String;
9151
+ readonly mime: Schema.String;
9152
+ readonly name: Schema.optional<Schema.String>;
9153
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
9154
+ readonly type: Schema.Literal<"text">;
9155
+ readonly text: Schema.String;
9156
+ }>, Schema.Struct<{
9157
+ readonly type: Schema.Literal<"file">;
9158
+ readonly uri: Schema.String;
9159
+ readonly mime: Schema.String;
9160
+ readonly name: Schema.optional<Schema.String>;
9161
+ }>]>>>, never, never>;
9162
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
9163
+ }>]>;
9164
+ readonly time: Schema.Struct<{
9165
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9166
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9167
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9168
+ }>;
9169
+ }>]>>>;
9170
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
9171
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
9172
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
9173
+ };
9174
+ }>;
9175
+ }> & {
9176
+ type: "session.message.content.updated";
9177
+ durability: "durable";
9251
9178
  durable: {
9252
9179
  readonly version: number;
9253
9180
  readonly aggregate: string;
9254
9181
  };
9255
9182
  data: Schema.Struct<{
9256
- /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
9257
- readonly idle: Schema.Finite;
9183
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
9184
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
9185
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
9186
+ };
9187
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
9188
+ readonly type: Schema.tag<"text">;
9189
+ readonly text: Schema.String;
9190
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9191
+ }>, Schema.Struct<{
9192
+ readonly type: Schema.tag<"reasoning">;
9193
+ readonly text: Schema.String;
9194
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9195
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9196
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9197
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9198
+ }>>>, Schema.optionalKey<Schema.Struct<{
9199
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9200
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9201
+ }>>, never, never>;
9202
+ }>, Schema.Struct<{
9203
+ readonly type: Schema.tag<"tool">;
9204
+ readonly id: Schema.String;
9205
+ readonly name: Schema.String;
9206
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
9207
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9208
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9209
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
9210
+ readonly status: Schema.tag<"streaming">;
9211
+ readonly input: Schema.String;
9212
+ }>, Schema.Struct<{
9213
+ readonly status: Schema.tag<"running">;
9214
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
9215
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
9216
+ }>, Schema.Struct<{
9217
+ readonly status: Schema.tag<"completed">;
9218
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
9219
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
9220
+ readonly type: Schema.Literal<"text">;
9221
+ readonly text: Schema.String;
9222
+ }>, Schema.Struct<{
9223
+ readonly type: Schema.Literal<"file">;
9224
+ readonly uri: Schema.String;
9225
+ readonly mime: Schema.String;
9226
+ readonly name: Schema.optional<Schema.String>;
9227
+ }>]>>;
9228
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
9229
+ }>, Schema.Struct<{
9230
+ readonly status: Schema.tag<"error">;
9231
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
9232
+ readonly error: Schema.Struct<{
9233
+ readonly type: Schema.String;
9234
+ readonly message: Schema.String;
9235
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
9236
+ }>;
9237
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
9238
+ readonly type: Schema.Literal<"text">;
9239
+ readonly text: Schema.String;
9240
+ }>, Schema.Struct<{
9241
+ readonly type: Schema.Literal<"file">;
9242
+ readonly uri: Schema.String;
9243
+ readonly mime: Schema.String;
9244
+ readonly name: Schema.optional<Schema.String>;
9245
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
9246
+ readonly type: Schema.Literal<"text">;
9247
+ readonly text: Schema.String;
9248
+ }>, Schema.Struct<{
9249
+ readonly type: Schema.Literal<"file">;
9250
+ readonly uri: Schema.String;
9251
+ readonly mime: Schema.String;
9252
+ readonly name: Schema.optional<Schema.String>;
9253
+ }>]>>>, never, never>;
9254
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
9255
+ }>]>;
9256
+ readonly time: Schema.Struct<{
9257
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9258
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9259
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
9260
+ }>;
9261
+ }>]>>>;
9258
9262
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
9259
9263
  create: () => string & import("effect/Brand").Brand<"SessionID">;
9260
9264
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -11832,28 +11836,6 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
11832
11836
  }>>, never, never>;
11833
11837
  readonly text: Schema.String;
11834
11838
  readonly recent: Schema.String;
11835
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
11836
- zero: number & import("effect/Brand").Brand<"Money.USD">;
11837
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
11838
- zero: number & import("effect/Brand").Brand<"Money.USD">;
11839
- }>, never, never>;
11840
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
11841
- readonly input: Schema.Finite;
11842
- readonly output: Schema.Finite;
11843
- readonly reasoning: Schema.Finite;
11844
- readonly cache: Schema.Struct<{
11845
- readonly read: Schema.Finite;
11846
- readonly write: Schema.Finite;
11847
- }>;
11848
- }>>>, Schema.optionalKey<Schema.Struct<{
11849
- readonly input: Schema.Finite;
11850
- readonly output: Schema.Finite;
11851
- readonly reasoning: Schema.Finite;
11852
- readonly cache: Schema.Struct<{
11853
- readonly read: Schema.Finite;
11854
- readonly write: Schema.Finite;
11855
- }>;
11856
- }>>, never, never>;
11857
11839
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
11858
11840
  create: () => string & import("effect/Brand").Brand<"SessionID">;
11859
11841
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -11963,28 +11945,6 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
11963
11945
  }>>, never, never>;
11964
11946
  readonly text: Schema.String;
11965
11947
  readonly recent: Schema.String;
11966
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
11967
- zero: number & import("effect/Brand").Brand<"Money.USD">;
11968
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
11969
- zero: number & import("effect/Brand").Brand<"Money.USD">;
11970
- }>, never, never>;
11971
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
11972
- readonly input: Schema.Finite;
11973
- readonly output: Schema.Finite;
11974
- readonly reasoning: Schema.Finite;
11975
- readonly cache: Schema.Struct<{
11976
- readonly read: Schema.Finite;
11977
- readonly write: Schema.Finite;
11978
- }>;
11979
- }>>>, Schema.optionalKey<Schema.Struct<{
11980
- readonly input: Schema.Finite;
11981
- readonly output: Schema.Finite;
11982
- readonly reasoning: Schema.Finite;
11983
- readonly cache: Schema.Struct<{
11984
- readonly read: Schema.Finite;
11985
- readonly write: Schema.Finite;
11986
- }>;
11987
- }>>, never, never>;
11988
11948
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
11989
11949
  create: () => string & import("effect/Brand").Brand<"SessionID">;
11990
11950
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -12035,28 +11995,6 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
12035
11995
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
12036
11996
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
12037
11997
  }>, never, never>;
12038
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
12039
- zero: number & import("effect/Brand").Brand<"Money.USD">;
12040
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
12041
- zero: number & import("effect/Brand").Brand<"Money.USD">;
12042
- }>, never, never>;
12043
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12044
- readonly input: Schema.Finite;
12045
- readonly output: Schema.Finite;
12046
- readonly reasoning: Schema.Finite;
12047
- readonly cache: Schema.Struct<{
12048
- readonly read: Schema.Finite;
12049
- readonly write: Schema.Finite;
12050
- }>;
12051
- }>>>, Schema.optionalKey<Schema.Struct<{
12052
- readonly input: Schema.Finite;
12053
- readonly output: Schema.Finite;
12054
- readonly reasoning: Schema.Finite;
12055
- readonly cache: Schema.Struct<{
12056
- readonly read: Schema.Finite;
12057
- readonly write: Schema.Finite;
12058
- }>;
12059
- }>>, never, never>;
12060
11998
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
12061
11999
  create: () => string & import("effect/Brand").Brand<"SessionID">;
12062
12000
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -12083,28 +12021,6 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
12083
12021
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
12084
12022
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
12085
12023
  }>, never, never>;
12086
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
12087
- zero: number & import("effect/Brand").Brand<"Money.USD">;
12088
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
12089
- zero: number & import("effect/Brand").Brand<"Money.USD">;
12090
- }>, never, never>;
12091
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12092
- readonly input: Schema.Finite;
12093
- readonly output: Schema.Finite;
12094
- readonly reasoning: Schema.Finite;
12095
- readonly cache: Schema.Struct<{
12096
- readonly read: Schema.Finite;
12097
- readonly write: Schema.Finite;
12098
- }>;
12099
- }>>>, Schema.optionalKey<Schema.Struct<{
12100
- readonly input: Schema.Finite;
12101
- readonly output: Schema.Finite;
12102
- readonly reasoning: Schema.Finite;
12103
- readonly cache: Schema.Struct<{
12104
- readonly read: Schema.Finite;
12105
- readonly write: Schema.Finite;
12106
- }>;
12107
- }>>, never, never>;
12108
12024
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
12109
12025
  create: () => string & import("effect/Brand").Brand<"SessionID">;
12110
12026
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -12386,216 +12302,8 @@ export declare const DurableDefinitions: readonly [...((Schema.Struct<{
12386
12302
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
12387
12303
  };
12388
12304
  }>;
12389
- }, Schema.Struct<{
12390
- readonly id: Schema.brand<Schema.String, "Event.ID"> & {
12391
- create: () => string & import("effect/Brand").Brand<"Event.ID">;
12392
- };
12393
- readonly created: Schema.Finite;
12394
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12395
- readonly type: Schema.Literal<"session.message.content.updated">;
12396
- readonly durable: Schema.Struct<{
12397
- readonly aggregateID: Schema.String;
12398
- readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
12399
- readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
12400
- }>;
12401
- readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12402
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
12403
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
12404
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
12405
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
12406
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
12407
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
12408
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
12409
- }>, never, never>;
12410
- }>>>, Schema.optionalKey<Schema.Struct<{
12411
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
12412
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
12413
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
12414
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
12415
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
12416
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
12417
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
12418
- }>, never, never>;
12419
- }>>, never, never>;
12420
- readonly data: Schema.Struct<{
12421
- readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
12422
- create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
12423
- fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
12424
- };
12425
- readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
12426
- readonly type: Schema.tag<"text">;
12427
- readonly text: Schema.String;
12428
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12429
- }>, Schema.Struct<{
12430
- readonly type: Schema.tag<"reasoning">;
12431
- readonly text: Schema.String;
12432
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12433
- readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12434
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12435
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12436
- }>>>, Schema.optionalKey<Schema.Struct<{
12437
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12438
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12439
- }>>, never, never>;
12440
- }>, Schema.Struct<{
12441
- readonly type: Schema.tag<"tool">;
12442
- readonly id: Schema.String;
12443
- readonly name: Schema.String;
12444
- readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
12445
- readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12446
- readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12447
- readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
12448
- readonly status: Schema.tag<"streaming">;
12449
- readonly input: Schema.String;
12450
- }>, Schema.Struct<{
12451
- readonly status: Schema.tag<"running">;
12452
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
12453
- readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
12454
- }>, Schema.Struct<{
12455
- readonly status: Schema.tag<"completed">;
12456
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
12457
- readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
12458
- readonly type: Schema.Literal<"text">;
12459
- readonly text: Schema.String;
12460
- }>, Schema.Struct<{
12461
- readonly type: Schema.Literal<"file">;
12462
- readonly uri: Schema.String;
12463
- readonly mime: Schema.String;
12464
- readonly name: Schema.optional<Schema.String>;
12465
- }>]>>;
12466
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
12467
- }>, Schema.Struct<{
12468
- readonly status: Schema.tag<"error">;
12469
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
12470
- readonly error: Schema.Struct<{
12471
- readonly type: Schema.String;
12472
- readonly message: Schema.String;
12473
- readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
12474
- }>;
12475
- readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
12476
- readonly type: Schema.Literal<"text">;
12477
- readonly text: Schema.String;
12478
- }>, Schema.Struct<{
12479
- readonly type: Schema.Literal<"file">;
12480
- readonly uri: Schema.String;
12481
- readonly mime: Schema.String;
12482
- readonly name: Schema.optional<Schema.String>;
12483
- }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
12484
- readonly type: Schema.Literal<"text">;
12485
- readonly text: Schema.String;
12486
- }>, Schema.Struct<{
12487
- readonly type: Schema.Literal<"file">;
12488
- readonly uri: Schema.String;
12489
- readonly mime: Schema.String;
12490
- readonly name: Schema.optional<Schema.String>;
12491
- }>]>>>, never, never>;
12492
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
12493
- }>]>;
12494
- readonly time: Schema.Struct<{
12495
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12496
- readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12497
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12498
- }>;
12499
- }>]>>>;
12500
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
12501
- create: () => string & import("effect/Brand").Brand<"SessionID">;
12502
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
12503
- };
12504
- }>;
12505
- }> & {
12506
- type: "session.message.content.updated";
12507
- durability: "durable";
12508
- durable: {
12509
- readonly version: number;
12510
- readonly aggregate: string;
12511
- };
12512
- data: Schema.Struct<{
12513
- readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
12514
- create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
12515
- fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
12516
- };
12517
- readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
12518
- readonly type: Schema.tag<"text">;
12519
- readonly text: Schema.String;
12520
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12521
- }>, Schema.Struct<{
12522
- readonly type: Schema.tag<"reasoning">;
12523
- readonly text: Schema.String;
12524
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12525
- readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12526
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12527
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12528
- }>>>, Schema.optionalKey<Schema.Struct<{
12529
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12530
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12531
- }>>, never, never>;
12532
- }>, Schema.Struct<{
12533
- readonly type: Schema.tag<"tool">;
12534
- readonly id: Schema.String;
12535
- readonly name: Schema.String;
12536
- readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
12537
- readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12538
- readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12539
- readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
12540
- readonly status: Schema.tag<"streaming">;
12541
- readonly input: Schema.String;
12542
- }>, Schema.Struct<{
12543
- readonly status: Schema.tag<"running">;
12544
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
12545
- readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
12546
- }>, Schema.Struct<{
12547
- readonly status: Schema.tag<"completed">;
12548
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
12549
- readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
12550
- readonly type: Schema.Literal<"text">;
12551
- readonly text: Schema.String;
12552
- }>, Schema.Struct<{
12553
- readonly type: Schema.Literal<"file">;
12554
- readonly uri: Schema.String;
12555
- readonly mime: Schema.String;
12556
- readonly name: Schema.optional<Schema.String>;
12557
- }>]>>;
12558
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
12559
- }>, Schema.Struct<{
12560
- readonly status: Schema.tag<"error">;
12561
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
12562
- readonly error: Schema.Struct<{
12563
- readonly type: Schema.String;
12564
- readonly message: Schema.String;
12565
- readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
12566
- }>;
12567
- readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
12568
- readonly type: Schema.Literal<"text">;
12569
- readonly text: Schema.String;
12570
- }>, Schema.Struct<{
12571
- readonly type: Schema.Literal<"file">;
12572
- readonly uri: Schema.String;
12573
- readonly mime: Schema.String;
12574
- readonly name: Schema.optional<Schema.String>;
12575
- }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
12576
- readonly type: Schema.Literal<"text">;
12577
- readonly text: Schema.String;
12578
- }>, Schema.Struct<{
12579
- readonly type: Schema.Literal<"file">;
12580
- readonly uri: Schema.String;
12581
- readonly mime: Schema.String;
12582
- readonly name: Schema.optional<Schema.String>;
12583
- }>]>>>, never, never>;
12584
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
12585
- }>]>;
12586
- readonly time: Schema.Struct<{
12587
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12588
- readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12589
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
12590
- }>;
12591
- }>]>>>;
12592
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
12593
- create: () => string & import("effect/Brand").Brand<"SessionID">;
12594
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
12595
- };
12596
- }>;
12597
- }];
12598
- export declare const EphemeralDefinitions: readonly ((Schema.Struct<{
12305
+ }];
12306
+ export declare const EphemeralDefinitions: readonly ((Schema.Struct<{
12599
12307
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
12600
12308
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
12601
12309
  };
@@ -13025,15 +12733,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
13025
12733
  }>, never, never>;
13026
12734
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
13027
12735
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
13028
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
13029
- readonly action: Schema.String;
13030
- readonly resource: Schema.String;
13031
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
13032
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
13033
- readonly action: Schema.String;
13034
- readonly resource: Schema.String;
13035
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
13036
- }>>>, never, never>;
13037
12736
  readonly version: Schema.String;
13038
12737
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13039
12738
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -13119,15 +12818,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
13119
12818
  }>, never, never>;
13120
12819
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
13121
12820
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
13122
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
13123
- readonly action: Schema.String;
13124
- readonly resource: Schema.String;
13125
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
13126
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
13127
- readonly action: Schema.String;
13128
- readonly resource: Schema.String;
13129
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
13130
- }>>>, never, never>;
13131
12821
  readonly version: Schema.String;
13132
12822
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13133
12823
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -13510,7 +13200,7 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
13510
13200
  };
13511
13201
  readonly created: Schema.Finite;
13512
13202
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13513
- readonly type: Schema.Literal<"session.permissions.updated">;
13203
+ readonly type: Schema.Literal<"session.viewed">;
13514
13204
  readonly durable: Schema.Struct<{
13515
13205
  readonly aggregateID: Schema.String;
13516
13206
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -13536,29 +13226,23 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
13536
13226
  }>, never, never>;
13537
13227
  }>>, never, never>;
13538
13228
  readonly data: Schema.Struct<{
13539
- readonly permissions: Schema.$Array<Schema.Struct<{
13540
- readonly action: Schema.String;
13541
- readonly resource: Schema.String;
13542
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
13543
- }>>;
13229
+ /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
13230
+ readonly idle: Schema.Finite;
13544
13231
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13545
13232
  create: () => string & import("effect/Brand").Brand<"SessionID">;
13546
13233
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
13547
13234
  };
13548
13235
  }>;
13549
13236
  }> & {
13550
- type: "session.permissions.updated";
13237
+ type: "session.viewed";
13551
13238
  durability: "durable";
13552
13239
  durable: {
13553
13240
  readonly version: number;
13554
13241
  readonly aggregate: string;
13555
13242
  };
13556
13243
  data: Schema.Struct<{
13557
- readonly permissions: Schema.$Array<Schema.Struct<{
13558
- readonly action: Schema.String;
13559
- readonly resource: Schema.String;
13560
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
13561
- }>>;
13244
+ /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
13245
+ readonly idle: Schema.Finite;
13562
13246
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13563
13247
  create: () => string & import("effect/Brand").Brand<"SessionID">;
13564
13248
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -13570,7 +13254,7 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
13570
13254
  };
13571
13255
  readonly created: Schema.Finite;
13572
13256
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13573
- readonly type: Schema.Literal<"session.viewed">;
13257
+ readonly type: Schema.Literal<"session.message.content.updated">;
13574
13258
  readonly durable: Schema.Struct<{
13575
13259
  readonly aggregateID: Schema.String;
13576
13260
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -13596,40 +13280,194 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
13596
13280
  }>, never, never>;
13597
13281
  }>>, never, never>;
13598
13282
  readonly data: Schema.Struct<{
13599
- /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
13600
- readonly idle: Schema.Finite;
13601
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13602
- create: () => string & import("effect/Brand").Brand<"SessionID">;
13603
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
13604
- };
13605
- }>;
13606
- }> & {
13607
- type: "session.viewed";
13608
- durability: "durable";
13609
- durable: {
13610
- readonly version: number;
13611
- readonly aggregate: string;
13612
- };
13613
- data: Schema.Struct<{
13614
- /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
13615
- readonly idle: Schema.Finite;
13616
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13617
- create: () => string & import("effect/Brand").Brand<"SessionID">;
13618
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
13283
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
13284
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
13285
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
13619
13286
  };
13620
- }>;
13621
- }) | (Schema.Struct<{
13622
- readonly id: Schema.brand<Schema.String, "Event.ID"> & {
13623
- create: () => string & import("effect/Brand").Brand<"Event.ID">;
13624
- };
13625
- readonly created: Schema.Finite;
13626
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13627
- readonly type: Schema.Literal<"session.deleted">;
13628
- readonly durable: Schema.Struct<{
13629
- readonly aggregateID: Schema.String;
13630
- readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
13631
- readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
13632
- }>;
13287
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
13288
+ readonly type: Schema.tag<"text">;
13289
+ readonly text: Schema.String;
13290
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13291
+ }>, Schema.Struct<{
13292
+ readonly type: Schema.tag<"reasoning">;
13293
+ readonly text: Schema.String;
13294
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13295
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
13296
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
13297
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13298
+ }>>>, Schema.optionalKey<Schema.Struct<{
13299
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
13300
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13301
+ }>>, never, never>;
13302
+ }>, Schema.Struct<{
13303
+ readonly type: Schema.tag<"tool">;
13304
+ readonly id: Schema.String;
13305
+ readonly name: Schema.String;
13306
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
13307
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13308
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13309
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
13310
+ readonly status: Schema.tag<"streaming">;
13311
+ readonly input: Schema.String;
13312
+ }>, Schema.Struct<{
13313
+ readonly status: Schema.tag<"running">;
13314
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
13315
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
13316
+ }>, Schema.Struct<{
13317
+ readonly status: Schema.tag<"completed">;
13318
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
13319
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
13320
+ readonly type: Schema.Literal<"text">;
13321
+ readonly text: Schema.String;
13322
+ }>, Schema.Struct<{
13323
+ readonly type: Schema.Literal<"file">;
13324
+ readonly uri: Schema.String;
13325
+ readonly mime: Schema.String;
13326
+ readonly name: Schema.optional<Schema.String>;
13327
+ }>]>>;
13328
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
13329
+ }>, Schema.Struct<{
13330
+ readonly status: Schema.tag<"error">;
13331
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
13332
+ readonly error: Schema.Struct<{
13333
+ readonly type: Schema.String;
13334
+ readonly message: Schema.String;
13335
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
13336
+ }>;
13337
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
13338
+ readonly type: Schema.Literal<"text">;
13339
+ readonly text: Schema.String;
13340
+ }>, Schema.Struct<{
13341
+ readonly type: Schema.Literal<"file">;
13342
+ readonly uri: Schema.String;
13343
+ readonly mime: Schema.String;
13344
+ readonly name: Schema.optional<Schema.String>;
13345
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
13346
+ readonly type: Schema.Literal<"text">;
13347
+ readonly text: Schema.String;
13348
+ }>, Schema.Struct<{
13349
+ readonly type: Schema.Literal<"file">;
13350
+ readonly uri: Schema.String;
13351
+ readonly mime: Schema.String;
13352
+ readonly name: Schema.optional<Schema.String>;
13353
+ }>]>>>, never, never>;
13354
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
13355
+ }>]>;
13356
+ readonly time: Schema.Struct<{
13357
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
13358
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13359
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13360
+ }>;
13361
+ }>]>>>;
13362
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13363
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
13364
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
13365
+ };
13366
+ }>;
13367
+ }> & {
13368
+ type: "session.message.content.updated";
13369
+ durability: "durable";
13370
+ durable: {
13371
+ readonly version: number;
13372
+ readonly aggregate: string;
13373
+ };
13374
+ data: Schema.Struct<{
13375
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
13376
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
13377
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
13378
+ };
13379
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
13380
+ readonly type: Schema.tag<"text">;
13381
+ readonly text: Schema.String;
13382
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13383
+ }>, Schema.Struct<{
13384
+ readonly type: Schema.tag<"reasoning">;
13385
+ readonly text: Schema.String;
13386
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13387
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
13388
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
13389
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13390
+ }>>>, Schema.optionalKey<Schema.Struct<{
13391
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
13392
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13393
+ }>>, never, never>;
13394
+ }>, Schema.Struct<{
13395
+ readonly type: Schema.tag<"tool">;
13396
+ readonly id: Schema.String;
13397
+ readonly name: Schema.String;
13398
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
13399
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13400
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13401
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
13402
+ readonly status: Schema.tag<"streaming">;
13403
+ readonly input: Schema.String;
13404
+ }>, Schema.Struct<{
13405
+ readonly status: Schema.tag<"running">;
13406
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
13407
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
13408
+ }>, Schema.Struct<{
13409
+ readonly status: Schema.tag<"completed">;
13410
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
13411
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
13412
+ readonly type: Schema.Literal<"text">;
13413
+ readonly text: Schema.String;
13414
+ }>, Schema.Struct<{
13415
+ readonly type: Schema.Literal<"file">;
13416
+ readonly uri: Schema.String;
13417
+ readonly mime: Schema.String;
13418
+ readonly name: Schema.optional<Schema.String>;
13419
+ }>]>>;
13420
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
13421
+ }>, Schema.Struct<{
13422
+ readonly status: Schema.tag<"error">;
13423
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
13424
+ readonly error: Schema.Struct<{
13425
+ readonly type: Schema.String;
13426
+ readonly message: Schema.String;
13427
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
13428
+ }>;
13429
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
13430
+ readonly type: Schema.Literal<"text">;
13431
+ readonly text: Schema.String;
13432
+ }>, Schema.Struct<{
13433
+ readonly type: Schema.Literal<"file">;
13434
+ readonly uri: Schema.String;
13435
+ readonly mime: Schema.String;
13436
+ readonly name: Schema.optional<Schema.String>;
13437
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
13438
+ readonly type: Schema.Literal<"text">;
13439
+ readonly text: Schema.String;
13440
+ }>, Schema.Struct<{
13441
+ readonly type: Schema.Literal<"file">;
13442
+ readonly uri: Schema.String;
13443
+ readonly mime: Schema.String;
13444
+ readonly name: Schema.optional<Schema.String>;
13445
+ }>]>>>, never, never>;
13446
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
13447
+ }>]>;
13448
+ readonly time: Schema.Struct<{
13449
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
13450
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13451
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
13452
+ }>;
13453
+ }>]>>>;
13454
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13455
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
13456
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
13457
+ };
13458
+ }>;
13459
+ }) | (Schema.Struct<{
13460
+ readonly id: Schema.brand<Schema.String, "Event.ID"> & {
13461
+ create: () => string & import("effect/Brand").Brand<"Event.ID">;
13462
+ };
13463
+ readonly created: Schema.Finite;
13464
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
13465
+ readonly type: Schema.Literal<"session.deleted">;
13466
+ readonly durable: Schema.Struct<{
13467
+ readonly aggregateID: Schema.String;
13468
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
13469
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
13470
+ }>;
13633
13471
  readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
13634
13472
  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
13635
13473
  readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
@@ -16190,28 +16028,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
16190
16028
  }>>, never, never>;
16191
16029
  readonly text: Schema.String;
16192
16030
  readonly recent: Schema.String;
16193
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
16194
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16195
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
16196
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16197
- }>, never, never>;
16198
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16199
- readonly input: Schema.Finite;
16200
- readonly output: Schema.Finite;
16201
- readonly reasoning: Schema.Finite;
16202
- readonly cache: Schema.Struct<{
16203
- readonly read: Schema.Finite;
16204
- readonly write: Schema.Finite;
16205
- }>;
16206
- }>>>, Schema.optionalKey<Schema.Struct<{
16207
- readonly input: Schema.Finite;
16208
- readonly output: Schema.Finite;
16209
- readonly reasoning: Schema.Finite;
16210
- readonly cache: Schema.Struct<{
16211
- readonly read: Schema.Finite;
16212
- readonly write: Schema.Finite;
16213
- }>;
16214
- }>>, never, never>;
16215
16031
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
16216
16032
  create: () => string & import("effect/Brand").Brand<"SessionID">;
16217
16033
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -16321,28 +16137,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
16321
16137
  }>>, never, never>;
16322
16138
  readonly text: Schema.String;
16323
16139
  readonly recent: Schema.String;
16324
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
16325
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16326
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
16327
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16328
- }>, never, never>;
16329
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16330
- readonly input: Schema.Finite;
16331
- readonly output: Schema.Finite;
16332
- readonly reasoning: Schema.Finite;
16333
- readonly cache: Schema.Struct<{
16334
- readonly read: Schema.Finite;
16335
- readonly write: Schema.Finite;
16336
- }>;
16337
- }>>>, Schema.optionalKey<Schema.Struct<{
16338
- readonly input: Schema.Finite;
16339
- readonly output: Schema.Finite;
16340
- readonly reasoning: Schema.Finite;
16341
- readonly cache: Schema.Struct<{
16342
- readonly read: Schema.Finite;
16343
- readonly write: Schema.Finite;
16344
- }>;
16345
- }>>, never, never>;
16346
16140
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
16347
16141
  create: () => string & import("effect/Brand").Brand<"SessionID">;
16348
16142
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -16393,28 +16187,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
16393
16187
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
16394
16188
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
16395
16189
  }>, never, never>;
16396
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
16397
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16398
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
16399
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16400
- }>, never, never>;
16401
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16402
- readonly input: Schema.Finite;
16403
- readonly output: Schema.Finite;
16404
- readonly reasoning: Schema.Finite;
16405
- readonly cache: Schema.Struct<{
16406
- readonly read: Schema.Finite;
16407
- readonly write: Schema.Finite;
16408
- }>;
16409
- }>>>, Schema.optionalKey<Schema.Struct<{
16410
- readonly input: Schema.Finite;
16411
- readonly output: Schema.Finite;
16412
- readonly reasoning: Schema.Finite;
16413
- readonly cache: Schema.Struct<{
16414
- readonly read: Schema.Finite;
16415
- readonly write: Schema.Finite;
16416
- }>;
16417
- }>>, never, never>;
16418
16190
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
16419
16191
  create: () => string & import("effect/Brand").Brand<"SessionID">;
16420
16192
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -16441,28 +16213,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
16441
16213
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
16442
16214
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
16443
16215
  }>, never, never>;
16444
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
16445
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16446
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
16447
- zero: number & import("effect/Brand").Brand<"Money.USD">;
16448
- }>, never, never>;
16449
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16450
- readonly input: Schema.Finite;
16451
- readonly output: Schema.Finite;
16452
- readonly reasoning: Schema.Finite;
16453
- readonly cache: Schema.Struct<{
16454
- readonly read: Schema.Finite;
16455
- readonly write: Schema.Finite;
16456
- }>;
16457
- }>>>, Schema.optionalKey<Schema.Struct<{
16458
- readonly input: Schema.Finite;
16459
- readonly output: Schema.Finite;
16460
- readonly reasoning: Schema.Finite;
16461
- readonly cache: Schema.Struct<{
16462
- readonly read: Schema.Finite;
16463
- readonly write: Schema.Finite;
16464
- }>;
16465
- }>>, never, never>;
16466
16216
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
16467
16217
  create: () => string & import("effect/Brand").Brand<"SessionID">;
16468
16218
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -16744,214 +16494,6 @@ export declare const Durable: Schema.Union<readonly [...((Schema.Struct<{
16744
16494
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
16745
16495
  };
16746
16496
  }>;
16747
- }, Schema.Struct<{
16748
- readonly id: Schema.brand<Schema.String, "Event.ID"> & {
16749
- create: () => string & import("effect/Brand").Brand<"Event.ID">;
16750
- };
16751
- readonly created: Schema.Finite;
16752
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16753
- readonly type: Schema.Literal<"session.message.content.updated">;
16754
- readonly durable: Schema.Struct<{
16755
- readonly aggregateID: Schema.String;
16756
- readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
16757
- readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
16758
- }>;
16759
- readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16760
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
16761
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
16762
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
16763
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
16764
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
16765
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
16766
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
16767
- }>, never, never>;
16768
- }>>>, Schema.optionalKey<Schema.Struct<{
16769
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
16770
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
16771
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
16772
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
16773
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
16774
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
16775
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
16776
- }>, never, never>;
16777
- }>>, never, never>;
16778
- readonly data: Schema.Struct<{
16779
- readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
16780
- create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
16781
- fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
16782
- };
16783
- readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
16784
- readonly type: Schema.tag<"text">;
16785
- readonly text: Schema.String;
16786
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16787
- }>, Schema.Struct<{
16788
- readonly type: Schema.tag<"reasoning">;
16789
- readonly text: Schema.String;
16790
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16791
- readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16792
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
16793
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16794
- }>>>, Schema.optionalKey<Schema.Struct<{
16795
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
16796
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16797
- }>>, never, never>;
16798
- }>, Schema.Struct<{
16799
- readonly type: Schema.tag<"tool">;
16800
- readonly id: Schema.String;
16801
- readonly name: Schema.String;
16802
- readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
16803
- readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16804
- readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16805
- readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
16806
- readonly status: Schema.tag<"streaming">;
16807
- readonly input: Schema.String;
16808
- }>, Schema.Struct<{
16809
- readonly status: Schema.tag<"running">;
16810
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
16811
- readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
16812
- }>, Schema.Struct<{
16813
- readonly status: Schema.tag<"completed">;
16814
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
16815
- readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
16816
- readonly type: Schema.Literal<"text">;
16817
- readonly text: Schema.String;
16818
- }>, Schema.Struct<{
16819
- readonly type: Schema.Literal<"file">;
16820
- readonly uri: Schema.String;
16821
- readonly mime: Schema.String;
16822
- readonly name: Schema.optional<Schema.String>;
16823
- }>]>>;
16824
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
16825
- }>, Schema.Struct<{
16826
- readonly status: Schema.tag<"error">;
16827
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
16828
- readonly error: Schema.Struct<{
16829
- readonly type: Schema.String;
16830
- readonly message: Schema.String;
16831
- readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
16832
- }>;
16833
- readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
16834
- readonly type: Schema.Literal<"text">;
16835
- readonly text: Schema.String;
16836
- }>, Schema.Struct<{
16837
- readonly type: Schema.Literal<"file">;
16838
- readonly uri: Schema.String;
16839
- readonly mime: Schema.String;
16840
- readonly name: Schema.optional<Schema.String>;
16841
- }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
16842
- readonly type: Schema.Literal<"text">;
16843
- readonly text: Schema.String;
16844
- }>, Schema.Struct<{
16845
- readonly type: Schema.Literal<"file">;
16846
- readonly uri: Schema.String;
16847
- readonly mime: Schema.String;
16848
- readonly name: Schema.optional<Schema.String>;
16849
- }>]>>>, never, never>;
16850
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
16851
- }>]>;
16852
- readonly time: Schema.Struct<{
16853
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
16854
- readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16855
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16856
- }>;
16857
- }>]>>>;
16858
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
16859
- create: () => string & import("effect/Brand").Brand<"SessionID">;
16860
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
16861
- };
16862
- }>;
16863
- }> & {
16864
- type: "session.message.content.updated";
16865
- durability: "durable";
16866
- durable: {
16867
- readonly version: number;
16868
- readonly aggregate: string;
16869
- };
16870
- data: Schema.Struct<{
16871
- readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
16872
- create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
16873
- fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
16874
- };
16875
- readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
16876
- readonly type: Schema.tag<"text">;
16877
- readonly text: Schema.String;
16878
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16879
- }>, Schema.Struct<{
16880
- readonly type: Schema.tag<"reasoning">;
16881
- readonly text: Schema.String;
16882
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16883
- readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
16884
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
16885
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16886
- }>>>, Schema.optionalKey<Schema.Struct<{
16887
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
16888
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16889
- }>>, never, never>;
16890
- }>, Schema.Struct<{
16891
- readonly type: Schema.tag<"tool">;
16892
- readonly id: Schema.String;
16893
- readonly name: Schema.String;
16894
- readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
16895
- readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16896
- readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
16897
- readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
16898
- readonly status: Schema.tag<"streaming">;
16899
- readonly input: Schema.String;
16900
- }>, Schema.Struct<{
16901
- readonly status: Schema.tag<"running">;
16902
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
16903
- readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
16904
- }>, Schema.Struct<{
16905
- readonly status: Schema.tag<"completed">;
16906
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
16907
- readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
16908
- readonly type: Schema.Literal<"text">;
16909
- readonly text: Schema.String;
16910
- }>, Schema.Struct<{
16911
- readonly type: Schema.Literal<"file">;
16912
- readonly uri: Schema.String;
16913
- readonly mime: Schema.String;
16914
- readonly name: Schema.optional<Schema.String>;
16915
- }>]>>;
16916
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
16917
- }>, Schema.Struct<{
16918
- readonly status: Schema.tag<"error">;
16919
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
16920
- readonly error: Schema.Struct<{
16921
- readonly type: Schema.String;
16922
- readonly message: Schema.String;
16923
- readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
16924
- }>;
16925
- readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
16926
- readonly type: Schema.Literal<"text">;
16927
- readonly text: Schema.String;
16928
- }>, Schema.Struct<{
16929
- readonly type: Schema.Literal<"file">;
16930
- readonly uri: Schema.String;
16931
- readonly mime: Schema.String;
16932
- readonly name: Schema.optional<Schema.String>;
16933
- }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
16934
- readonly type: Schema.Literal<"text">;
16935
- readonly text: Schema.String;
16936
- }>, Schema.Struct<{
16937
- readonly type: Schema.Literal<"file">;
16938
- readonly uri: Schema.String;
16939
- readonly mime: Schema.String;
16940
- readonly name: Schema.optional<Schema.String>;
16941
- }>]>>>, never, never>;
16942
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
16943
- }>]>;
16944
- readonly time: Schema.Struct<{
16945
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
16946
- readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16947
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
16948
- }>;
16949
- }>]>>>;
16950
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
16951
- create: () => string & import("effect/Brand").Brand<"SessionID">;
16952
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
16953
- };
16954
- }>;
16955
16497
  }]>;
16956
16498
  export type DurableEvent = typeof Durable.Type;
16957
16499
  export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<readonly [...((Schema.Struct<{
@@ -17057,15 +16599,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
17057
16599
  }>, never, never>;
17058
16600
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
17059
16601
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
17060
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
17061
- readonly action: Schema.String;
17062
- readonly resource: Schema.String;
17063
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
17064
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
17065
- readonly action: Schema.String;
17066
- readonly resource: Schema.String;
17067
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
17068
- }>>>, never, never>;
17069
16602
  readonly version: Schema.String;
17070
16603
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17071
16604
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -17151,15 +16684,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
17151
16684
  }>, never, never>;
17152
16685
  /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
17153
16686
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
17154
- readonly permissions: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
17155
- readonly action: Schema.String;
17156
- readonly resource: Schema.String;
17157
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
17158
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
17159
- readonly action: Schema.String;
17160
- readonly resource: Schema.String;
17161
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
17162
- }>>>, never, never>;
17163
16687
  readonly version: Schema.String;
17164
16688
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17165
16689
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -17542,7 +17066,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
17542
17066
  };
17543
17067
  readonly created: Schema.Finite;
17544
17068
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17545
- readonly type: Schema.Literal<"session.permissions.updated">;
17069
+ readonly type: Schema.Literal<"session.viewed">;
17546
17070
  readonly durable: Schema.Struct<{
17547
17071
  readonly aggregateID: Schema.String;
17548
17072
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -17568,29 +17092,23 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
17568
17092
  }>, never, never>;
17569
17093
  }>>, never, never>;
17570
17094
  readonly data: Schema.Struct<{
17571
- readonly permissions: Schema.$Array<Schema.Struct<{
17572
- readonly action: Schema.String;
17573
- readonly resource: Schema.String;
17574
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
17575
- }>>;
17095
+ /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
17096
+ readonly idle: Schema.Finite;
17576
17097
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17577
17098
  create: () => string & import("effect/Brand").Brand<"SessionID">;
17578
17099
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
17579
17100
  };
17580
17101
  }>;
17581
17102
  }> & {
17582
- type: "session.permissions.updated";
17103
+ type: "session.viewed";
17583
17104
  durability: "durable";
17584
17105
  durable: {
17585
17106
  readonly version: number;
17586
17107
  readonly aggregate: string;
17587
17108
  };
17588
17109
  data: Schema.Struct<{
17589
- readonly permissions: Schema.$Array<Schema.Struct<{
17590
- readonly action: Schema.String;
17591
- readonly resource: Schema.String;
17592
- readonly effect: Schema.Literals<readonly ["allow", "deny", "ask"]>;
17593
- }>>;
17110
+ /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
17111
+ readonly idle: Schema.Finite;
17594
17112
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17595
17113
  create: () => string & import("effect/Brand").Brand<"SessionID">;
17596
17114
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -17602,7 +17120,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
17602
17120
  };
17603
17121
  readonly created: Schema.Finite;
17604
17122
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17605
- readonly type: Schema.Literal<"session.viewed">;
17123
+ readonly type: Schema.Literal<"session.message.content.updated">;
17606
17124
  readonly durable: Schema.Struct<{
17607
17125
  readonly aggregateID: Schema.String;
17608
17126
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -17628,24 +17146,178 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
17628
17146
  }>, never, never>;
17629
17147
  }>>, never, never>;
17630
17148
  readonly data: Schema.Struct<{
17631
- /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
17632
- readonly idle: Schema.Finite;
17633
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17634
- create: () => string & import("effect/Brand").Brand<"SessionID">;
17635
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
17149
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
17150
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
17151
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
17636
17152
  };
17637
- }>;
17638
- }> & {
17639
- type: "session.viewed";
17640
- durability: "durable";
17641
- durable: {
17642
- readonly version: number;
17643
- readonly aggregate: string;
17644
- };
17645
- data: Schema.Struct<{
17646
- /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
17647
- readonly idle: Schema.Finite;
17648
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17153
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
17154
+ readonly type: Schema.tag<"text">;
17155
+ readonly text: Schema.String;
17156
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17157
+ }>, Schema.Struct<{
17158
+ readonly type: Schema.tag<"reasoning">;
17159
+ readonly text: Schema.String;
17160
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17161
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
17162
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
17163
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17164
+ }>>>, Schema.optionalKey<Schema.Struct<{
17165
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
17166
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17167
+ }>>, never, never>;
17168
+ }>, Schema.Struct<{
17169
+ readonly type: Schema.tag<"tool">;
17170
+ readonly id: Schema.String;
17171
+ readonly name: Schema.String;
17172
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
17173
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17174
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17175
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
17176
+ readonly status: Schema.tag<"streaming">;
17177
+ readonly input: Schema.String;
17178
+ }>, Schema.Struct<{
17179
+ readonly status: Schema.tag<"running">;
17180
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
17181
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
17182
+ }>, Schema.Struct<{
17183
+ readonly status: Schema.tag<"completed">;
17184
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
17185
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
17186
+ readonly type: Schema.Literal<"text">;
17187
+ readonly text: Schema.String;
17188
+ }>, Schema.Struct<{
17189
+ readonly type: Schema.Literal<"file">;
17190
+ readonly uri: Schema.String;
17191
+ readonly mime: Schema.String;
17192
+ readonly name: Schema.optional<Schema.String>;
17193
+ }>]>>;
17194
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
17195
+ }>, Schema.Struct<{
17196
+ readonly status: Schema.tag<"error">;
17197
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
17198
+ readonly error: Schema.Struct<{
17199
+ readonly type: Schema.String;
17200
+ readonly message: Schema.String;
17201
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
17202
+ }>;
17203
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
17204
+ readonly type: Schema.Literal<"text">;
17205
+ readonly text: Schema.String;
17206
+ }>, Schema.Struct<{
17207
+ readonly type: Schema.Literal<"file">;
17208
+ readonly uri: Schema.String;
17209
+ readonly mime: Schema.String;
17210
+ readonly name: Schema.optional<Schema.String>;
17211
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
17212
+ readonly type: Schema.Literal<"text">;
17213
+ readonly text: Schema.String;
17214
+ }>, Schema.Struct<{
17215
+ readonly type: Schema.Literal<"file">;
17216
+ readonly uri: Schema.String;
17217
+ readonly mime: Schema.String;
17218
+ readonly name: Schema.optional<Schema.String>;
17219
+ }>]>>>, never, never>;
17220
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
17221
+ }>]>;
17222
+ readonly time: Schema.Struct<{
17223
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
17224
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17225
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17226
+ }>;
17227
+ }>]>>>;
17228
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17229
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
17230
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
17231
+ };
17232
+ }>;
17233
+ }> & {
17234
+ type: "session.message.content.updated";
17235
+ durability: "durable";
17236
+ durable: {
17237
+ readonly version: number;
17238
+ readonly aggregate: string;
17239
+ };
17240
+ data: Schema.Struct<{
17241
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
17242
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
17243
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
17244
+ };
17245
+ readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
17246
+ readonly type: Schema.tag<"text">;
17247
+ readonly text: Schema.String;
17248
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17249
+ }>, Schema.Struct<{
17250
+ readonly type: Schema.tag<"reasoning">;
17251
+ readonly text: Schema.String;
17252
+ readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17253
+ readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
17254
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
17255
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17256
+ }>>>, Schema.optionalKey<Schema.Struct<{
17257
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
17258
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17259
+ }>>, never, never>;
17260
+ }>, Schema.Struct<{
17261
+ readonly type: Schema.tag<"tool">;
17262
+ readonly id: Schema.String;
17263
+ readonly name: Schema.String;
17264
+ readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
17265
+ readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17266
+ readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
17267
+ readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
17268
+ readonly status: Schema.tag<"streaming">;
17269
+ readonly input: Schema.String;
17270
+ }>, Schema.Struct<{
17271
+ readonly status: Schema.tag<"running">;
17272
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
17273
+ readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
17274
+ }>, Schema.Struct<{
17275
+ readonly status: Schema.tag<"completed">;
17276
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
17277
+ readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
17278
+ readonly type: Schema.Literal<"text">;
17279
+ readonly text: Schema.String;
17280
+ }>, Schema.Struct<{
17281
+ readonly type: Schema.Literal<"file">;
17282
+ readonly uri: Schema.String;
17283
+ readonly mime: Schema.String;
17284
+ readonly name: Schema.optional<Schema.String>;
17285
+ }>]>>;
17286
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
17287
+ }>, Schema.Struct<{
17288
+ readonly status: Schema.tag<"error">;
17289
+ readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
17290
+ readonly error: Schema.Struct<{
17291
+ readonly type: Schema.String;
17292
+ readonly message: Schema.String;
17293
+ readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
17294
+ }>;
17295
+ readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
17296
+ readonly type: Schema.Literal<"text">;
17297
+ readonly text: Schema.String;
17298
+ }>, Schema.Struct<{
17299
+ readonly type: Schema.Literal<"file">;
17300
+ readonly uri: Schema.String;
17301
+ readonly mime: Schema.String;
17302
+ readonly name: Schema.optional<Schema.String>;
17303
+ }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
17304
+ readonly type: Schema.Literal<"text">;
17305
+ readonly text: Schema.String;
17306
+ }>, Schema.Struct<{
17307
+ readonly type: Schema.Literal<"file">;
17308
+ readonly uri: Schema.String;
17309
+ readonly mime: Schema.String;
17310
+ readonly name: Schema.optional<Schema.String>;
17311
+ }>]>>>, never, never>;
17312
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
17313
+ }>]>;
17314
+ readonly time: Schema.Struct<{
17315
+ readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
17316
+ readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17317
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
17318
+ }>;
17319
+ }>]>>>;
17320
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
17649
17321
  create: () => string & import("effect/Brand").Brand<"SessionID">;
17650
17322
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
17651
17323
  };
@@ -20222,28 +19894,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
20222
19894
  }>>, never, never>;
20223
19895
  readonly text: Schema.String;
20224
19896
  readonly recent: Schema.String;
20225
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
20226
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20227
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
20228
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20229
- }>, never, never>;
20230
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20231
- readonly input: Schema.Finite;
20232
- readonly output: Schema.Finite;
20233
- readonly reasoning: Schema.Finite;
20234
- readonly cache: Schema.Struct<{
20235
- readonly read: Schema.Finite;
20236
- readonly write: Schema.Finite;
20237
- }>;
20238
- }>>>, Schema.optionalKey<Schema.Struct<{
20239
- readonly input: Schema.Finite;
20240
- readonly output: Schema.Finite;
20241
- readonly reasoning: Schema.Finite;
20242
- readonly cache: Schema.Struct<{
20243
- readonly read: Schema.Finite;
20244
- readonly write: Schema.Finite;
20245
- }>;
20246
- }>>, never, never>;
20247
19897
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
20248
19898
  create: () => string & import("effect/Brand").Brand<"SessionID">;
20249
19899
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -20353,28 +20003,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
20353
20003
  }>>, never, never>;
20354
20004
  readonly text: Schema.String;
20355
20005
  readonly recent: Schema.String;
20356
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
20357
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20358
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
20359
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20360
- }>, never, never>;
20361
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20362
- readonly input: Schema.Finite;
20363
- readonly output: Schema.Finite;
20364
- readonly reasoning: Schema.Finite;
20365
- readonly cache: Schema.Struct<{
20366
- readonly read: Schema.Finite;
20367
- readonly write: Schema.Finite;
20368
- }>;
20369
- }>>>, Schema.optionalKey<Schema.Struct<{
20370
- readonly input: Schema.Finite;
20371
- readonly output: Schema.Finite;
20372
- readonly reasoning: Schema.Finite;
20373
- readonly cache: Schema.Struct<{
20374
- readonly read: Schema.Finite;
20375
- readonly write: Schema.Finite;
20376
- }>;
20377
- }>>, never, never>;
20378
20006
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
20379
20007
  create: () => string & import("effect/Brand").Brand<"SessionID">;
20380
20008
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -20425,28 +20053,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
20425
20053
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
20426
20054
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
20427
20055
  }>, never, never>;
20428
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
20429
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20430
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
20431
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20432
- }>, never, never>;
20433
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20434
- readonly input: Schema.Finite;
20435
- readonly output: Schema.Finite;
20436
- readonly reasoning: Schema.Finite;
20437
- readonly cache: Schema.Struct<{
20438
- readonly read: Schema.Finite;
20439
- readonly write: Schema.Finite;
20440
- }>;
20441
- }>>>, Schema.optionalKey<Schema.Struct<{
20442
- readonly input: Schema.Finite;
20443
- readonly output: Schema.Finite;
20444
- readonly reasoning: Schema.Finite;
20445
- readonly cache: Schema.Struct<{
20446
- readonly read: Schema.Finite;
20447
- readonly write: Schema.Finite;
20448
- }>;
20449
- }>>, never, never>;
20450
20056
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
20451
20057
  create: () => string & import("effect/Brand").Brand<"SessionID">;
20452
20058
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -20473,28 +20079,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
20473
20079
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
20474
20080
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
20475
20081
  }>, never, never>;
20476
- readonly cost: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Finite, "Money.USD"> & {
20477
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20478
- }>>, Schema.optionalKey<Schema.brand<Schema.Finite, "Money.USD"> & {
20479
- zero: number & import("effect/Brand").Brand<"Money.USD">;
20480
- }>, never, never>;
20481
- readonly tokens: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20482
- readonly input: Schema.Finite;
20483
- readonly output: Schema.Finite;
20484
- readonly reasoning: Schema.Finite;
20485
- readonly cache: Schema.Struct<{
20486
- readonly read: Schema.Finite;
20487
- readonly write: Schema.Finite;
20488
- }>;
20489
- }>>>, Schema.optionalKey<Schema.Struct<{
20490
- readonly input: Schema.Finite;
20491
- readonly output: Schema.Finite;
20492
- readonly reasoning: Schema.Finite;
20493
- readonly cache: Schema.Struct<{
20494
- readonly read: Schema.Finite;
20495
- readonly write: Schema.Finite;
20496
- }>;
20497
- }>>, never, never>;
20498
20082
  readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
20499
20083
  create: () => string & import("effect/Brand").Brand<"SessionID">;
20500
20084
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -20776,214 +20360,6 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Union<re
20776
20360
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
20777
20361
  };
20778
20362
  }>;
20779
- }, Schema.Struct<{
20780
- readonly id: Schema.brand<Schema.String, "Event.ID"> & {
20781
- create: () => string & import("effect/Brand").Brand<"Event.ID">;
20782
- };
20783
- readonly created: Schema.Finite;
20784
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20785
- readonly type: Schema.Literal<"session.message.content.updated">;
20786
- readonly durable: Schema.Struct<{
20787
- readonly aggregateID: Schema.String;
20788
- readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
20789
- readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
20790
- }>;
20791
- readonly location: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20792
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
20793
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
20794
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
20795
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
20796
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
20797
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
20798
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
20799
- }>, never, never>;
20800
- }>>>, Schema.optionalKey<Schema.Struct<{
20801
- readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
20802
- readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Workspace.ID"> & {
20803
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
20804
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
20805
- }>>, Schema.optionalKey<Schema.brand<Schema.String, "Workspace.ID"> & {
20806
- ascending: (id?: string) => string & import("effect/Brand").Brand<"Workspace.ID">;
20807
- create: () => string & import("effect/Brand").Brand<"Workspace.ID">;
20808
- }>, never, never>;
20809
- }>>, never, never>;
20810
- readonly data: Schema.Struct<{
20811
- readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
20812
- create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
20813
- fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
20814
- };
20815
- readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
20816
- readonly type: Schema.tag<"text">;
20817
- readonly text: Schema.String;
20818
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20819
- }>, Schema.Struct<{
20820
- readonly type: Schema.tag<"reasoning">;
20821
- readonly text: Schema.String;
20822
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20823
- readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20824
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
20825
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20826
- }>>>, Schema.optionalKey<Schema.Struct<{
20827
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
20828
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20829
- }>>, never, never>;
20830
- }>, Schema.Struct<{
20831
- readonly type: Schema.tag<"tool">;
20832
- readonly id: Schema.String;
20833
- readonly name: Schema.String;
20834
- readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
20835
- readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20836
- readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20837
- readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
20838
- readonly status: Schema.tag<"streaming">;
20839
- readonly input: Schema.String;
20840
- }>, Schema.Struct<{
20841
- readonly status: Schema.tag<"running">;
20842
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
20843
- readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
20844
- }>, Schema.Struct<{
20845
- readonly status: Schema.tag<"completed">;
20846
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
20847
- readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
20848
- readonly type: Schema.Literal<"text">;
20849
- readonly text: Schema.String;
20850
- }>, Schema.Struct<{
20851
- readonly type: Schema.Literal<"file">;
20852
- readonly uri: Schema.String;
20853
- readonly mime: Schema.String;
20854
- readonly name: Schema.optional<Schema.String>;
20855
- }>]>>;
20856
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
20857
- }>, Schema.Struct<{
20858
- readonly status: Schema.tag<"error">;
20859
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
20860
- readonly error: Schema.Struct<{
20861
- readonly type: Schema.String;
20862
- readonly message: Schema.String;
20863
- readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
20864
- }>;
20865
- readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
20866
- readonly type: Schema.Literal<"text">;
20867
- readonly text: Schema.String;
20868
- }>, Schema.Struct<{
20869
- readonly type: Schema.Literal<"file">;
20870
- readonly uri: Schema.String;
20871
- readonly mime: Schema.String;
20872
- readonly name: Schema.optional<Schema.String>;
20873
- }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
20874
- readonly type: Schema.Literal<"text">;
20875
- readonly text: Schema.String;
20876
- }>, Schema.Struct<{
20877
- readonly type: Schema.Literal<"file">;
20878
- readonly uri: Schema.String;
20879
- readonly mime: Schema.String;
20880
- readonly name: Schema.optional<Schema.String>;
20881
- }>]>>>, never, never>;
20882
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
20883
- }>]>;
20884
- readonly time: Schema.Struct<{
20885
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
20886
- readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20887
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20888
- }>;
20889
- }>]>>>;
20890
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
20891
- create: () => string & import("effect/Brand").Brand<"SessionID">;
20892
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
20893
- };
20894
- }>;
20895
- }> & {
20896
- type: "session.message.content.updated";
20897
- durability: "durable";
20898
- durable: {
20899
- readonly version: number;
20900
- readonly aggregate: string;
20901
- };
20902
- data: Schema.Struct<{
20903
- readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
20904
- create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
20905
- fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
20906
- };
20907
- readonly content: Schema.$Array<Schema.toEncoded<Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
20908
- readonly type: Schema.tag<"text">;
20909
- readonly text: Schema.String;
20910
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20911
- }>, Schema.Struct<{
20912
- readonly type: Schema.tag<"reasoning">;
20913
- readonly text: Schema.String;
20914
- readonly state: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20915
- readonly time: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
20916
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
20917
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20918
- }>>>, Schema.optionalKey<Schema.Struct<{
20919
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
20920
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20921
- }>>, never, never>;
20922
- }>, Schema.Struct<{
20923
- readonly type: Schema.tag<"tool">;
20924
- readonly id: Schema.String;
20925
- readonly name: Schema.String;
20926
- readonly executed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Boolean>>, Schema.optionalKey<Schema.Boolean>, never, never>;
20927
- readonly providerState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20928
- readonly providerResultState: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
20929
- readonly state: Schema.toTaggedUnion<"status", readonly [Schema.Struct<{
20930
- readonly status: Schema.tag<"streaming">;
20931
- readonly input: Schema.String;
20932
- }>, Schema.Struct<{
20933
- readonly status: Schema.tag<"running">;
20934
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
20935
- readonly metadata: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
20936
- }>, Schema.Struct<{
20937
- readonly status: Schema.tag<"completed">;
20938
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
20939
- readonly content: Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
20940
- readonly type: Schema.Literal<"text">;
20941
- readonly text: Schema.String;
20942
- }>, Schema.Struct<{
20943
- readonly type: Schema.Literal<"file">;
20944
- readonly uri: Schema.String;
20945
- readonly mime: Schema.String;
20946
- readonly name: Schema.optional<Schema.String>;
20947
- }>]>>;
20948
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
20949
- }>, Schema.Struct<{
20950
- readonly status: Schema.tag<"error">;
20951
- readonly input: Schema.$Record<Schema.String, Schema.Unknown>;
20952
- readonly error: Schema.Struct<{
20953
- readonly type: Schema.String;
20954
- readonly message: Schema.String;
20955
- readonly status: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
20956
- }>;
20957
- readonly content: Schema.decodeTo<Schema.optional<Schema.toType<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
20958
- readonly type: Schema.Literal<"text">;
20959
- readonly text: Schema.String;
20960
- }>, Schema.Struct<{
20961
- readonly type: Schema.Literal<"file">;
20962
- readonly uri: Schema.String;
20963
- readonly mime: Schema.String;
20964
- readonly name: Schema.optional<Schema.String>;
20965
- }>]>>>>, Schema.optionalKey<Schema.NonEmptyArray<Schema.Union<readonly [Schema.Struct<{
20966
- readonly type: Schema.Literal<"text">;
20967
- readonly text: Schema.String;
20968
- }>, Schema.Struct<{
20969
- readonly type: Schema.Literal<"file">;
20970
- readonly uri: Schema.String;
20971
- readonly mime: Schema.String;
20972
- readonly name: Schema.optional<Schema.String>;
20973
- }>]>>>, never, never>;
20974
- readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>, never, never>;
20975
- }>]>;
20976
- readonly time: Schema.Struct<{
20977
- readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
20978
- readonly ran: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20979
- readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>>, Schema.optionalKey<Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>>, never, never>;
20980
- }>;
20981
- }>]>>>;
20982
- readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
20983
- create: () => string & import("effect/Brand").Brand<"SessionID">;
20984
- descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
20985
- };
20986
- }>;
20987
20363
  }]>, ...((Schema.Struct<{
20988
20364
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
20989
20365
  create: () => string & import("effect/Brand").Brand<"Event.ID">;