@opencode-ai/protocol 0.0.0-next-15718 → 0.0.0-next-15747

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 (30) hide show
  1. package/dist/api.d.ts +2 -2
  2. package/dist/groups/agent.d.ts +3 -3
  3. package/dist/groups/command.d.ts +3 -3
  4. package/dist/groups/credential.d.ts +6 -6
  5. package/dist/groups/debug.d.ts +3 -3
  6. package/dist/groups/event.d.ts +2757 -2103
  7. package/dist/groups/form.d.ts +15 -15
  8. package/dist/groups/fs.d.ts +6 -6
  9. package/dist/groups/generate.d.ts +4 -4
  10. package/dist/groups/health.d.ts +4 -4
  11. package/dist/groups/integration.d.ts +32 -32
  12. package/dist/groups/location.d.ts +2 -2
  13. package/dist/groups/mcp.d.ts +5 -5
  14. package/dist/groups/message.d.ts +28 -28
  15. package/dist/groups/model.d.ts +5 -5
  16. package/dist/groups/permission.d.ts +15 -15
  17. package/dist/groups/plugin.d.ts +3 -3
  18. package/dist/groups/project-copy.d.ts +10 -10
  19. package/dist/groups/project.d.ts +7 -7
  20. package/dist/groups/provider.d.ts +6 -6
  21. package/dist/groups/pty.d.ts +19 -19
  22. package/dist/groups/question.d.ts +8 -8
  23. package/dist/groups/reference.d.ts +3 -3
  24. package/dist/groups/server.d.ts +2 -2
  25. package/dist/groups/session.d.ts +1215 -971
  26. package/dist/groups/session.js +14 -0
  27. package/dist/groups/shell.d.ts +18 -18
  28. package/dist/groups/skill.d.ts +3 -3
  29. package/dist/groups/vcs.d.ts +5 -5
  30. package/package.json +3 -3
package/dist/groups/session.d.ts CHANGED
@@ -7,7 +7,6 @@ import { ConflictError, CommandEvaluationError, CommandNotFoundError, InvalidCur
7
7
  import { SessionEvent } from "@opencode-ai/schema/session-event";
8
8
  declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
9
9
  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
10
- readonly search: Schema.optional<Schema.String>;
11
10
  readonly workspace: Schema.optional<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
12
11
  ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
13
12
  create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
@@ -16,6 +15,7 @@ declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
16
15
  create: () => string & import("effect/Brand").Brand<"SessionID">;
17
16
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
18
17
  }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
18
+ readonly search: Schema.optional<Schema.String>;
19
19
  readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
20
20
  readonly anchor: Schema.Struct<{
21
21
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
@@ -26,7 +26,6 @@ declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
26
26
  readonly direction: Schema.Literals<readonly ["previous", "next"]>;
27
27
  }>;
28
28
  }>, Schema.Struct<{
29
- readonly search: Schema.optional<Schema.String>;
30
29
  readonly project: Schema.brand<Schema.String, "Project.ID"> & {
31
30
  global: string & import("effect/Brand").Brand<"Project.ID">;
32
31
  };
@@ -39,6 +38,7 @@ declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
39
38
  create: () => string & import("effect/Brand").Brand<"SessionID">;
40
39
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
41
40
  }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
41
+ readonly search: Schema.optional<Schema.String>;
42
42
  readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
43
43
  readonly anchor: Schema.Struct<{
44
44
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
@@ -49,7 +49,6 @@ declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
49
49
  readonly direction: Schema.Literals<readonly ["previous", "next"]>;
50
50
  }>;
51
51
  }>, Schema.Struct<{
52
- readonly search: Schema.optional<Schema.String>;
53
52
  readonly workspace: Schema.optional<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
54
53
  ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
55
54
  create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
@@ -58,6 +57,7 @@ declare const SessionsCursorInput: Schema.Union<readonly [Schema.Struct<{
58
57
  create: () => string & import("effect/Brand").Brand<"SessionID">;
59
58
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
60
59
  }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
60
+ readonly search: Schema.optional<Schema.String>;
61
61
  readonly order: Schema.optional<Schema.Union<readonly [Schema.Literal<"asc">, Schema.Literal<"desc">]>>;
62
62
  readonly anchor: Schema.Struct<{
63
63
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
@@ -72,36 +72,45 @@ export declare const SessionsCursor: Schema.brand<Schema.String, "SessionsCursor
72
72
  make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
73
73
  parse: (input: string) => Effect.Effect<{
74
74
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
75
- readonly anchor: {
76
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
77
- readonly time: number;
78
- readonly direction: "previous" | "next";
79
- };
80
- readonly search?: string | undefined;
75
+ readonly anchor: Schema.Struct.ReadonlySide<{
76
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
77
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
78
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
79
+ };
80
+ readonly time: Schema.Finite;
81
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
82
+ }, "Type">;
81
83
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
82
84
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
85
+ readonly search?: string | undefined;
83
86
  readonly order?: "asc" | "desc" | undefined;
84
87
  } | {
85
88
  readonly project: string & import("effect/Brand").Brand<"Project.ID">;
86
- readonly anchor: {
87
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
88
- readonly time: number;
89
- readonly direction: "previous" | "next";
90
- };
91
- readonly search?: string | undefined;
89
+ readonly anchor: Schema.Struct.ReadonlySide<{
90
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
91
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
92
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
93
+ };
94
+ readonly time: Schema.Finite;
95
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
96
+ }, "Type">;
92
97
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
93
98
  readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
94
99
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
100
+ readonly search?: string | undefined;
95
101
  readonly order?: "asc" | "desc" | undefined;
96
102
  } | {
97
- readonly anchor: {
98
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
99
- readonly time: number;
100
- readonly direction: "previous" | "next";
101
- };
102
- readonly search?: string | undefined;
103
+ readonly anchor: Schema.Struct.ReadonlySide<{
104
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
105
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
106
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
107
+ };
108
+ readonly time: Schema.Finite;
109
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
110
+ }, "Type">;
103
111
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
104
112
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
113
+ readonly search?: string | undefined;
105
114
  readonly order?: "asc" | "desc" | undefined;
106
115
  }, "Invalid cursor", never>;
107
116
  };
@@ -125,7 +134,7 @@ export declare const SessionsQuery: Schema.Struct<{
125
134
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
126
135
  }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
127
136
  }>;
128
- export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(sessionLocationMiddleware: Context.Key<I, S>) => HttpApiGroup.HttpApiGroup<"server.session", HttpApiEndpoint.HttpApiEndpoint<"session.list", "GET", "/api/session", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<Schema.Struct<{
137
+ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(sessionLocationMiddleware: Context.Key<I, S>) => HttpApiGroup.HttpApiGroup<"server.session", HttpApiEndpoint.HttpApiEndpoint<"session.list", "GET", "/api/session", never, Schema.toCodecStringTree<Schema.Struct<{
129
138
  readonly directory: Schema.optional<Schema.brand<Schema.String, "AbsolutePath">>;
130
139
  readonly project: Schema.optional<Schema.brand<Schema.String, "Project.ID"> & {
131
140
  global: string & import("effect/Brand").Brand<"Project.ID">;
@@ -143,7 +152,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
143
152
  create: () => string & import("effect/Brand").Brand<"SessionID">;
144
153
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
145
154
  }, Schema.decodeTo<Schema.Null, Schema.Literal<"null">, never, never>]>>;
146
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
155
+ }>>, never, never, Schema.toCodecJson<Schema.Struct<{
147
156
  readonly data: Schema.$Array<Schema.Struct<{
148
157
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
149
158
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -306,36 +315,45 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
306
315
  make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
307
316
  parse: (input: string) => Effect.Effect<{
308
317
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
309
- readonly anchor: {
310
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
311
- readonly time: number;
312
- readonly direction: "previous" | "next";
313
- };
314
- readonly search?: string | undefined;
318
+ readonly anchor: Schema.Struct.ReadonlySide<{
319
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
320
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
321
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
322
+ };
323
+ readonly time: Schema.Finite;
324
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
325
+ }, "Type">;
315
326
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
316
327
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
328
+ readonly search?: string | undefined;
317
329
  readonly order?: "asc" | "desc" | undefined;
318
330
  } | {
319
331
  readonly project: string & import("effect/Brand").Brand<"Project.ID">;
320
- readonly anchor: {
321
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
322
- readonly time: number;
323
- readonly direction: "previous" | "next";
324
- };
325
- readonly search?: string | undefined;
332
+ readonly anchor: Schema.Struct.ReadonlySide<{
333
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
334
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
335
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
336
+ };
337
+ readonly time: Schema.Finite;
338
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
339
+ }, "Type">;
326
340
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
327
341
  readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
328
342
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
343
+ readonly search?: string | undefined;
329
344
  readonly order?: "asc" | "desc" | undefined;
330
345
  } | {
331
- readonly anchor: {
332
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
333
- readonly time: number;
334
- readonly direction: "previous" | "next";
335
- };
336
- readonly search?: string | undefined;
346
+ readonly anchor: Schema.Struct.ReadonlySide<{
347
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
348
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
349
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
350
+ };
351
+ readonly time: Schema.Finite;
352
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
353
+ }, "Type">;
337
354
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
338
355
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
356
+ readonly search?: string | undefined;
339
357
  readonly order?: "asc" | "desc" | undefined;
340
358
  }, "Invalid cursor", never>;
341
359
  }>;
@@ -343,41 +361,50 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
343
361
  make: (input: typeof SessionsCursorInput.Type) => string & import("effect/Brand").Brand<"SessionsCursor">;
344
362
  parse: (input: string) => Effect.Effect<{
345
363
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
346
- readonly anchor: {
347
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
348
- readonly time: number;
349
- readonly direction: "previous" | "next";
350
- };
351
- readonly search?: string | undefined;
364
+ readonly anchor: Schema.Struct.ReadonlySide<{
365
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
366
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
367
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
368
+ };
369
+ readonly time: Schema.Finite;
370
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
371
+ }, "Type">;
352
372
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
353
373
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
374
+ readonly search?: string | undefined;
354
375
  readonly order?: "asc" | "desc" | undefined;
355
376
  } | {
356
377
  readonly project: string & import("effect/Brand").Brand<"Project.ID">;
357
- readonly anchor: {
358
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
359
- readonly time: number;
360
- readonly direction: "previous" | "next";
361
- };
362
- readonly search?: string | undefined;
378
+ readonly anchor: Schema.Struct.ReadonlySide<{
379
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
380
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
381
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
382
+ };
383
+ readonly time: Schema.Finite;
384
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
385
+ }, "Type">;
363
386
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
364
387
  readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
365
388
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
389
+ readonly search?: string | undefined;
366
390
  readonly order?: "asc" | "desc" | undefined;
367
391
  } | {
368
- readonly anchor: {
369
- readonly id: string & import("effect/Brand").Brand<"SessionID">;
370
- readonly time: number;
371
- readonly direction: "previous" | "next";
372
- };
373
- readonly search?: string | undefined;
392
+ readonly anchor: Schema.Struct.ReadonlySide<{
393
+ readonly id: Schema.brand<Schema.String, "SessionID"> & {
394
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
395
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
396
+ };
397
+ readonly time: Schema.Finite;
398
+ readonly direction: Schema.Literals<readonly ["previous", "next"]>;
399
+ }, "Type">;
374
400
  readonly workspace?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
375
401
  readonly parentID?: (string & import("effect/Brand").Brand<"SessionID">) | null | undefined;
402
+ readonly search?: string | undefined;
376
403
  readonly order?: "asc" | "desc" | undefined;
377
404
  }, "Invalid cursor", never>;
378
405
  }>;
379
406
  }>;
380
- }>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof InvalidCursorError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.create", "POST", "/api/session", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
407
+ }>>, Schema.toCodecJson<typeof InvalidRequestError | typeof InvalidCursorError>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.create", "POST", "/api/session", never, never, Schema.toCodecJson<Schema.Struct<{
381
408
  readonly id: Schema.optional<Schema.brand<Schema.String, "SessionID"> & {
382
409
  create: () => string & import("effect/Brand").Brand<"SessionID">;
383
410
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -416,7 +443,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
416
443
  create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
417
444
  }>, never, never>;
418
445
  }>>;
419
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
446
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
420
447
  readonly data: Schema.Struct<{
421
448
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
422
449
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -574,19 +601,19 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
574
601
  }>>>, never, never>;
575
602
  }>>, never, never>;
576
603
  }>;
577
- }>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.active", "GET", "/api/session/active", HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
604
+ }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.active", "GET", "/api/session/active", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
578
605
  readonly data: Schema.$Record<Schema.brand<Schema.String, "SessionID"> & {
579
606
  create: () => string & import("effect/Brand").Brand<"SessionID">;
580
607
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
581
608
  }, Schema.Struct<{
582
609
  readonly type: Schema.Literal<"running">;
583
610
  }>>;
584
- }>>, HttpApiEndpoint.Json<never>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.get", "GET", "/api/session/:sessionID", HttpApiEndpoint.StringTree<Schema.Struct<{
611
+ }>>, never, never, never> | HttpApiEndpoint.HttpApiEndpoint<"session.get", "GET", "/api/session/:sessionID", Schema.toCodecStringTree<Schema.Struct<{
585
612
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
586
613
  create: () => string & import("effect/Brand").Brand<"SessionID">;
587
614
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
588
615
  };
589
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
616
+ }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
590
617
  readonly data: Schema.Struct<{
591
618
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
592
619
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -744,22 +771,22 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
744
771
  }>>>, never, never>;
745
772
  }>>, never, never>;
746
773
  }>;
747
- }>>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.remove", "DELETE", "/api/session/:sessionID", HttpApiEndpoint.StringTree<Schema.Struct<{
774
+ }>>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.remove", "DELETE", "/api/session/:sessionID", Schema.toCodecStringTree<Schema.Struct<{
748
775
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
749
776
  create: () => string & import("effect/Brand").Brand<"SessionID">;
750
777
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
751
778
  };
752
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.fork", "POST", "/api/session/:sessionID/fork", HttpApiEndpoint.StringTree<Schema.Struct<{
779
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.fork", "POST", "/api/session/:sessionID/fork", Schema.toCodecStringTree<Schema.Struct<{
753
780
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
754
781
  create: () => string & import("effect/Brand").Brand<"SessionID">;
755
782
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
756
783
  };
757
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
784
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
758
785
  readonly messageID: Schema.optional<Schema.brand<Schema.String, "Session.Message.ID"> & {
759
786
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
760
787
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
761
788
  }>;
762
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
789
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
763
790
  readonly data: Schema.Struct<{
764
791
  readonly id: Schema.brand<Schema.String, "SessionID"> & {
765
792
  create: () => string & import("effect/Brand").Brand<"SessionID">;
@@ -917,19 +944,19 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
917
944
  }>>>, never, never>;
918
945
  }>>, never, never>;
919
946
  }>;
920
- }>>, HttpApiEndpoint.Json<typeof SessionNotFoundError | typeof MessageNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.switchAgent", "POST", "/api/session/:sessionID/agent", HttpApiEndpoint.StringTree<Schema.Struct<{
947
+ }>>, Schema.toCodecJson<typeof SessionNotFoundError | typeof MessageNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.switchAgent", "POST", "/api/session/:sessionID/agent", Schema.toCodecStringTree<Schema.Struct<{
921
948
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
922
949
  create: () => string & import("effect/Brand").Brand<"SessionID">;
923
950
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
924
951
  };
925
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
952
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
926
953
  readonly agent: Schema.brand<Schema.String, "Agent.ID">;
927
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.switchModel", "POST", "/api/session/:sessionID/model", HttpApiEndpoint.StringTree<Schema.Struct<{
954
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.switchModel", "POST", "/api/session/:sessionID/model", Schema.toCodecStringTree<Schema.Struct<{
928
955
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
929
956
  create: () => string & import("effect/Brand").Brand<"SessionID">;
930
957
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
931
958
  };
932
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
959
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
933
960
  readonly model: Schema.Struct<{
934
961
  readonly id: Schema.brand<Schema.String, "Model.ID">;
935
962
  readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
@@ -953,19 +980,19 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
953
980
  readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
954
981
  };
955
982
  };
956
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.rename", "POST", "/api/session/:sessionID/rename", HttpApiEndpoint.StringTree<Schema.Struct<{
983
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.rename", "POST", "/api/session/:sessionID/rename", Schema.toCodecStringTree<Schema.Struct<{
957
984
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
958
985
  create: () => string & import("effect/Brand").Brand<"SessionID">;
959
986
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
960
987
  };
961
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
988
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
962
989
  readonly title: Schema.String;
963
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.move", "POST", "/api/session/:sessionID/move", HttpApiEndpoint.StringTree<Schema.Struct<{
990
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.move", "POST", "/api/session/:sessionID/move", Schema.toCodecStringTree<Schema.Struct<{
964
991
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
965
992
  create: () => string & import("effect/Brand").Brand<"SessionID">;
966
993
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
967
994
  };
968
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
995
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
969
996
  readonly directory: Schema.brand<Schema.String, "AbsolutePath">;
970
997
  readonly workspaceID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "WorkspaceV2.ID"> & {
971
998
  ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
@@ -974,12 +1001,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
974
1001
  ascending: (id?: string) => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
975
1002
  create: () => string & import("effect/Brand").Brand<"WorkspaceV2.ID">;
976
1003
  }>, never, never>;
977
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.prompt", "POST", "/api/session/:sessionID/prompt", HttpApiEndpoint.StringTree<Schema.Struct<{
1004
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof InvalidRequestError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.prompt", "POST", "/api/session/:sessionID/prompt", Schema.toCodecStringTree<Schema.Struct<{
978
1005
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
979
1006
  create: () => string & import("effect/Brand").Brand<"SessionID">;
980
1007
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
981
1008
  };
982
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1009
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
983
1010
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
984
1011
  readonly delivery: Schema.optional<Schema.Literals<readonly ["steer", "queue"]>>;
985
1012
  readonly resume: Schema.optional<Schema.Boolean>;
@@ -1000,13 +1027,13 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1000
1027
  }> & {
1001
1028
  create: (input: PromptInput.FileAttachment) => {
1002
1029
  readonly uri: string;
1003
- readonly name?: string | undefined;
1004
1030
  readonly description?: string | undefined;
1005
- readonly mention?: {
1006
- readonly start: number;
1007
- readonly end: number;
1008
- readonly text: string;
1009
- } | undefined;
1031
+ readonly name?: string | undefined;
1032
+ readonly mention?: Schema.Struct.ReadonlySide<{
1033
+ readonly start: Schema.Finite;
1034
+ readonly end: Schema.Finite;
1035
+ readonly text: Schema.String;
1036
+ }, "Type"> | undefined;
1010
1037
  };
1011
1038
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
1012
1039
  readonly uri: Schema.String;
@@ -1024,13 +1051,13 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1024
1051
  }> & {
1025
1052
  create: (input: PromptInput.FileAttachment) => {
1026
1053
  readonly uri: string;
1027
- readonly name?: string | undefined;
1028
1054
  readonly description?: string | undefined;
1029
- readonly mention?: {
1030
- readonly start: number;
1031
- readonly end: number;
1032
- readonly text: string;
1033
- } | undefined;
1055
+ readonly name?: string | undefined;
1056
+ readonly mention?: Schema.Struct.ReadonlySide<{
1057
+ readonly start: Schema.Finite;
1058
+ readonly end: Schema.Finite;
1059
+ readonly text: Schema.String;
1060
+ }, "Type"> | undefined;
1034
1061
  };
1035
1062
  }>>, never, never>;
1036
1063
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -1060,7 +1087,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1060
1087
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
1061
1088
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
1062
1089
  }>;
1063
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1090
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1064
1091
  readonly data: Schema.Struct<{
1065
1092
  readonly type: Schema.tag<"user">;
1066
1093
  readonly data: Schema.Struct<{
@@ -1089,20 +1116,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1089
1116
  }> & {
1090
1117
  create: (input: SessionEvent.FileAttachment) => {
1091
1118
  readonly data: string;
1119
+ readonly source: Schema.Struct.ReadonlySide<{
1120
+ readonly type: Schema.Literal<"inline">;
1121
+ }, "Type"> | Schema.Struct.ReadonlySide<{
1122
+ readonly type: Schema.Literal<"uri">;
1123
+ readonly uri: Schema.String;
1124
+ }, "Type">;
1092
1125
  readonly mime: string;
1093
- readonly source: {
1094
- readonly type: "inline";
1095
- } | {
1096
- readonly type: "uri";
1097
- readonly uri: string;
1098
- };
1099
- readonly name?: string | undefined;
1100
1126
  readonly description?: string | undefined;
1101
- readonly mention?: {
1102
- readonly start: number;
1103
- readonly end: number;
1104
- readonly text: string;
1105
- } | undefined;
1127
+ readonly name?: string | undefined;
1128
+ readonly mention?: Schema.Struct.ReadonlySide<{
1129
+ readonly start: Schema.Finite;
1130
+ readonly end: Schema.Finite;
1131
+ readonly text: Schema.String;
1132
+ }, "Type"> | undefined;
1106
1133
  };
1107
1134
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
1108
1135
  readonly data: Schema.String;
@@ -1127,20 +1154,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1127
1154
  }> & {
1128
1155
  create: (input: SessionEvent.FileAttachment) => {
1129
1156
  readonly data: string;
1157
+ readonly source: Schema.Struct.ReadonlySide<{
1158
+ readonly type: Schema.Literal<"inline">;
1159
+ }, "Type"> | Schema.Struct.ReadonlySide<{
1160
+ readonly type: Schema.Literal<"uri">;
1161
+ readonly uri: Schema.String;
1162
+ }, "Type">;
1130
1163
  readonly mime: string;
1131
- readonly source: {
1132
- readonly type: "inline";
1133
- } | {
1134
- readonly type: "uri";
1135
- readonly uri: string;
1136
- };
1137
- readonly name?: string | undefined;
1138
1164
  readonly description?: string | undefined;
1139
- readonly mention?: {
1140
- readonly start: number;
1141
- readonly end: number;
1142
- readonly text: string;
1143
- } | undefined;
1165
+ readonly name?: string | undefined;
1166
+ readonly mention?: Schema.Struct.ReadonlySide<{
1167
+ readonly start: Schema.Finite;
1168
+ readonly end: Schema.Finite;
1169
+ readonly text: Schema.String;
1170
+ }, "Type"> | undefined;
1144
1171
  };
1145
1172
  }>>, never, never>;
1146
1173
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -1179,12 +1206,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1179
1206
  };
1180
1207
  readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
1181
1208
  }>;
1182
- }>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof ConflictError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.command", "POST", "/api/session/:sessionID/command", HttpApiEndpoint.StringTree<Schema.Struct<{
1209
+ }>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ConflictError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.command", "POST", "/api/session/:sessionID/command", Schema.toCodecStringTree<Schema.Struct<{
1183
1210
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1184
1211
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1185
1212
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1186
1213
  };
1187
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1214
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1188
1215
  readonly id: Schema.optional<Schema.brand<Schema.String, "Session.Message.ID"> & {
1189
1216
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
1190
1217
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -1231,13 +1258,13 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1231
1258
  }> & {
1232
1259
  create: (input: PromptInput.FileAttachment) => {
1233
1260
  readonly uri: string;
1234
- readonly name?: string | undefined;
1235
1261
  readonly description?: string | undefined;
1236
- readonly mention?: {
1237
- readonly start: number;
1238
- readonly end: number;
1239
- readonly text: string;
1240
- } | undefined;
1262
+ readonly name?: string | undefined;
1263
+ readonly mention?: Schema.Struct.ReadonlySide<{
1264
+ readonly start: Schema.Finite;
1265
+ readonly end: Schema.Finite;
1266
+ readonly text: Schema.String;
1267
+ }, "Type"> | undefined;
1241
1268
  };
1242
1269
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
1243
1270
  readonly uri: Schema.String;
@@ -1255,13 +1282,13 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1255
1282
  }> & {
1256
1283
  create: (input: PromptInput.FileAttachment) => {
1257
1284
  readonly uri: string;
1258
- readonly name?: string | undefined;
1259
1285
  readonly description?: string | undefined;
1260
- readonly mention?: {
1261
- readonly start: number;
1262
- readonly end: number;
1263
- readonly text: string;
1264
- } | undefined;
1286
+ readonly name?: string | undefined;
1287
+ readonly mention?: Schema.Struct.ReadonlySide<{
1288
+ readonly start: Schema.Finite;
1289
+ readonly end: Schema.Finite;
1290
+ readonly text: Schema.String;
1291
+ }, "Type"> | undefined;
1265
1292
  };
1266
1293
  }>>, never, never>;
1267
1294
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -1289,7 +1316,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1289
1316
  }>>>, never, never>;
1290
1317
  readonly delivery: Schema.optional<Schema.Literals<readonly ["steer", "queue"]>>;
1291
1318
  readonly resume: Schema.optional<Schema.Boolean>;
1292
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1319
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1293
1320
  readonly data: Schema.Struct<{
1294
1321
  readonly type: Schema.tag<"user">;
1295
1322
  readonly data: Schema.Struct<{
@@ -1318,20 +1345,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1318
1345
  }> & {
1319
1346
  create: (input: SessionEvent.FileAttachment) => {
1320
1347
  readonly data: string;
1348
+ readonly source: Schema.Struct.ReadonlySide<{
1349
+ readonly type: Schema.Literal<"inline">;
1350
+ }, "Type"> | Schema.Struct.ReadonlySide<{
1351
+ readonly type: Schema.Literal<"uri">;
1352
+ readonly uri: Schema.String;
1353
+ }, "Type">;
1321
1354
  readonly mime: string;
1322
- readonly source: {
1323
- readonly type: "inline";
1324
- } | {
1325
- readonly type: "uri";
1326
- readonly uri: string;
1327
- };
1328
- readonly name?: string | undefined;
1329
1355
  readonly description?: string | undefined;
1330
- readonly mention?: {
1331
- readonly start: number;
1332
- readonly end: number;
1333
- readonly text: string;
1334
- } | undefined;
1356
+ readonly name?: string | undefined;
1357
+ readonly mention?: Schema.Struct.ReadonlySide<{
1358
+ readonly start: Schema.Finite;
1359
+ readonly end: Schema.Finite;
1360
+ readonly text: Schema.String;
1361
+ }, "Type"> | undefined;
1335
1362
  };
1336
1363
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
1337
1364
  readonly data: Schema.String;
@@ -1356,20 +1383,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1356
1383
  }> & {
1357
1384
  create: (input: SessionEvent.FileAttachment) => {
1358
1385
  readonly data: string;
1386
+ readonly source: Schema.Struct.ReadonlySide<{
1387
+ readonly type: Schema.Literal<"inline">;
1388
+ }, "Type"> | Schema.Struct.ReadonlySide<{
1389
+ readonly type: Schema.Literal<"uri">;
1390
+ readonly uri: Schema.String;
1391
+ }, "Type">;
1359
1392
  readonly mime: string;
1360
- readonly source: {
1361
- readonly type: "inline";
1362
- } | {
1363
- readonly type: "uri";
1364
- readonly uri: string;
1365
- };
1366
- readonly name?: string | undefined;
1367
1393
  readonly description?: string | undefined;
1368
- readonly mention?: {
1369
- readonly start: number;
1370
- readonly end: number;
1371
- readonly text: string;
1372
- } | undefined;
1394
+ readonly name?: string | undefined;
1395
+ readonly mention?: Schema.Struct.ReadonlySide<{
1396
+ readonly start: Schema.Finite;
1397
+ readonly end: Schema.Finite;
1398
+ readonly text: Schema.String;
1399
+ }, "Type"> | undefined;
1373
1400
  };
1374
1401
  }>>, never, never>;
1375
1402
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -1408,24 +1435,24 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1408
1435
  };
1409
1436
  readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
1410
1437
  }>;
1411
- }>>, HttpApiEndpoint.Json<typeof InvalidRequestError | typeof ConflictError | typeof SessionNotFoundError | typeof CommandNotFoundError | typeof CommandEvaluationError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.skill", "POST", "/api/session/:sessionID/skill", HttpApiEndpoint.StringTree<Schema.Struct<{
1438
+ }>>, Schema.toCodecJson<typeof InvalidRequestError | typeof ConflictError | typeof SessionNotFoundError | typeof CommandNotFoundError | typeof CommandEvaluationError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.skill", "POST", "/api/session/:sessionID/skill", Schema.toCodecStringTree<Schema.Struct<{
1412
1439
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1413
1440
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1414
1441
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1415
1442
  };
1416
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1443
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1417
1444
  readonly id: Schema.optional<Schema.brand<Schema.String, "Session.Message.ID"> & {
1418
1445
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
1419
1446
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
1420
1447
  }>;
1421
1448
  readonly skill: Schema.brand<Schema.String, "Skill.ID">;
1422
1449
  readonly resume: Schema.optional<Schema.Boolean>;
1423
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError | typeof SkillNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.synthetic", "POST", "/api/session/:sessionID/synthetic", HttpApiEndpoint.StringTree<Schema.Struct<{
1450
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError | typeof SkillNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.synthetic", "POST", "/api/session/:sessionID/synthetic", Schema.toCodecStringTree<Schema.Struct<{
1424
1451
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1425
1452
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1426
1453
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1427
1454
  };
1428
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1455
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1429
1456
  readonly id: Schema.optional<Schema.brand<Schema.String, "Session.Message.ID"> & {
1430
1457
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
1431
1458
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -1435,7 +1462,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1435
1462
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
1436
1463
  readonly delivery: Schema.optional<Schema.Literals<readonly ["steer", "queue"]>>;
1437
1464
  readonly resume: Schema.optional<Schema.Boolean>;
1438
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1465
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1439
1466
  readonly data: Schema.Struct<{
1440
1467
  readonly type: Schema.tag<"synthetic">;
1441
1468
  readonly data: Schema.Struct<{
@@ -1455,27 +1482,27 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1455
1482
  };
1456
1483
  readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
1457
1484
  }>;
1458
- }>>, HttpApiEndpoint.Json<typeof ConflictError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.shell", "POST", "/api/session/:sessionID/shell", HttpApiEndpoint.StringTree<Schema.Struct<{
1485
+ }>>, Schema.toCodecJson<typeof ConflictError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.shell", "POST", "/api/session/:sessionID/shell", Schema.toCodecStringTree<Schema.Struct<{
1459
1486
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1460
1487
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1461
1488
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1462
1489
  };
1463
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1490
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1464
1491
  readonly id: Schema.optional<Schema.brand<Schema.String, "Event.ID"> & {
1465
1492
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
1466
1493
  }>;
1467
1494
  readonly command: Schema.String;
1468
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.compact", "POST", "/api/session/:sessionID/compact", HttpApiEndpoint.StringTree<Schema.Struct<{
1495
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.compact", "POST", "/api/session/:sessionID/compact", Schema.toCodecStringTree<Schema.Struct<{
1469
1496
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1470
1497
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1471
1498
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1472
1499
  };
1473
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1500
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1474
1501
  readonly id: Schema.optional<Schema.brand<Schema.String, "Session.Message.ID"> & {
1475
1502
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
1476
1503
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
1477
1504
  }>;
1478
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1505
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1479
1506
  readonly data: Schema.Struct<{
1480
1507
  readonly type: Schema.tag<"compaction">;
1481
1508
  readonly admittedSeq: Schema.Int;
@@ -1489,23 +1516,23 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1489
1516
  };
1490
1517
  readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
1491
1518
  }>;
1492
- }>>, HttpApiEndpoint.Json<typeof ConflictError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.wait", "POST", "/api/session/:sessionID/wait", HttpApiEndpoint.StringTree<Schema.Struct<{
1519
+ }>>, Schema.toCodecJson<typeof ConflictError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.wait", "POST", "/api/session/:sessionID/wait", Schema.toCodecStringTree<Schema.Struct<{
1493
1520
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1494
1521
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1495
1522
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1496
1523
  };
1497
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof ServiceUnavailableError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.revert.stage", "POST", "/api/session/:sessionID/revert/stage", HttpApiEndpoint.StringTree<Schema.Struct<{
1524
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof ServiceUnavailableError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.revert.stage", "POST", "/api/session/:sessionID/revert/stage", Schema.toCodecStringTree<Schema.Struct<{
1498
1525
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1499
1526
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1500
1527
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1501
1528
  };
1502
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1529
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1503
1530
  readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
1504
1531
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
1505
1532
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
1506
1533
  };
1507
1534
  readonly files: Schema.optional<Schema.Boolean>;
1508
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1535
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
1509
1536
  readonly data: Schema.Struct<{
1510
1537
  readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
1511
1538
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
@@ -1527,22 +1554,22 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1527
1554
  readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
1528
1555
  }>>>, never, never>;
1529
1556
  }>;
1530
- }>>, HttpApiEndpoint.Json<typeof SessionBusyError | typeof UnknownError | typeof SessionNotFoundError | typeof MessageNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.revert.clear", "POST", "/api/session/:sessionID/revert/clear", HttpApiEndpoint.StringTree<Schema.Struct<{
1557
+ }>>, Schema.toCodecJson<typeof SessionBusyError | typeof UnknownError | typeof SessionNotFoundError | typeof MessageNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.revert.clear", "POST", "/api/session/:sessionID/revert/clear", Schema.toCodecStringTree<Schema.Struct<{
1531
1558
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1532
1559
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1533
1560
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1534
1561
  };
1535
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionBusyError | typeof UnknownError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.revert.commit", "POST", "/api/session/:sessionID/revert/commit", HttpApiEndpoint.StringTree<Schema.Struct<{
1562
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionBusyError | typeof UnknownError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.revert.commit", "POST", "/api/session/:sessionID/revert/commit", Schema.toCodecStringTree<Schema.Struct<{
1536
1563
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1537
1564
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1538
1565
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1539
1566
  };
1540
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionBusyError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.context", "GET", "/api/session/:sessionID/context", HttpApiEndpoint.StringTree<Schema.Struct<{
1567
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionBusyError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.context", "GET", "/api/session/:sessionID/context", Schema.toCodecStringTree<Schema.Struct<{
1541
1568
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
1542
1569
  create: () => string & import("effect/Brand").Brand<"SessionID">;
1543
1570
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
1544
1571
  };
1545
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
1572
+ }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
1546
1573
  readonly data: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
1547
1574
  readonly type: Schema.tag<"agent-switched">;
1548
1575
  readonly agent: Schema.brand<Schema.String, "Agent.ID">;
@@ -1657,20 +1684,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1657
1684
  }> & {
1658
1685
  create: (input: SessionEvent.FileAttachment) => {
1659
1686
  readonly data: string;
1687
+ readonly source: Schema.Struct.ReadonlySide<{
1688
+ readonly type: Schema.Literal<"inline">;
1689
+ }, "Type"> | Schema.Struct.ReadonlySide<{
1690
+ readonly type: Schema.Literal<"uri">;
1691
+ readonly uri: Schema.String;
1692
+ }, "Type">;
1660
1693
  readonly mime: string;
1661
- readonly source: {
1662
- readonly type: "inline";
1663
- } | {
1664
- readonly type: "uri";
1665
- readonly uri: string;
1666
- };
1667
- readonly name?: string | undefined;
1668
1694
  readonly description?: string | undefined;
1669
- readonly mention?: {
1670
- readonly start: number;
1671
- readonly end: number;
1672
- readonly text: string;
1673
- } | undefined;
1695
+ readonly name?: string | undefined;
1696
+ readonly mention?: Schema.Struct.ReadonlySide<{
1697
+ readonly start: Schema.Finite;
1698
+ readonly end: Schema.Finite;
1699
+ readonly text: Schema.String;
1700
+ }, "Type"> | undefined;
1674
1701
  };
1675
1702
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
1676
1703
  readonly data: Schema.String;
@@ -1695,20 +1722,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
1695
1722
  }> & {
1696
1723
  create: (input: SessionEvent.FileAttachment) => {
1697
1724
  readonly data: string;
1725
+ readonly source: Schema.Struct.ReadonlySide<{
1726
+ readonly type: Schema.Literal<"inline">;
1727
+ }, "Type"> | Schema.Struct.ReadonlySide<{
1728
+ readonly type: Schema.Literal<"uri">;
1729
+ readonly uri: Schema.String;
1730
+ }, "Type">;
1698
1731
  readonly mime: string;
1699
- readonly source: {
1700
- readonly type: "inline";
1701
- } | {
1702
- readonly type: "uri";
1703
- readonly uri: string;
1704
- };
1705
- readonly name?: string | undefined;
1706
1732
  readonly description?: string | undefined;
1707
- readonly mention?: {
1708
- readonly start: number;
1709
- readonly end: number;
1710
- readonly text: string;
1711
- } | undefined;
1733
+ readonly name?: string | undefined;
1734
+ readonly mention?: Schema.Struct.ReadonlySide<{
1735
+ readonly start: Schema.Finite;
1736
+ readonly end: Schema.Finite;
1737
+ readonly text: Schema.String;
1738
+ }, "Type"> | undefined;
1712
1739
  };
1713
1740
  }>>, never, never>;
1714
1741
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -2018,12 +2045,12 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2018
2045
  }>;
2019
2046
  readonly type: Schema.tag<"compaction">;
2020
2047
  }>]>]>>;
2021
- }>>, HttpApiEndpoint.Json<typeof UnknownError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.pending.list", "GET", "/api/session/:sessionID/pending", HttpApiEndpoint.StringTree<Schema.Struct<{
2048
+ }>>, Schema.toCodecJson<typeof UnknownError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.pending.list", "GET", "/api/session/:sessionID/pending", Schema.toCodecStringTree<Schema.Struct<{
2022
2049
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
2023
2050
  create: () => string & import("effect/Brand").Brand<"SessionID">;
2024
2051
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
2025
2052
  };
2026
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
2053
+ }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
2027
2054
  readonly data: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
2028
2055
  readonly type: Schema.tag<"user">;
2029
2056
  readonly data: Schema.Struct<{
@@ -2052,20 +2079,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2052
2079
  }> & {
2053
2080
  create: (input: SessionEvent.FileAttachment) => {
2054
2081
  readonly data: string;
2082
+ readonly source: Schema.Struct.ReadonlySide<{
2083
+ readonly type: Schema.Literal<"inline">;
2084
+ }, "Type"> | Schema.Struct.ReadonlySide<{
2085
+ readonly type: Schema.Literal<"uri">;
2086
+ readonly uri: Schema.String;
2087
+ }, "Type">;
2055
2088
  readonly mime: string;
2056
- readonly source: {
2057
- readonly type: "inline";
2058
- } | {
2059
- readonly type: "uri";
2060
- readonly uri: string;
2061
- };
2062
- readonly name?: string | undefined;
2063
2089
  readonly description?: string | undefined;
2064
- readonly mention?: {
2065
- readonly start: number;
2066
- readonly end: number;
2067
- readonly text: string;
2068
- } | undefined;
2090
+ readonly name?: string | undefined;
2091
+ readonly mention?: Schema.Struct.ReadonlySide<{
2092
+ readonly start: Schema.Finite;
2093
+ readonly end: Schema.Finite;
2094
+ readonly text: Schema.String;
2095
+ }, "Type"> | undefined;
2069
2096
  };
2070
2097
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
2071
2098
  readonly data: Schema.String;
@@ -2090,20 +2117,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2090
2117
  }> & {
2091
2118
  create: (input: SessionEvent.FileAttachment) => {
2092
2119
  readonly data: string;
2120
+ readonly source: Schema.Struct.ReadonlySide<{
2121
+ readonly type: Schema.Literal<"inline">;
2122
+ }, "Type"> | Schema.Struct.ReadonlySide<{
2123
+ readonly type: Schema.Literal<"uri">;
2124
+ readonly uri: Schema.String;
2125
+ }, "Type">;
2093
2126
  readonly mime: string;
2094
- readonly source: {
2095
- readonly type: "inline";
2096
- } | {
2097
- readonly type: "uri";
2098
- readonly uri: string;
2099
- };
2100
- readonly name?: string | undefined;
2101
2127
  readonly description?: string | undefined;
2102
- readonly mention?: {
2103
- readonly start: number;
2104
- readonly end: number;
2105
- readonly text: string;
2106
- } | undefined;
2128
+ readonly name?: string | undefined;
2129
+ readonly mention?: Schema.Struct.ReadonlySide<{
2130
+ readonly start: Schema.Finite;
2131
+ readonly end: Schema.Finite;
2132
+ readonly text: Schema.String;
2133
+ }, "Type"> | undefined;
2107
2134
  };
2108
2135
  }>>, never, never>;
2109
2136
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -2172,39 +2199,50 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2172
2199
  };
2173
2200
  readonly timeCreated: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
2174
2201
  }>]>>;
2175
- }>>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.instructions.entry.list", "GET", "/api/session/:sessionID/instructions/entries", HttpApiEndpoint.StringTree<Schema.Struct<{
2202
+ }>>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.instructions.entry.list", "GET", "/api/session/:sessionID/instructions/entries", Schema.toCodecStringTree<Schema.Struct<{
2176
2203
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
2177
2204
  create: () => string & import("effect/Brand").Brand<"SessionID">;
2178
2205
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
2179
2206
  };
2180
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
2207
+ }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
2181
2208
  readonly data: Schema.$Array<Schema.Struct<{
2182
2209
  readonly key: Schema.String;
2183
2210
  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2184
2211
  }>>;
2185
- }>>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.instructions.entry.put", "PUT", "/api/session/:sessionID/instructions/entries/:key", HttpApiEndpoint.StringTree<Schema.Struct<{
2212
+ }>>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.instructions.entry.put", "PUT", "/api/session/:sessionID/instructions/entries/:key", Schema.toCodecStringTree<Schema.Struct<{
2186
2213
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
2187
2214
  create: () => string & import("effect/Brand").Brand<"SessionID">;
2188
2215
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
2189
2216
  };
2190
2217
  key: Schema.String;
2191
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
2218
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
2192
2219
  readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
2193
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError | typeof InstructionEntry.ValueTooLargeError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.instructions.entry.remove", "DELETE", "/api/session/:sessionID/instructions/entries/:key", HttpApiEndpoint.StringTree<Schema.Struct<{
2220
+ }>>, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError | typeof InstructionEntry.ValueTooLargeError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.instructions.entry.remove", "DELETE", "/api/session/:sessionID/instructions/entries/:key", Schema.toCodecStringTree<Schema.Struct<{
2194
2221
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
2195
2222
  create: () => string & import("effect/Brand").Brand<"SessionID">;
2196
2223
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
2197
2224
  };
2198
2225
  key: Schema.String;
2199
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.log", "GET", "/api/experimental/session/:sessionID/log", HttpApiEndpoint.StringTree<Schema.Struct<{
2226
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.generate", "POST", "/api/session/:sessionID/generate", Schema.toCodecStringTree<Schema.Struct<{
2227
+ sessionID: Schema.brand<Schema.String, "SessionID"> & {
2228
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
2229
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
2230
+ };
2231
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
2232
+ readonly prompt: Schema.String;
2233
+ }>>, never, Schema.toCodecJson<Schema.Struct<{
2234
+ readonly data: Schema.Struct<{
2235
+ readonly text: Schema.String;
2236
+ }>;
2237
+ }>>, Schema.toCodecJson<typeof ServiceUnavailableError | typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.log", "GET", "/api/experimental/session/:sessionID/log", Schema.toCodecStringTree<Schema.Struct<{
2200
2238
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
2201
2239
  create: () => string & import("effect/Brand").Brand<"SessionID">;
2202
2240
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
2203
2241
  };
2204
- }>>, HttpApiEndpoint.StringTree<Schema.Struct<{
2242
+ }>>, Schema.toCodecStringTree<Schema.Struct<{
2205
2243
  after: Schema.optional<Schema.compose<Schema.brand<Schema.Int, "Event.Seq">, Schema.NumberFromString>>;
2206
2244
  follow: Schema.optional<Schema.decodeTo<Schema.Boolean, Schema.Literals<readonly ["true", "false"]>, never, never>>;
2207
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Union<readonly [...((Schema.Struct<{
2245
+ }>>, never, never, HttpApiSchema.StreamSse<HttpApiSchema.SseEventFromData<Schema.Union<readonly [Schema.Union<readonly [...((Schema.Struct<{
2208
2246
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
2209
2247
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
2210
2248
  };
@@ -2732,20 +2770,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2732
2770
  }> & {
2733
2771
  create: (input: SessionEvent.FileAttachment) => {
2734
2772
  readonly data: string;
2773
+ readonly source: Schema.Struct.ReadonlySide<{
2774
+ readonly type: Schema.Literal<"inline">;
2775
+ }, "Type"> | Schema.Struct.ReadonlySide<{
2776
+ readonly type: Schema.Literal<"uri">;
2777
+ readonly uri: Schema.String;
2778
+ }, "Type">;
2735
2779
  readonly mime: string;
2736
- readonly source: {
2737
- readonly type: "inline";
2738
- } | {
2739
- readonly type: "uri";
2740
- readonly uri: string;
2741
- };
2742
- readonly name?: string | undefined;
2743
2780
  readonly description?: string | undefined;
2744
- readonly mention?: {
2745
- readonly start: number;
2746
- readonly end: number;
2747
- readonly text: string;
2748
- } | undefined;
2781
+ readonly name?: string | undefined;
2782
+ readonly mention?: Schema.Struct.ReadonlySide<{
2783
+ readonly start: Schema.Finite;
2784
+ readonly end: Schema.Finite;
2785
+ readonly text: Schema.String;
2786
+ }, "Type"> | undefined;
2749
2787
  };
2750
2788
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
2751
2789
  readonly data: Schema.String;
@@ -2770,20 +2808,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2770
2808
  }> & {
2771
2809
  create: (input: SessionEvent.FileAttachment) => {
2772
2810
  readonly data: string;
2811
+ readonly source: Schema.Struct.ReadonlySide<{
2812
+ readonly type: Schema.Literal<"inline">;
2813
+ }, "Type"> | Schema.Struct.ReadonlySide<{
2814
+ readonly type: Schema.Literal<"uri">;
2815
+ readonly uri: Schema.String;
2816
+ }, "Type">;
2773
2817
  readonly mime: string;
2774
- readonly source: {
2775
- readonly type: "inline";
2776
- } | {
2777
- readonly type: "uri";
2778
- readonly uri: string;
2779
- };
2780
- readonly name?: string | undefined;
2781
2818
  readonly description?: string | undefined;
2782
- readonly mention?: {
2783
- readonly start: number;
2784
- readonly end: number;
2785
- readonly text: string;
2786
- } | undefined;
2819
+ readonly name?: string | undefined;
2820
+ readonly mention?: Schema.Struct.ReadonlySide<{
2821
+ readonly start: Schema.Finite;
2822
+ readonly end: Schema.Finite;
2823
+ readonly text: Schema.String;
2824
+ }, "Type"> | undefined;
2787
2825
  };
2788
2826
  }>>, never, never>;
2789
2827
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -2865,20 +2903,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2865
2903
  }> & {
2866
2904
  create: (input: SessionEvent.FileAttachment) => {
2867
2905
  readonly data: string;
2906
+ readonly source: Schema.Struct.ReadonlySide<{
2907
+ readonly type: Schema.Literal<"inline">;
2908
+ }, "Type"> | Schema.Struct.ReadonlySide<{
2909
+ readonly type: Schema.Literal<"uri">;
2910
+ readonly uri: Schema.String;
2911
+ }, "Type">;
2868
2912
  readonly mime: string;
2869
- readonly source: {
2870
- readonly type: "inline";
2871
- } | {
2872
- readonly type: "uri";
2873
- readonly uri: string;
2874
- };
2875
- readonly name?: string | undefined;
2876
2913
  readonly description?: string | undefined;
2877
- readonly mention?: {
2878
- readonly start: number;
2879
- readonly end: number;
2880
- readonly text: string;
2881
- } | undefined;
2914
+ readonly name?: string | undefined;
2915
+ readonly mention?: Schema.Struct.ReadonlySide<{
2916
+ readonly start: Schema.Finite;
2917
+ readonly end: Schema.Finite;
2918
+ readonly text: Schema.String;
2919
+ }, "Type"> | undefined;
2882
2920
  };
2883
2921
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
2884
2922
  readonly data: Schema.String;
@@ -2903,20 +2941,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
2903
2941
  }> & {
2904
2942
  create: (input: SessionEvent.FileAttachment) => {
2905
2943
  readonly data: string;
2944
+ readonly source: Schema.Struct.ReadonlySide<{
2945
+ readonly type: Schema.Literal<"inline">;
2946
+ }, "Type"> | Schema.Struct.ReadonlySide<{
2947
+ readonly type: Schema.Literal<"uri">;
2948
+ readonly uri: Schema.String;
2949
+ }, "Type">;
2906
2950
  readonly mime: string;
2907
- readonly source: {
2908
- readonly type: "inline";
2909
- } | {
2910
- readonly type: "uri";
2911
- readonly uri: string;
2912
- };
2913
- readonly name?: string | undefined;
2914
2951
  readonly description?: string | undefined;
2915
- readonly mention?: {
2916
- readonly start: number;
2917
- readonly end: number;
2918
- readonly text: string;
2919
- } | undefined;
2952
+ readonly name?: string | undefined;
2953
+ readonly mention?: Schema.Struct.ReadonlySide<{
2954
+ readonly start: Schema.Finite;
2955
+ readonly end: Schema.Finite;
2956
+ readonly text: Schema.String;
2957
+ }, "Type"> | undefined;
2920
2958
  };
2921
2959
  }>>, never, never>;
2922
2960
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -5108,57 +5146,74 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
5108
5146
  readonly seq: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.Int, "Event.Seq">>>, Schema.optionalKey<Schema.brand<Schema.Int, "Event.Seq">>, never, never>;
5109
5147
  }>]>>, Schema.Never, {
5110
5148
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5111
- readonly created: import("effect/DateTime").Utc;
5149
+ readonly data: Schema.Struct.ReadonlySide<{
5150
+ readonly agent: Schema.brand<Schema.String, "Agent.ID">;
5151
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5152
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5153
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5154
+ };
5155
+ }, "Type">;
5156
+ readonly durable: Schema.Struct.ReadonlySide<{
5157
+ readonly aggregateID: Schema.String;
5158
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5159
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5160
+ }, "Type">;
5112
5161
  readonly type: "session.agent.selected";
5113
- readonly durable: {
5114
- readonly aggregateID: string;
5115
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5116
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5117
- };
5118
- readonly data: {
5119
- readonly agent: string & import("effect/Brand").Brand<"Agent.ID">;
5120
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5121
- };
5122
- readonly metadata?: {
5123
- readonly [x: string]: unknown;
5124
- } | undefined;
5162
+ readonly created: import("effect/DateTime").Utc;
5125
5163
  readonly location?: {
5126
5164
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5127
5165
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5128
5166
  } | undefined;
5129
- } | {
5130
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5131
- readonly created: import("effect/DateTime").Utc;
5132
- readonly type: "session.model.selected";
5133
- readonly durable: {
5134
- readonly aggregateID: string;
5135
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5136
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5137
- };
5138
- readonly data: {
5139
- readonly model: {
5140
- readonly id: string & import("effect/Brand").Brand<"Model.ID">;
5141
- readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5142
- readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
5143
- };
5144
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5145
- };
5146
5167
  readonly metadata?: {
5147
5168
  readonly [x: string]: unknown;
5148
5169
  } | undefined;
5170
+ } | {
5171
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5172
+ readonly data: Schema.Struct.ReadonlySide<{
5173
+ readonly model: Schema.Struct<{
5174
+ readonly id: Schema.brand<Schema.String, "Model.ID">;
5175
+ readonly providerID: Schema.brand<Schema.String, "ProviderV2.ID"> & {
5176
+ opencode: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5177
+ anthropic: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5178
+ openai: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5179
+ google: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5180
+ googleVertex: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5181
+ githubCopilot: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5182
+ amazonBedrock: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5183
+ azure: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5184
+ openrouter: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5185
+ mistral: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5186
+ gitlab: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5187
+ };
5188
+ readonly variant: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Model.VariantID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Model.VariantID">>, never, never>;
5189
+ }> & {
5190
+ parse: (input: string) => {
5191
+ readonly id: string & import("effect/Brand").Brand<"Model.ID">;
5192
+ readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5193
+ readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
5194
+ };
5195
+ };
5196
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5197
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5198
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5199
+ };
5200
+ }, "Type">;
5201
+ readonly durable: Schema.Struct.ReadonlySide<{
5202
+ readonly aggregateID: Schema.String;
5203
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5204
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5205
+ }, "Type">;
5206
+ readonly type: "session.model.selected";
5207
+ readonly created: import("effect/DateTime").Utc;
5149
5208
  readonly location?: {
5150
5209
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5151
5210
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5152
5211
  } | undefined;
5212
+ readonly metadata?: {
5213
+ readonly [x: string]: unknown;
5214
+ } | undefined;
5153
5215
  } | {
5154
5216
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5155
- readonly created: import("effect/DateTime").Utc;
5156
- readonly type: "session.moved";
5157
- readonly durable: {
5158
- readonly aggregateID: string;
5159
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5160
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5161
- };
5162
5217
  readonly data: {
5163
5218
  readonly location: {
5164
5219
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
@@ -5168,975 +5223,1164 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
5168
5223
  readonly projectID?: (string & import("effect/Brand").Brand<"Project.ID">) | undefined;
5169
5224
  readonly subpath?: (string & import("effect/Brand").Brand<"RelativePath">) | undefined;
5170
5225
  };
5171
- readonly metadata?: {
5172
- readonly [x: string]: unknown;
5173
- } | undefined;
5226
+ readonly durable: Schema.Struct.ReadonlySide<{
5227
+ readonly aggregateID: Schema.String;
5228
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5229
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5230
+ }, "Type">;
5231
+ readonly type: "session.moved";
5232
+ readonly created: import("effect/DateTime").Utc;
5174
5233
  readonly location?: {
5175
5234
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5176
5235
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5177
5236
  } | undefined;
5178
- } | {
5179
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5180
- readonly created: import("effect/DateTime").Utc;
5181
- readonly type: "session.renamed";
5182
- readonly durable: {
5183
- readonly aggregateID: string;
5184
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5185
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5186
- };
5187
- readonly data: {
5188
- readonly title: string;
5189
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5190
- };
5191
5237
  readonly metadata?: {
5192
5238
  readonly [x: string]: unknown;
5193
5239
  } | undefined;
5240
+ } | {
5241
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5242
+ readonly data: Schema.Struct.ReadonlySide<{
5243
+ readonly title: Schema.String;
5244
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5245
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5246
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5247
+ };
5248
+ }, "Type">;
5249
+ readonly durable: Schema.Struct.ReadonlySide<{
5250
+ readonly aggregateID: Schema.String;
5251
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5252
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5253
+ }, "Type">;
5254
+ readonly type: "session.renamed";
5255
+ readonly created: import("effect/DateTime").Utc;
5194
5256
  readonly location?: {
5195
5257
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5196
5258
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5197
5259
  } | undefined;
5198
- } | {
5199
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5200
- readonly created: import("effect/DateTime").Utc;
5201
- readonly type: "session.usage.recorded";
5202
- readonly durable: {
5203
- readonly aggregateID: string;
5204
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5205
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5206
- };
5207
- readonly data: {
5208
- readonly source: "compaction" | "title";
5209
- readonly cost: number & import("effect/Brand").Brand<"Money.USD">;
5210
- readonly tokens: {
5211
- readonly input: number;
5212
- readonly output: number;
5213
- readonly reasoning: number;
5214
- readonly cache: {
5215
- readonly read: number;
5216
- readonly write: number;
5217
- };
5218
- };
5219
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5220
- };
5221
5260
  readonly metadata?: {
5222
5261
  readonly [x: string]: unknown;
5223
5262
  } | undefined;
5263
+ } | {
5264
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5265
+ readonly data: Schema.Struct.ReadonlySide<{
5266
+ readonly source: Schema.Literals<readonly ["title", "compaction"]>;
5267
+ readonly cost: Schema.brand<Schema.Finite, "Money.USD"> & {
5268
+ zero: number & import("effect/Brand").Brand<"Money.USD">;
5269
+ };
5270
+ readonly tokens: Schema.Struct<{
5271
+ readonly input: Schema.Finite;
5272
+ readonly output: Schema.Finite;
5273
+ readonly reasoning: Schema.Finite;
5274
+ readonly cache: Schema.Struct<{
5275
+ readonly read: Schema.Finite;
5276
+ readonly write: Schema.Finite;
5277
+ }>;
5278
+ }>;
5279
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5280
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5281
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5282
+ };
5283
+ }, "Type">;
5284
+ readonly durable: Schema.Struct.ReadonlySide<{
5285
+ readonly aggregateID: Schema.String;
5286
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5287
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5288
+ }, "Type">;
5289
+ readonly type: "session.usage.recorded";
5290
+ readonly created: import("effect/DateTime").Utc;
5224
5291
  readonly location?: {
5225
5292
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5226
5293
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5227
5294
  } | undefined;
5228
- } | {
5229
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5230
- readonly created: import("effect/DateTime").Utc;
5231
- readonly type: "session.deleted";
5232
- readonly durable: {
5233
- readonly aggregateID: string;
5234
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5235
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5236
- };
5237
- readonly data: {
5238
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5239
- };
5240
5295
  readonly metadata?: {
5241
5296
  readonly [x: string]: unknown;
5242
5297
  } | undefined;
5298
+ } | {
5299
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5300
+ readonly data: Schema.Struct.ReadonlySide<{
5301
+ sessionID: Schema.brand<Schema.String, "SessionID"> & {
5302
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5303
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5304
+ };
5305
+ }, "Type">;
5306
+ readonly durable: Schema.Struct.ReadonlySide<{
5307
+ readonly aggregateID: Schema.String;
5308
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5309
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5310
+ }, "Type">;
5311
+ readonly type: "session.deleted";
5312
+ readonly created: import("effect/DateTime").Utc;
5243
5313
  readonly location?: {
5244
5314
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5245
5315
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5246
5316
  } | undefined;
5317
+ readonly metadata?: {
5318
+ readonly [x: string]: unknown;
5319
+ } | undefined;
5247
5320
  } | {
5248
5321
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5249
- readonly created: import("effect/DateTime").Utc;
5250
- readonly type: "session.forked";
5251
- readonly durable: {
5252
- readonly aggregateID: string;
5253
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5254
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5255
- };
5256
5322
  readonly data: {
5323
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5257
5324
  readonly parentID: string & import("effect/Brand").Brand<"SessionID">;
5258
5325
  readonly parentSeq: number;
5259
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5260
5326
  readonly from?: (string & import("effect/Brand").Brand<"Session.Message.ID">) | undefined;
5261
5327
  };
5262
- readonly metadata?: {
5263
- readonly [x: string]: unknown;
5264
- } | undefined;
5328
+ readonly durable: Schema.Struct.ReadonlySide<{
5329
+ readonly aggregateID: Schema.String;
5330
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5331
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5332
+ }, "Type">;
5333
+ readonly type: "session.forked";
5334
+ readonly created: import("effect/DateTime").Utc;
5265
5335
  readonly location?: {
5266
5336
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5267
5337
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5268
5338
  } | undefined;
5269
- } | {
5270
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5271
- readonly created: import("effect/DateTime").Utc;
5272
- readonly type: "session.input.promoted";
5273
- readonly durable: {
5274
- readonly aggregateID: string;
5275
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5276
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5277
- };
5278
- readonly data: {
5279
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5280
- readonly inputID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5281
- };
5282
5339
  readonly metadata?: {
5283
5340
  readonly [x: string]: unknown;
5284
5341
  } | undefined;
5342
+ } | {
5343
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5344
+ readonly data: Schema.Struct.ReadonlySide<{
5345
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5346
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5347
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5348
+ };
5349
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
5350
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
5351
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
5352
+ };
5353
+ }, "Type">;
5354
+ readonly durable: Schema.Struct.ReadonlySide<{
5355
+ readonly aggregateID: Schema.String;
5356
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5357
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5358
+ }, "Type">;
5359
+ readonly type: "session.input.promoted";
5360
+ readonly created: import("effect/DateTime").Utc;
5285
5361
  readonly location?: {
5286
5362
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5287
5363
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5288
5364
  } | undefined;
5365
+ readonly metadata?: {
5366
+ readonly [x: string]: unknown;
5367
+ } | undefined;
5289
5368
  } | {
5290
5369
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5291
- readonly created: import("effect/DateTime").Utc;
5292
- readonly type: "session.input.admitted";
5293
- readonly durable: {
5294
- readonly aggregateID: string;
5295
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5296
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5297
- };
5298
- readonly data: {
5299
- readonly inputID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5300
- readonly input: {
5301
- readonly type: "user";
5302
- readonly data: {
5303
- readonly text: string;
5304
- readonly metadata?: {
5305
- readonly [x: string]: unknown;
5306
- } | undefined;
5307
- readonly files?: readonly {
5308
- readonly data: string;
5309
- readonly mime: string;
5310
- readonly source: {
5311
- readonly type: "inline";
5312
- } | {
5313
- readonly type: "uri";
5314
- readonly uri: string;
5370
+ readonly data: Schema.Struct.ReadonlySide<{
5371
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
5372
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
5373
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
5374
+ };
5375
+ readonly input: Schema.Union<readonly [Schema.Struct<{
5376
+ readonly type: Schema.tag<"user">;
5377
+ readonly data: Schema.Struct<{
5378
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
5379
+ readonly text: Schema.String;
5380
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
5381
+ readonly data: Schema.String;
5382
+ readonly mime: Schema.String;
5383
+ readonly source: Schema.Union<readonly [Schema.Struct<{
5384
+ readonly type: Schema.Literal<"inline">;
5385
+ }>, Schema.Struct<{
5386
+ readonly type: Schema.Literal<"uri">;
5387
+ readonly uri: Schema.String;
5388
+ }>]>;
5389
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
5390
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
5391
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
5392
+ readonly start: Schema.Finite;
5393
+ readonly end: Schema.Finite;
5394
+ readonly text: Schema.String;
5395
+ }>>>, Schema.optionalKey<Schema.Struct<{
5396
+ readonly start: Schema.Finite;
5397
+ readonly end: Schema.Finite;
5398
+ readonly text: Schema.String;
5399
+ }>>, never, never>;
5400
+ }> & {
5401
+ create: (input: SessionEvent.FileAttachment) => {
5402
+ readonly data: string;
5403
+ readonly source: Schema.Struct.ReadonlySide<{
5404
+ readonly type: Schema.Literal<"inline">;
5405
+ }, "Type"> | Schema.Struct.ReadonlySide<{
5406
+ readonly type: Schema.Literal<"uri">;
5407
+ readonly uri: Schema.String;
5408
+ }, "Type">;
5409
+ readonly mime: string;
5410
+ readonly description?: string | undefined;
5411
+ readonly name?: string | undefined;
5412
+ readonly mention?: Schema.Struct.ReadonlySide<{
5413
+ readonly start: Schema.Finite;
5414
+ readonly end: Schema.Finite;
5415
+ readonly text: Schema.String;
5416
+ }, "Type"> | undefined;
5315
5417
  };
5316
- readonly name?: string | undefined;
5317
- readonly description?: string | undefined;
5318
- readonly mention?: {
5319
- readonly start: number;
5320
- readonly end: number;
5321
- readonly text: string;
5322
- } | undefined;
5323
- }[] | undefined;
5324
- readonly agents?: readonly {
5325
- readonly name: string;
5326
- readonly mention?: {
5327
- readonly start: number;
5328
- readonly end: number;
5329
- readonly text: string;
5330
- } | undefined;
5331
- }[] | undefined;
5332
- };
5333
- readonly delivery: "steer" | "queue";
5334
- } | {
5335
- readonly type: "synthetic";
5336
- readonly data: {
5337
- readonly text: string;
5338
- readonly description?: string | undefined;
5339
- readonly metadata?: {
5340
- readonly [x: string]: unknown;
5341
- } | undefined;
5342
- };
5343
- readonly delivery: "steer" | "queue";
5418
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
5419
+ readonly data: Schema.String;
5420
+ readonly mime: Schema.String;
5421
+ readonly source: Schema.Union<readonly [Schema.Struct<{
5422
+ readonly type: Schema.Literal<"inline">;
5423
+ }>, Schema.Struct<{
5424
+ readonly type: Schema.Literal<"uri">;
5425
+ readonly uri: Schema.String;
5426
+ }>]>;
5427
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
5428
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
5429
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
5430
+ readonly start: Schema.Finite;
5431
+ readonly end: Schema.Finite;
5432
+ readonly text: Schema.String;
5433
+ }>>>, Schema.optionalKey<Schema.Struct<{
5434
+ readonly start: Schema.Finite;
5435
+ readonly end: Schema.Finite;
5436
+ readonly text: Schema.String;
5437
+ }>>, never, never>;
5438
+ }> & {
5439
+ create: (input: SessionEvent.FileAttachment) => {
5440
+ readonly data: string;
5441
+ readonly source: Schema.Struct.ReadonlySide<{
5442
+ readonly type: Schema.Literal<"inline">;
5443
+ }, "Type"> | Schema.Struct.ReadonlySide<{
5444
+ readonly type: Schema.Literal<"uri">;
5445
+ readonly uri: Schema.String;
5446
+ }, "Type">;
5447
+ readonly mime: string;
5448
+ readonly description?: string | undefined;
5449
+ readonly name?: string | undefined;
5450
+ readonly mention?: Schema.Struct.ReadonlySide<{
5451
+ readonly start: Schema.Finite;
5452
+ readonly end: Schema.Finite;
5453
+ readonly text: Schema.String;
5454
+ }, "Type"> | undefined;
5455
+ };
5456
+ }>>, never, never>;
5457
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
5458
+ readonly name: Schema.String;
5459
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
5460
+ readonly start: Schema.Finite;
5461
+ readonly end: Schema.Finite;
5462
+ readonly text: Schema.String;
5463
+ }>>>, Schema.optionalKey<Schema.Struct<{
5464
+ readonly start: Schema.Finite;
5465
+ readonly end: Schema.Finite;
5466
+ readonly text: Schema.String;
5467
+ }>>, never, never>;
5468
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
5469
+ readonly name: Schema.String;
5470
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
5471
+ readonly start: Schema.Finite;
5472
+ readonly end: Schema.Finite;
5473
+ readonly text: Schema.String;
5474
+ }>>>, Schema.optionalKey<Schema.Struct<{
5475
+ readonly start: Schema.Finite;
5476
+ readonly end: Schema.Finite;
5477
+ readonly text: Schema.String;
5478
+ }>>, never, never>;
5479
+ }>>>, never, never>;
5480
+ }>;
5481
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
5482
+ }>, Schema.Struct<{
5483
+ readonly type: Schema.tag<"synthetic">;
5484
+ readonly data: Schema.Struct<{
5485
+ readonly text: Schema.String;
5486
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
5487
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
5488
+ }>;
5489
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
5490
+ }>]>;
5491
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5492
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5493
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5344
5494
  };
5345
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5346
- };
5347
- readonly metadata?: {
5348
- readonly [x: string]: unknown;
5349
- } | undefined;
5495
+ }, "Type">;
5496
+ readonly durable: Schema.Struct.ReadonlySide<{
5497
+ readonly aggregateID: Schema.String;
5498
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5499
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5500
+ }, "Type">;
5501
+ readonly type: "session.input.admitted";
5502
+ readonly created: import("effect/DateTime").Utc;
5350
5503
  readonly location?: {
5351
5504
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5352
5505
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5353
5506
  } | undefined;
5354
- } | {
5355
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5356
- readonly created: import("effect/DateTime").Utc;
5357
- readonly type: "session.execution.started";
5358
- readonly durable: {
5359
- readonly aggregateID: string;
5360
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5361
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5362
- };
5363
- readonly data: {
5364
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5365
- };
5366
5507
  readonly metadata?: {
5367
5508
  readonly [x: string]: unknown;
5368
5509
  } | undefined;
5510
+ } | {
5511
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5512
+ readonly data: Schema.Struct.ReadonlySide<{
5513
+ sessionID: Schema.brand<Schema.String, "SessionID"> & {
5514
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5515
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5516
+ };
5517
+ }, "Type">;
5518
+ readonly durable: Schema.Struct.ReadonlySide<{
5519
+ readonly aggregateID: Schema.String;
5520
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5521
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5522
+ }, "Type">;
5523
+ readonly type: "session.execution.started";
5524
+ readonly created: import("effect/DateTime").Utc;
5369
5525
  readonly location?: {
5370
5526
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5371
5527
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5372
5528
  } | undefined;
5373
- } | {
5374
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5375
- readonly created: import("effect/DateTime").Utc;
5376
- readonly type: "session.execution.succeeded";
5377
- readonly durable: {
5378
- readonly aggregateID: string;
5379
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5380
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5381
- };
5382
- readonly data: {
5383
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5384
- };
5385
5529
  readonly metadata?: {
5386
5530
  readonly [x: string]: unknown;
5387
5531
  } | undefined;
5532
+ } | {
5533
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5534
+ readonly data: Schema.Struct.ReadonlySide<{
5535
+ sessionID: Schema.brand<Schema.String, "SessionID"> & {
5536
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5537
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5538
+ };
5539
+ }, "Type">;
5540
+ readonly durable: Schema.Struct.ReadonlySide<{
5541
+ readonly aggregateID: Schema.String;
5542
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5543
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5544
+ }, "Type">;
5545
+ readonly type: "session.execution.succeeded";
5546
+ readonly created: import("effect/DateTime").Utc;
5388
5547
  readonly location?: {
5389
5548
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5390
5549
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5391
5550
  } | undefined;
5392
- } | {
5393
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5394
- readonly created: import("effect/DateTime").Utc;
5395
- readonly type: "session.execution.failed";
5396
- readonly durable: {
5397
- readonly aggregateID: string;
5398
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5399
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5400
- };
5401
- readonly data: {
5402
- readonly error: {
5403
- readonly type: string;
5404
- readonly message: string;
5405
- };
5406
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5407
- };
5408
5551
  readonly metadata?: {
5409
5552
  readonly [x: string]: unknown;
5410
5553
  } | undefined;
5554
+ } | {
5555
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5556
+ readonly data: Schema.Struct.ReadonlySide<{
5557
+ readonly error: Schema.Struct<{
5558
+ readonly type: Schema.String;
5559
+ readonly message: Schema.String;
5560
+ }>;
5561
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5562
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5563
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5564
+ };
5565
+ }, "Type">;
5566
+ readonly durable: Schema.Struct.ReadonlySide<{
5567
+ readonly aggregateID: Schema.String;
5568
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5569
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5570
+ }, "Type">;
5571
+ readonly type: "session.execution.failed";
5572
+ readonly created: import("effect/DateTime").Utc;
5411
5573
  readonly location?: {
5412
5574
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5413
5575
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5414
5576
  } | undefined;
5415
- } | {
5416
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5417
- readonly created: import("effect/DateTime").Utc;
5418
- readonly type: "session.execution.interrupted";
5419
- readonly durable: {
5420
- readonly aggregateID: string;
5421
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5422
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5423
- };
5424
- readonly data: {
5425
- readonly reason: "user" | "shutdown" | "superseded";
5426
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5427
- };
5428
5577
  readonly metadata?: {
5429
5578
  readonly [x: string]: unknown;
5430
5579
  } | undefined;
5580
+ } | {
5581
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5582
+ readonly data: Schema.Struct.ReadonlySide<{
5583
+ readonly reason: Schema.Literals<readonly ["user", "shutdown", "superseded"]>;
5584
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5585
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5586
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5587
+ };
5588
+ }, "Type">;
5589
+ readonly durable: Schema.Struct.ReadonlySide<{
5590
+ readonly aggregateID: Schema.String;
5591
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5592
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5593
+ }, "Type">;
5594
+ readonly type: "session.execution.interrupted";
5595
+ readonly created: import("effect/DateTime").Utc;
5431
5596
  readonly location?: {
5432
5597
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5433
5598
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5434
5599
  } | undefined;
5435
- } | {
5436
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5437
- readonly created: import("effect/DateTime").Utc;
5438
- readonly type: "session.instructions.updated";
5439
- readonly durable: {
5440
- readonly aggregateID: string;
5441
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5442
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5443
- };
5444
- readonly data: {
5445
- readonly delta: {
5446
- readonly [x: string]: (string & import("effect/Brand").Brand<"Instruction.Hash">) | "removed";
5447
- };
5448
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5449
- };
5450
5600
  readonly metadata?: {
5451
5601
  readonly [x: string]: unknown;
5452
5602
  } | undefined;
5603
+ } | {
5604
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5605
+ readonly data: Schema.Struct.ReadonlySide<{
5606
+ readonly delta: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.brand<Schema.String, "Instruction.Hash">, Schema.Literal<"removed">]>>;
5607
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5608
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5609
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5610
+ };
5611
+ }, "Type">;
5612
+ readonly durable: Schema.Struct.ReadonlySide<{
5613
+ readonly aggregateID: Schema.String;
5614
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5615
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5616
+ }, "Type">;
5617
+ readonly type: "session.instructions.updated";
5618
+ readonly created: import("effect/DateTime").Utc;
5453
5619
  readonly location?: {
5454
5620
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5455
5621
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5456
5622
  } | undefined;
5623
+ readonly metadata?: {
5624
+ readonly [x: string]: unknown;
5625
+ } | undefined;
5457
5626
  } | {
5458
5627
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5459
- readonly created: import("effect/DateTime").Utc;
5460
- readonly type: "session.synthetic";
5461
- readonly durable: {
5462
- readonly aggregateID: string;
5463
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5464
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5465
- };
5466
5628
  readonly data: {
5467
- readonly text: string;
5468
5629
  readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5469
- readonly description?: string | undefined;
5630
+ readonly text: string;
5470
5631
  readonly metadata?: {
5471
5632
  readonly [x: string]: unknown;
5472
5633
  } | undefined;
5634
+ readonly description?: string | undefined;
5473
5635
  };
5474
- readonly metadata?: {
5475
- readonly [x: string]: unknown;
5476
- } | undefined;
5636
+ readonly durable: Schema.Struct.ReadonlySide<{
5637
+ readonly aggregateID: Schema.String;
5638
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5639
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5640
+ }, "Type">;
5641
+ readonly type: "session.synthetic";
5642
+ readonly created: import("effect/DateTime").Utc;
5477
5643
  readonly location?: {
5478
5644
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5479
5645
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5480
5646
  } | undefined;
5481
- } | {
5482
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5483
- readonly created: import("effect/DateTime").Utc;
5484
- readonly type: "session.skill.activated";
5485
- readonly durable: {
5486
- readonly aggregateID: string;
5487
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5488
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5489
- };
5490
- readonly data: {
5491
- readonly id: string & import("effect/Brand").Brand<"Skill.ID">;
5492
- readonly name: string & import("effect/Brand").Brand<"Skill.Name">;
5493
- readonly text: string;
5494
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5495
- };
5496
5647
  readonly metadata?: {
5497
5648
  readonly [x: string]: unknown;
5498
5649
  } | undefined;
5650
+ } | {
5651
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5652
+ readonly data: Schema.Struct.ReadonlySide<{
5653
+ readonly id: Schema.brand<Schema.String, "Skill.ID">;
5654
+ readonly name: Schema.brand<Schema.String, "Skill.Name">;
5655
+ readonly text: Schema.String;
5656
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5657
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5658
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5659
+ };
5660
+ }, "Type">;
5661
+ readonly durable: Schema.Struct.ReadonlySide<{
5662
+ readonly aggregateID: Schema.String;
5663
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5664
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5665
+ }, "Type">;
5666
+ readonly type: "session.skill.activated";
5667
+ readonly created: import("effect/DateTime").Utc;
5499
5668
  readonly location?: {
5500
5669
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5501
5670
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5502
5671
  } | undefined;
5672
+ readonly metadata?: {
5673
+ readonly [x: string]: unknown;
5674
+ } | undefined;
5503
5675
  } | {
5504
5676
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5505
- readonly created: import("effect/DateTime").Utc;
5506
- readonly type: "session.shell.started";
5507
- readonly durable: {
5508
- readonly aggregateID: string;
5509
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5510
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5511
- };
5512
- readonly data: {
5513
- readonly shell: {
5514
- readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
5515
- readonly status: "running" | "exited" | "timeout" | "killed";
5516
- readonly command: string;
5517
- readonly cwd: string;
5518
- readonly shell: string;
5519
- readonly file: string;
5520
- readonly metadata: {
5521
- readonly [x: string]: unknown;
5522
- };
5523
- readonly time: {
5524
- readonly started: number;
5525
- readonly completed?: number | undefined;
5677
+ readonly data: Schema.Struct.ReadonlySide<{
5678
+ readonly shell: Schema.Struct<{
5679
+ readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
5680
+ create: () => string & import("effect/Brand").Brand<"Shell.ID">;
5681
+ ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
5526
5682
  };
5527
- readonly pid?: number | undefined;
5528
- readonly exit?: number | undefined;
5683
+ readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
5684
+ readonly command: Schema.String;
5685
+ readonly cwd: Schema.String;
5686
+ readonly shell: Schema.String;
5687
+ readonly file: Schema.String;
5688
+ readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
5689
+ readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
5690
+ readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
5691
+ readonly time: Schema.Struct<{
5692
+ readonly started: Schema.Finite;
5693
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
5694
+ }>;
5695
+ }>;
5696
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5697
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5698
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5529
5699
  };
5530
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5531
- };
5532
- readonly metadata?: {
5533
- readonly [x: string]: unknown;
5534
- } | undefined;
5700
+ }, "Type">;
5701
+ readonly durable: Schema.Struct.ReadonlySide<{
5702
+ readonly aggregateID: Schema.String;
5703
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5704
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5705
+ }, "Type">;
5706
+ readonly type: "session.shell.started";
5707
+ readonly created: import("effect/DateTime").Utc;
5535
5708
  readonly location?: {
5536
5709
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5537
5710
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5538
5711
  } | undefined;
5712
+ readonly metadata?: {
5713
+ readonly [x: string]: unknown;
5714
+ } | undefined;
5539
5715
  } | {
5540
5716
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5541
- readonly created: import("effect/DateTime").Utc;
5542
- readonly type: "session.shell.ended";
5543
- readonly durable: {
5544
- readonly aggregateID: string;
5545
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5546
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5547
- };
5548
- readonly data: {
5549
- readonly shell: {
5550
- readonly id: string & import("effect/Brand").Brand<"Shell.ID">;
5551
- readonly status: "running" | "exited" | "timeout" | "killed";
5552
- readonly command: string;
5553
- readonly cwd: string;
5554
- readonly shell: string;
5555
- readonly file: string;
5556
- readonly metadata: {
5557
- readonly [x: string]: unknown;
5558
- };
5559
- readonly time: {
5560
- readonly started: number;
5561
- readonly completed?: number | undefined;
5717
+ readonly data: Schema.Struct.ReadonlySide<{
5718
+ readonly shell: Schema.Struct<{
5719
+ readonly id: Schema.brand<Schema.String, "Shell.ID"> & {
5720
+ create: () => string & import("effect/Brand").Brand<"Shell.ID">;
5721
+ ascending: (id?: string) => string & import("effect/Brand").Brand<"Shell.ID">;
5562
5722
  };
5563
- readonly pid?: number | undefined;
5564
- readonly exit?: number | undefined;
5565
- };
5566
- readonly output: {
5567
- readonly output: string;
5568
- readonly cursor: number;
5569
- readonly size: number;
5570
- readonly truncated: boolean;
5723
+ readonly status: Schema.Literals<readonly ["running", "exited", "timeout", "killed"]>;
5724
+ readonly command: Schema.String;
5725
+ readonly cwd: Schema.String;
5726
+ readonly shell: Schema.String;
5727
+ readonly file: Schema.String;
5728
+ readonly pid: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Int>>, Schema.optionalKey<Schema.Int>, never, never>;
5729
+ readonly exit: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
5730
+ readonly metadata: Schema.$Record<Schema.String, Schema.Unknown>;
5731
+ readonly time: Schema.Struct<{
5732
+ readonly started: Schema.Finite;
5733
+ readonly completed: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Finite>>, Schema.optionalKey<Schema.Finite>, never, never>;
5734
+ }>;
5735
+ }>;
5736
+ readonly output: Schema.Struct<{
5737
+ readonly output: Schema.String;
5738
+ readonly cursor: Schema.Int;
5739
+ readonly size: Schema.Int;
5740
+ readonly truncated: Schema.Boolean;
5741
+ }>;
5742
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5743
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5744
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5571
5745
  };
5572
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5573
- };
5574
- readonly metadata?: {
5575
- readonly [x: string]: unknown;
5576
- } | undefined;
5746
+ }, "Type">;
5747
+ readonly durable: Schema.Struct.ReadonlySide<{
5748
+ readonly aggregateID: Schema.String;
5749
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5750
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5751
+ }, "Type">;
5752
+ readonly type: "session.shell.ended";
5753
+ readonly created: import("effect/DateTime").Utc;
5577
5754
  readonly location?: {
5578
5755
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5579
5756
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5580
5757
  } | undefined;
5758
+ readonly metadata?: {
5759
+ readonly [x: string]: unknown;
5760
+ } | undefined;
5581
5761
  } | {
5582
5762
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5583
- readonly created: import("effect/DateTime").Utc;
5584
- readonly type: "session.step.started";
5585
- readonly durable: {
5586
- readonly aggregateID: string;
5587
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5588
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5589
- };
5590
5763
  readonly data: {
5591
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5592
- readonly agent: string & import("effect/Brand").Brand<"Agent.ID">;
5764
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5593
5765
  readonly model: {
5594
5766
  readonly id: string & import("effect/Brand").Brand<"Model.ID">;
5595
5767
  readonly providerID: string & import("effect/Brand").Brand<"ProviderV2.ID">;
5596
5768
  readonly variant?: (string & import("effect/Brand").Brand<"Model.VariantID">) | undefined;
5597
5769
  };
5598
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5770
+ readonly agent: string & import("effect/Brand").Brand<"Agent.ID">;
5771
+ readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5599
5772
  readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
5600
5773
  };
5601
- readonly metadata?: {
5602
- readonly [x: string]: unknown;
5603
- } | undefined;
5774
+ readonly durable: Schema.Struct.ReadonlySide<{
5775
+ readonly aggregateID: Schema.String;
5776
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5777
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5778
+ }, "Type">;
5779
+ readonly type: "session.step.started";
5780
+ readonly created: import("effect/DateTime").Utc;
5604
5781
  readonly location?: {
5605
5782
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5606
5783
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5607
5784
  } | undefined;
5785
+ readonly metadata?: {
5786
+ readonly [x: string]: unknown;
5787
+ } | undefined;
5608
5788
  } | {
5609
5789
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5610
- readonly created: import("effect/DateTime").Utc;
5611
- readonly type: "session.step.ended";
5612
- readonly durable: {
5613
- readonly aggregateID: string;
5614
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5615
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5616
- };
5617
5790
  readonly data: {
5618
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5619
- readonly finish: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
5620
- readonly cost: number & import("effect/Brand").Brand<"Money.USD">;
5621
- readonly tokens: {
5622
- readonly input: number;
5623
- readonly output: number;
5624
- readonly reasoning: number;
5625
- readonly cache: {
5626
- readonly read: number;
5627
- readonly write: number;
5628
- };
5629
- };
5630
5791
  readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5631
- readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
5792
+ readonly cost: number & import("effect/Brand").Brand<"Money.USD">;
5793
+ readonly finish: "length" | "error" | "stop" | "tool-calls" | "content-filter" | "unknown";
5794
+ readonly tokens: Schema.Struct.ReadonlySide<{
5795
+ readonly input: Schema.Finite;
5796
+ readonly output: Schema.Finite;
5797
+ readonly reasoning: Schema.Finite;
5798
+ readonly cache: Schema.Struct<{
5799
+ readonly read: Schema.Finite;
5800
+ readonly write: Schema.Finite;
5801
+ }>;
5802
+ }, "Type">;
5803
+ readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5632
5804
  readonly files?: readonly (string & import("effect/Brand").Brand<"RelativePath">)[] | undefined;
5805
+ readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
5633
5806
  };
5634
- readonly metadata?: {
5635
- readonly [x: string]: unknown;
5636
- } | undefined;
5807
+ readonly durable: Schema.Struct.ReadonlySide<{
5808
+ readonly aggregateID: Schema.String;
5809
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5810
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5811
+ }, "Type">;
5812
+ readonly type: "session.step.ended";
5813
+ readonly created: import("effect/DateTime").Utc;
5637
5814
  readonly location?: {
5638
5815
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5639
5816
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5640
5817
  } | undefined;
5818
+ readonly metadata?: {
5819
+ readonly [x: string]: unknown;
5820
+ } | undefined;
5641
5821
  } | {
5642
5822
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5643
- readonly created: import("effect/DateTime").Utc;
5644
- readonly type: "session.step.failed";
5645
- readonly durable: {
5646
- readonly aggregateID: string;
5647
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5648
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5649
- };
5650
5823
  readonly data: {
5651
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5652
- readonly error: {
5653
- readonly type: string;
5654
- readonly message: string;
5655
- };
5656
5824
  readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5825
+ readonly error: Schema.Struct.ReadonlySide<{
5826
+ readonly type: Schema.String;
5827
+ readonly message: Schema.String;
5828
+ }, "Type">;
5829
+ readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5657
5830
  readonly cost?: (number & import("effect/Brand").Brand<"Money.USD">) | undefined;
5658
- readonly tokens?: {
5659
- readonly input: number;
5660
- readonly output: number;
5661
- readonly reasoning: number;
5662
- readonly cache: {
5663
- readonly read: number;
5664
- readonly write: number;
5665
- };
5666
- } | undefined;
5831
+ readonly tokens?: Schema.Struct.ReadonlySide<{
5832
+ readonly input: Schema.Finite;
5833
+ readonly output: Schema.Finite;
5834
+ readonly reasoning: Schema.Finite;
5835
+ readonly cache: Schema.Struct<{
5836
+ readonly read: Schema.Finite;
5837
+ readonly write: Schema.Finite;
5838
+ }>;
5839
+ }, "Type"> | undefined;
5667
5840
  };
5668
- readonly metadata?: {
5669
- readonly [x: string]: unknown;
5670
- } | undefined;
5841
+ readonly durable: Schema.Struct.ReadonlySide<{
5842
+ readonly aggregateID: Schema.String;
5843
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5844
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5845
+ }, "Type">;
5846
+ readonly type: "session.step.failed";
5847
+ readonly created: import("effect/DateTime").Utc;
5671
5848
  readonly location?: {
5672
5849
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5673
5850
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5674
5851
  } | undefined;
5675
- } | {
5676
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5677
- readonly created: import("effect/DateTime").Utc;
5678
- readonly type: "session.text.started";
5679
- readonly durable: {
5680
- readonly aggregateID: string;
5681
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5682
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5683
- };
5684
- readonly data: {
5685
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5686
- readonly ordinal: number;
5687
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5688
- };
5689
5852
  readonly metadata?: {
5690
5853
  readonly [x: string]: unknown;
5691
5854
  } | undefined;
5855
+ } | {
5856
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5857
+ readonly data: Schema.Struct.ReadonlySide<{
5858
+ readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
5859
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
5860
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
5861
+ };
5862
+ readonly ordinal: Schema.Int;
5863
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5864
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5865
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5866
+ };
5867
+ }, "Type">;
5868
+ readonly durable: Schema.Struct.ReadonlySide<{
5869
+ readonly aggregateID: Schema.String;
5870
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5871
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5872
+ }, "Type">;
5873
+ readonly type: "session.text.started";
5874
+ readonly created: import("effect/DateTime").Utc;
5692
5875
  readonly location?: {
5693
5876
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5694
5877
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5695
5878
  } | undefined;
5696
- } | {
5697
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5698
- readonly created: import("effect/DateTime").Utc;
5699
- readonly type: "session.text.ended";
5700
- readonly durable: {
5701
- readonly aggregateID: string;
5702
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5703
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5704
- };
5705
- readonly data: {
5706
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5707
- readonly ordinal: number;
5708
- readonly text: string;
5709
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5710
- };
5711
5879
  readonly metadata?: {
5712
5880
  readonly [x: string]: unknown;
5713
5881
  } | undefined;
5882
+ } | {
5883
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5884
+ readonly data: Schema.Struct.ReadonlySide<{
5885
+ readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
5886
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
5887
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
5888
+ };
5889
+ readonly ordinal: Schema.Int;
5890
+ readonly text: Schema.String;
5891
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5892
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5893
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5894
+ };
5895
+ }, "Type">;
5896
+ readonly durable: Schema.Struct.ReadonlySide<{
5897
+ readonly aggregateID: Schema.String;
5898
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5899
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5900
+ }, "Type">;
5901
+ readonly type: "session.text.ended";
5902
+ readonly created: import("effect/DateTime").Utc;
5714
5903
  readonly location?: {
5715
5904
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5716
5905
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5717
5906
  } | undefined;
5907
+ readonly metadata?: {
5908
+ readonly [x: string]: unknown;
5909
+ } | undefined;
5718
5910
  } | {
5719
5911
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5720
- readonly created: import("effect/DateTime").Utc;
5721
- readonly type: "session.reasoning.started";
5722
- readonly durable: {
5723
- readonly aggregateID: string;
5724
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5725
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5726
- };
5727
5912
  readonly data: {
5913
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5728
5914
  readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5729
5915
  readonly ordinal: number;
5730
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5731
5916
  readonly state?: {
5732
5917
  readonly [x: string]: unknown;
5733
5918
  } | undefined;
5734
5919
  };
5735
- readonly metadata?: {
5736
- readonly [x: string]: unknown;
5737
- } | undefined;
5920
+ readonly durable: Schema.Struct.ReadonlySide<{
5921
+ readonly aggregateID: Schema.String;
5922
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5923
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5924
+ }, "Type">;
5925
+ readonly type: "session.reasoning.started";
5926
+ readonly created: import("effect/DateTime").Utc;
5738
5927
  readonly location?: {
5739
5928
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5740
5929
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5741
5930
  } | undefined;
5931
+ readonly metadata?: {
5932
+ readonly [x: string]: unknown;
5933
+ } | undefined;
5742
5934
  } | {
5743
5935
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5744
- readonly created: import("effect/DateTime").Utc;
5745
- readonly type: "session.reasoning.ended";
5746
- readonly durable: {
5747
- readonly aggregateID: string;
5748
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5749
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5750
- };
5751
5936
  readonly data: {
5937
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5938
+ readonly text: string;
5752
5939
  readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5753
5940
  readonly ordinal: number;
5754
- readonly text: string;
5755
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5756
5941
  readonly state?: {
5757
5942
  readonly [x: string]: unknown;
5758
5943
  } | undefined;
5759
5944
  };
5760
- readonly metadata?: {
5761
- readonly [x: string]: unknown;
5762
- } | undefined;
5945
+ readonly durable: Schema.Struct.ReadonlySide<{
5946
+ readonly aggregateID: Schema.String;
5947
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5948
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5949
+ }, "Type">;
5950
+ readonly type: "session.reasoning.ended";
5951
+ readonly created: import("effect/DateTime").Utc;
5763
5952
  readonly location?: {
5764
5953
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5765
5954
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5766
5955
  } | undefined;
5767
- } | {
5768
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5769
- readonly created: import("effect/DateTime").Utc;
5770
- readonly type: "session.tool.input.started";
5771
- readonly durable: {
5772
- readonly aggregateID: string;
5773
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5774
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5775
- };
5776
- readonly data: {
5777
- readonly name: string;
5778
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5779
- readonly callID: string;
5780
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5781
- };
5782
5956
  readonly metadata?: {
5783
5957
  readonly [x: string]: unknown;
5784
5958
  } | undefined;
5959
+ } | {
5960
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5961
+ readonly data: Schema.Struct.ReadonlySide<{
5962
+ readonly name: Schema.String;
5963
+ readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
5964
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
5965
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
5966
+ };
5967
+ readonly callID: Schema.String;
5968
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5969
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5970
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5971
+ };
5972
+ }, "Type">;
5973
+ readonly durable: Schema.Struct.ReadonlySide<{
5974
+ readonly aggregateID: Schema.String;
5975
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
5976
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
5977
+ }, "Type">;
5978
+ readonly type: "session.tool.input.started";
5979
+ readonly created: import("effect/DateTime").Utc;
5785
5980
  readonly location?: {
5786
5981
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5787
5982
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5788
5983
  } | undefined;
5789
- } | {
5790
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5791
- readonly created: import("effect/DateTime").Utc;
5792
- readonly type: "session.tool.input.ended";
5793
- readonly durable: {
5794
- readonly aggregateID: string;
5795
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5796
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5797
- };
5798
- readonly data: {
5799
- readonly text: string;
5800
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5801
- readonly callID: string;
5802
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5803
- };
5804
5984
  readonly metadata?: {
5805
5985
  readonly [x: string]: unknown;
5806
5986
  } | undefined;
5987
+ } | {
5988
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5989
+ readonly data: Schema.Struct.ReadonlySide<{
5990
+ readonly text: Schema.String;
5991
+ readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
5992
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
5993
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
5994
+ };
5995
+ readonly callID: Schema.String;
5996
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
5997
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
5998
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
5999
+ };
6000
+ }, "Type">;
6001
+ readonly durable: Schema.Struct.ReadonlySide<{
6002
+ readonly aggregateID: Schema.String;
6003
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6004
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6005
+ }, "Type">;
6006
+ readonly type: "session.tool.input.ended";
6007
+ readonly created: import("effect/DateTime").Utc;
5807
6008
  readonly location?: {
5808
6009
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5809
6010
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5810
6011
  } | undefined;
6012
+ readonly metadata?: {
6013
+ readonly [x: string]: unknown;
6014
+ } | undefined;
5811
6015
  } | {
5812
6016
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5813
- readonly created: import("effect/DateTime").Utc;
5814
- readonly type: "session.tool.called";
5815
- readonly durable: {
5816
- readonly aggregateID: string;
5817
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5818
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5819
- };
5820
6017
  readonly data: {
6018
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5821
6019
  readonly input: {
5822
6020
  readonly [x: string]: unknown;
5823
6021
  };
6022
+ readonly callID: string;
5824
6023
  readonly executed: boolean;
5825
6024
  readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5826
- readonly callID: string;
5827
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5828
6025
  readonly state?: {
5829
6026
  readonly [x: string]: unknown;
5830
6027
  } | undefined;
5831
6028
  };
5832
- readonly metadata?: {
5833
- readonly [x: string]: unknown;
5834
- } | undefined;
6029
+ readonly durable: Schema.Struct.ReadonlySide<{
6030
+ readonly aggregateID: Schema.String;
6031
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6032
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6033
+ }, "Type">;
6034
+ readonly type: "session.tool.called";
6035
+ readonly created: import("effect/DateTime").Utc;
5835
6036
  readonly location?: {
5836
6037
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5837
6038
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5838
6039
  } | undefined;
5839
- } | {
5840
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5841
- readonly created: import("effect/DateTime").Utc;
5842
- readonly type: "session.tool.progress";
5843
- readonly durable: {
5844
- readonly aggregateID: string;
5845
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5846
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5847
- };
5848
- readonly data: {
5849
- readonly structured: {
5850
- readonly [x: string]: unknown;
5851
- };
5852
- readonly content: readonly ({
5853
- readonly type: "text";
5854
- readonly text: string;
5855
- } | {
5856
- readonly type: "file";
5857
- readonly uri: string;
5858
- readonly mime: string;
5859
- readonly name?: string | undefined;
5860
- })[];
5861
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5862
- readonly callID: string;
5863
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5864
- };
5865
6040
  readonly metadata?: {
5866
6041
  readonly [x: string]: unknown;
5867
6042
  } | undefined;
6043
+ } | {
6044
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6045
+ readonly data: Schema.Struct.ReadonlySide<{
6046
+ readonly structured: Schema.$Record<Schema.String, Schema.Unknown>;
6047
+ readonly content: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
6048
+ readonly type: Schema.Literal<"text">;
6049
+ readonly text: Schema.String;
6050
+ }>, Schema.Struct<{
6051
+ readonly type: Schema.Literal<"file">;
6052
+ readonly uri: Schema.String;
6053
+ readonly mime: Schema.String;
6054
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6055
+ }>]>>;
6056
+ readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6057
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6058
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6059
+ };
6060
+ readonly callID: Schema.String;
6061
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
6062
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6063
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6064
+ };
6065
+ }, "Type">;
6066
+ readonly durable: Schema.Struct.ReadonlySide<{
6067
+ readonly aggregateID: Schema.String;
6068
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6069
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6070
+ }, "Type">;
6071
+ readonly type: "session.tool.progress";
6072
+ readonly created: import("effect/DateTime").Utc;
5868
6073
  readonly location?: {
5869
6074
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5870
6075
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5871
6076
  } | undefined;
6077
+ readonly metadata?: {
6078
+ readonly [x: string]: unknown;
6079
+ } | undefined;
5872
6080
  } | {
5873
6081
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5874
- readonly created: import("effect/DateTime").Utc;
5875
- readonly type: "session.tool.success";
5876
- readonly durable: {
5877
- readonly aggregateID: string;
5878
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5879
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5880
- };
5881
6082
  readonly data: {
5882
- readonly structured: {
5883
- readonly [x: string]: unknown;
5884
- };
5885
- readonly content: readonly ({
5886
- readonly type: "text";
5887
- readonly text: string;
5888
- } | {
6083
+ readonly content: readonly (Schema.Struct.ReadonlySide<{
6084
+ readonly type: Schema.Literal<"text">;
6085
+ readonly text: Schema.String;
6086
+ }, "Type"> | {
5889
6087
  readonly type: "file";
5890
6088
  readonly uri: string;
5891
6089
  readonly mime: string;
5892
6090
  readonly name?: string | undefined;
5893
6091
  })[];
6092
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6093
+ readonly callID: string;
6094
+ readonly structured: {
6095
+ readonly [x: string]: unknown;
6096
+ };
5894
6097
  readonly executed: boolean;
5895
6098
  readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5896
- readonly callID: string;
5897
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5898
6099
  readonly result?: unknown;
5899
6100
  readonly resultState?: {
5900
6101
  readonly [x: string]: unknown;
5901
6102
  } | undefined;
5902
6103
  };
5903
- readonly metadata?: {
5904
- readonly [x: string]: unknown;
5905
- } | undefined;
6104
+ readonly durable: Schema.Struct.ReadonlySide<{
6105
+ readonly aggregateID: Schema.String;
6106
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6107
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6108
+ }, "Type">;
6109
+ readonly type: "session.tool.success";
6110
+ readonly created: import("effect/DateTime").Utc;
5906
6111
  readonly location?: {
5907
6112
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5908
6113
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5909
6114
  } | undefined;
6115
+ readonly metadata?: {
6116
+ readonly [x: string]: unknown;
6117
+ } | undefined;
5910
6118
  } | {
5911
6119
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5912
- readonly created: import("effect/DateTime").Utc;
5913
- readonly type: "session.tool.failed";
5914
- readonly durable: {
5915
- readonly aggregateID: string;
5916
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5917
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5918
- };
5919
6120
  readonly data: {
5920
- readonly error: {
5921
- readonly type: string;
5922
- readonly message: string;
5923
- };
6121
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6122
+ readonly error: Schema.Struct.ReadonlySide<{
6123
+ readonly type: Schema.String;
6124
+ readonly message: Schema.String;
6125
+ }, "Type">;
6126
+ readonly callID: string;
5924
6127
  readonly executed: boolean;
5925
6128
  readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5926
- readonly callID: string;
5927
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5928
6129
  readonly result?: unknown;
5929
6130
  readonly resultState?: {
5930
6131
  readonly [x: string]: unknown;
5931
6132
  } | undefined;
5932
6133
  };
5933
- readonly metadata?: {
5934
- readonly [x: string]: unknown;
5935
- } | undefined;
6134
+ readonly durable: Schema.Struct.ReadonlySide<{
6135
+ readonly aggregateID: Schema.String;
6136
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6137
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6138
+ }, "Type">;
6139
+ readonly type: "session.tool.failed";
6140
+ readonly created: import("effect/DateTime").Utc;
5936
6141
  readonly location?: {
5937
6142
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5938
6143
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5939
6144
  } | undefined;
5940
- } | {
5941
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5942
- readonly created: import("effect/DateTime").Utc;
5943
- readonly type: "session.retry.scheduled";
5944
- readonly durable: {
5945
- readonly aggregateID: string;
5946
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5947
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5948
- };
5949
- readonly data: {
5950
- readonly assistantMessageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5951
- readonly attempt: number;
5952
- readonly at: number;
5953
- readonly error: {
5954
- readonly type: string;
5955
- readonly message: string;
5956
- };
5957
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5958
- };
5959
6145
  readonly metadata?: {
5960
6146
  readonly [x: string]: unknown;
5961
6147
  } | undefined;
6148
+ } | {
6149
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6150
+ readonly data: Schema.Struct.ReadonlySide<{
6151
+ readonly assistantMessageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6152
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6153
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6154
+ };
6155
+ readonly attempt: Schema.Int;
6156
+ readonly at: Schema.Int;
6157
+ readonly error: Schema.Struct<{
6158
+ readonly type: Schema.String;
6159
+ readonly message: Schema.String;
6160
+ }>;
6161
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
6162
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6163
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6164
+ };
6165
+ }, "Type">;
6166
+ readonly durable: Schema.Struct.ReadonlySide<{
6167
+ readonly aggregateID: Schema.String;
6168
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6169
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6170
+ }, "Type">;
6171
+ readonly type: "session.retry.scheduled";
6172
+ readonly created: import("effect/DateTime").Utc;
5962
6173
  readonly location?: {
5963
6174
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5964
6175
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5965
6176
  } | undefined;
5966
- } | {
5967
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5968
- readonly created: import("effect/DateTime").Utc;
5969
- readonly type: "session.compaction.admitted";
5970
- readonly durable: {
5971
- readonly aggregateID: string;
5972
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5973
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5974
- };
5975
- readonly data: {
5976
- readonly inputID: string & import("effect/Brand").Brand<"Session.Message.ID">;
5977
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5978
- };
5979
6177
  readonly metadata?: {
5980
6178
  readonly [x: string]: unknown;
5981
6179
  } | undefined;
6180
+ } | {
6181
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6182
+ readonly data: Schema.Struct.ReadonlySide<{
6183
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6184
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6185
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6186
+ };
6187
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
6188
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6189
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6190
+ };
6191
+ }, "Type">;
6192
+ readonly durable: Schema.Struct.ReadonlySide<{
6193
+ readonly aggregateID: Schema.String;
6194
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6195
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6196
+ }, "Type">;
6197
+ readonly type: "session.compaction.admitted";
6198
+ readonly created: import("effect/DateTime").Utc;
5982
6199
  readonly location?: {
5983
6200
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
5984
6201
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
5985
6202
  } | undefined;
6203
+ readonly metadata?: {
6204
+ readonly [x: string]: unknown;
6205
+ } | undefined;
5986
6206
  } | {
5987
6207
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
5988
- readonly created: import("effect/DateTime").Utc;
5989
- readonly type: "session.compaction.started";
5990
- readonly durable: {
5991
- readonly aggregateID: string;
5992
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
5993
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
5994
- };
5995
6208
  readonly data: {
6209
+ readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5996
6210
  readonly reason: "auto" | "manual";
5997
6211
  readonly recent: string;
5998
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
5999
6212
  readonly inputID?: (string & import("effect/Brand").Brand<"Session.Message.ID">) | undefined;
6000
6213
  };
6001
- readonly metadata?: {
6002
- readonly [x: string]: unknown;
6003
- } | undefined;
6214
+ readonly durable: Schema.Struct.ReadonlySide<{
6215
+ readonly aggregateID: Schema.String;
6216
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6217
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6218
+ }, "Type">;
6219
+ readonly type: "session.compaction.started";
6220
+ readonly created: import("effect/DateTime").Utc;
6004
6221
  readonly location?: {
6005
6222
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
6006
6223
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
6007
6224
  } | undefined;
6008
- } | {
6009
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6010
- readonly created: import("effect/DateTime").Utc;
6011
- readonly type: "session.compaction.ended";
6012
- readonly durable: {
6013
- readonly aggregateID: string;
6014
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
6015
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
6016
- };
6017
- readonly data: {
6018
- readonly reason: "auto" | "manual";
6019
- readonly text: string;
6020
- readonly recent: string;
6021
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6022
- };
6023
6225
  readonly metadata?: {
6024
6226
  readonly [x: string]: unknown;
6025
6227
  } | undefined;
6228
+ } | {
6229
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6230
+ readonly data: Schema.Struct.ReadonlySide<{
6231
+ readonly reason: Schema.Literals<readonly ["auto", "manual"]>;
6232
+ readonly text: Schema.String;
6233
+ readonly recent: Schema.String;
6234
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
6235
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6236
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6237
+ };
6238
+ }, "Type">;
6239
+ readonly durable: Schema.Struct.ReadonlySide<{
6240
+ readonly aggregateID: Schema.String;
6241
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6242
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6243
+ }, "Type">;
6244
+ readonly type: "session.compaction.ended";
6245
+ readonly created: import("effect/DateTime").Utc;
6026
6246
  readonly location?: {
6027
6247
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
6028
6248
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
6029
6249
  } | undefined;
6250
+ readonly metadata?: {
6251
+ readonly [x: string]: unknown;
6252
+ } | undefined;
6030
6253
  } | {
6031
6254
  readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6032
- readonly created: import("effect/DateTime").Utc;
6033
- readonly type: "session.compaction.failed";
6034
- readonly durable: {
6035
- readonly aggregateID: string;
6036
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
6037
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
6038
- };
6039
6255
  readonly data: {
6040
- readonly reason: "auto" | "manual";
6041
- readonly error: {
6042
- readonly type: string;
6043
- readonly message: string;
6044
- };
6045
6256
  readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6257
+ readonly error: Schema.Struct.ReadonlySide<{
6258
+ readonly type: Schema.String;
6259
+ readonly message: Schema.String;
6260
+ }, "Type">;
6261
+ readonly reason: "auto" | "manual";
6046
6262
  readonly inputID?: (string & import("effect/Brand").Brand<"Session.Message.ID">) | undefined;
6047
6263
  };
6048
- readonly metadata?: {
6049
- readonly [x: string]: unknown;
6050
- } | undefined;
6264
+ readonly durable: Schema.Struct.ReadonlySide<{
6265
+ readonly aggregateID: Schema.String;
6266
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6267
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6268
+ }, "Type">;
6269
+ readonly type: "session.compaction.failed";
6270
+ readonly created: import("effect/DateTime").Utc;
6051
6271
  readonly location?: {
6052
6272
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
6053
6273
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
6054
6274
  } | undefined;
6055
- } | {
6056
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6057
- readonly created: import("effect/DateTime").Utc;
6058
- readonly type: "session.revert.staged";
6059
- readonly durable: {
6060
- readonly aggregateID: string;
6061
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
6062
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
6063
- };
6064
- readonly data: {
6065
- readonly revert: {
6066
- readonly messageID: string & import("effect/Brand").Brand<"Session.Message.ID">;
6067
- readonly partID?: string | undefined;
6068
- readonly snapshot?: (string & import("effect/Brand").Brand<"Snapshot.ID">) | undefined;
6069
- readonly files?: readonly {
6070
- readonly file: string;
6071
- readonly patch: string;
6072
- readonly additions: number;
6073
- readonly deletions: number;
6074
- readonly status: "added" | "deleted" | "modified";
6075
- }[] | undefined;
6076
- };
6077
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6078
- };
6079
6275
  readonly metadata?: {
6080
6276
  readonly [x: string]: unknown;
6081
6277
  } | undefined;
6278
+ } | {
6279
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6280
+ readonly data: Schema.Struct.ReadonlySide<{
6281
+ readonly revert: Schema.Struct<{
6282
+ readonly messageID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6283
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6284
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6285
+ };
6286
+ readonly partID: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6287
+ readonly snapshot: Schema.decodeTo<Schema.optional<Schema.toType<Schema.brand<Schema.String, "Snapshot.ID">>>, Schema.optionalKey<Schema.brand<Schema.String, "Snapshot.ID">>, never, never>;
6288
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6289
+ readonly file: Schema.String;
6290
+ readonly patch: Schema.String;
6291
+ readonly additions: Schema.Int;
6292
+ readonly deletions: Schema.Int;
6293
+ readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
6294
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6295
+ readonly file: Schema.String;
6296
+ readonly patch: Schema.String;
6297
+ readonly additions: Schema.Int;
6298
+ readonly deletions: Schema.Int;
6299
+ readonly status: Schema.Literals<readonly ["added", "deleted", "modified"]>;
6300
+ }>>>, never, never>;
6301
+ }>;
6302
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
6303
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6304
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6305
+ };
6306
+ }, "Type">;
6307
+ readonly durable: Schema.Struct.ReadonlySide<{
6308
+ readonly aggregateID: Schema.String;
6309
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6310
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6311
+ }, "Type">;
6312
+ readonly type: "session.revert.staged";
6313
+ readonly created: import("effect/DateTime").Utc;
6082
6314
  readonly location?: {
6083
6315
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
6084
6316
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
6085
6317
  } | undefined;
6086
- } | {
6087
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6088
- readonly created: import("effect/DateTime").Utc;
6089
- readonly type: "session.revert.cleared";
6090
- readonly durable: {
6091
- readonly aggregateID: string;
6092
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
6093
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
6094
- };
6095
- readonly data: {
6096
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6097
- };
6098
6318
  readonly metadata?: {
6099
6319
  readonly [x: string]: unknown;
6100
6320
  } | undefined;
6321
+ } | {
6322
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6323
+ readonly data: Schema.Struct.ReadonlySide<{
6324
+ sessionID: Schema.brand<Schema.String, "SessionID"> & {
6325
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6326
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6327
+ };
6328
+ }, "Type">;
6329
+ readonly durable: Schema.Struct.ReadonlySide<{
6330
+ readonly aggregateID: Schema.String;
6331
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6332
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6333
+ }, "Type">;
6334
+ readonly type: "session.revert.cleared";
6335
+ readonly created: import("effect/DateTime").Utc;
6101
6336
  readonly location?: {
6102
6337
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
6103
6338
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
6104
6339
  } | undefined;
6105
- } | {
6106
- readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6107
- readonly created: import("effect/DateTime").Utc;
6108
- readonly type: "session.revert.committed";
6109
- readonly durable: {
6110
- readonly aggregateID: string;
6111
- readonly seq: number & import("effect/Brand").Brand<"Event.Seq">;
6112
- readonly version: number & import("effect/Brand").Brand<"Event.Version">;
6113
- };
6114
- readonly data: {
6115
- readonly to: string & import("effect/Brand").Brand<"Session.Message.ID">;
6116
- readonly sessionID: string & import("effect/Brand").Brand<"SessionID">;
6117
- };
6118
6340
  readonly metadata?: {
6119
6341
  readonly [x: string]: unknown;
6120
6342
  } | undefined;
6343
+ } | {
6344
+ readonly id: string & import("effect/Brand").Brand<"Event.ID">;
6345
+ readonly data: Schema.Struct.ReadonlySide<{
6346
+ readonly to: Schema.brand<Schema.String, "Session.Message.ID"> & {
6347
+ create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6348
+ fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6349
+ };
6350
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
6351
+ create: () => string & import("effect/Brand").Brand<"SessionID">;
6352
+ descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6353
+ };
6354
+ }, "Type">;
6355
+ readonly durable: Schema.Struct.ReadonlySide<{
6356
+ readonly aggregateID: Schema.String;
6357
+ readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
6358
+ readonly version: Schema.decodeTo<Schema.toType<Schema.brand<Schema.Int, "Event.Version">>, Schema.Literal<number>, never, never>;
6359
+ }, "Type">;
6360
+ readonly type: "session.revert.committed";
6361
+ readonly created: import("effect/DateTime").Utc;
6121
6362
  readonly location?: {
6122
6363
  readonly directory: string & import("effect/Brand").Brand<"AbsolutePath">;
6123
6364
  readonly workspaceID?: (string & import("effect/Brand").Brand<"WorkspaceV2.ID">) | undefined;
6124
6365
  } | undefined;
6366
+ readonly metadata?: {
6367
+ readonly [x: string]: unknown;
6368
+ } | undefined;
6125
6369
  } | {
6126
- readonly type: "log.synced";
6127
6370
  readonly aggregateID: string;
6371
+ readonly type: "log.synced";
6128
6372
  readonly seq?: (number & import("effect/Brand").Brand<"Event.Seq">) | undefined;
6129
- }>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.interrupt", "POST", "/api/session/:sessionID/interrupt", HttpApiEndpoint.StringTree<Schema.Struct<{
6373
+ }>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.interrupt", "POST", "/api/session/:sessionID/interrupt", Schema.toCodecStringTree<Schema.Struct<{
6130
6374
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
6131
6375
  create: () => string & import("effect/Brand").Brand<"SessionID">;
6132
6376
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6133
6377
  };
6134
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.background", "POST", "/api/session/:sessionID/background", HttpApiEndpoint.StringTree<Schema.Struct<{
6378
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.background", "POST", "/api/session/:sessionID/background", Schema.toCodecStringTree<Schema.Struct<{
6135
6379
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
6136
6380
  create: () => string & import("effect/Brand").Brand<"SessionID">;
6137
6381
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
6138
6382
  };
6139
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<HttpApiSchema.NoContent>, HttpApiEndpoint.Json<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.message", "GET", "/api/session/:sessionID/message/:messageID", HttpApiEndpoint.StringTree<Schema.Struct<{
6383
+ }>>, never, never, never, Schema.toCodecJson<HttpApiSchema.NoContent>, Schema.toCodecJson<typeof SessionNotFoundError>, I, HttpApiMiddleware.Requires<I>> | HttpApiEndpoint.HttpApiEndpoint<"session.message", "GET", "/api/session/:sessionID/message/:messageID", Schema.toCodecStringTree<Schema.Struct<{
6140
6384
  sessionID: Schema.brand<Schema.String, "SessionID"> & {
6141
6385
  create: () => string & import("effect/Brand").Brand<"SessionID">;
6142
6386
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
@@ -6145,7 +6389,7 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
6145
6389
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6146
6390
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6147
6391
  };
6148
- }>>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.StringTree<never>, HttpApiEndpoint.Json<Schema.Struct<{
6392
+ }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
6149
6393
  readonly data: Schema.Union<readonly [Schema.Struct<{
6150
6394
  readonly type: Schema.tag<"agent-switched">;
6151
6395
  readonly agent: Schema.brand<Schema.String, "Agent.ID">;
@@ -6260,20 +6504,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
6260
6504
  }> & {
6261
6505
  create: (input: SessionEvent.FileAttachment) => {
6262
6506
  readonly data: string;
6507
+ readonly source: Schema.Struct.ReadonlySide<{
6508
+ readonly type: Schema.Literal<"inline">;
6509
+ }, "Type"> | Schema.Struct.ReadonlySide<{
6510
+ readonly type: Schema.Literal<"uri">;
6511
+ readonly uri: Schema.String;
6512
+ }, "Type">;
6263
6513
  readonly mime: string;
6264
- readonly source: {
6265
- readonly type: "inline";
6266
- } | {
6267
- readonly type: "uri";
6268
- readonly uri: string;
6269
- };
6270
- readonly name?: string | undefined;
6271
6514
  readonly description?: string | undefined;
6272
- readonly mention?: {
6273
- readonly start: number;
6274
- readonly end: number;
6275
- readonly text: string;
6276
- } | undefined;
6515
+ readonly name?: string | undefined;
6516
+ readonly mention?: Schema.Struct.ReadonlySide<{
6517
+ readonly start: Schema.Finite;
6518
+ readonly end: Schema.Finite;
6519
+ readonly text: Schema.String;
6520
+ }, "Type"> | undefined;
6277
6521
  };
6278
6522
  }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6279
6523
  readonly data: Schema.String;
@@ -6298,20 +6542,20 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
6298
6542
  }> & {
6299
6543
  create: (input: SessionEvent.FileAttachment) => {
6300
6544
  readonly data: string;
6545
+ readonly source: Schema.Struct.ReadonlySide<{
6546
+ readonly type: Schema.Literal<"inline">;
6547
+ }, "Type"> | Schema.Struct.ReadonlySide<{
6548
+ readonly type: Schema.Literal<"uri">;
6549
+ readonly uri: Schema.String;
6550
+ }, "Type">;
6301
6551
  readonly mime: string;
6302
- readonly source: {
6303
- readonly type: "inline";
6304
- } | {
6305
- readonly type: "uri";
6306
- readonly uri: string;
6307
- };
6308
- readonly name?: string | undefined;
6309
6552
  readonly description?: string | undefined;
6310
- readonly mention?: {
6311
- readonly start: number;
6312
- readonly end: number;
6313
- readonly text: string;
6314
- } | undefined;
6553
+ readonly name?: string | undefined;
6554
+ readonly mention?: Schema.Struct.ReadonlySide<{
6555
+ readonly start: Schema.Finite;
6556
+ readonly end: Schema.Finite;
6557
+ readonly text: Schema.String;
6558
+ }, "Type"> | undefined;
6315
6559
  };
6316
6560
  }>>, never, never>;
6317
6561
  readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
@@ -6621,5 +6865,5 @@ export declare const makeSessionGroup: <I extends HttpApiMiddleware.AnyId, S>(se
6621
6865
  }>;
6622
6866
  readonly type: Schema.tag<"compaction">;
6623
6867
  }>]>]>;
6624
- }>>, HttpApiEndpoint.Json<typeof SessionNotFoundError | typeof MessageNotFoundError>, I, HttpApiMiddleware.Requires<I>>, false>;
6868
+ }>>, Schema.toCodecJson<typeof SessionNotFoundError | typeof MessageNotFoundError>, I, HttpApiMiddleware.Requires<I>>, false>;
6625
6869
  export {};