@opencode-ai/schema 0.0.0-next-15174 → 0.0.0-next-15180

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 (7) hide show
  1. package/dist/durable-event-manifest.d.ts +232 -322
  2. package/dist/event-manifest.d.ts +464 -644
  3. package/dist/session-event.d.ts +1165 -1615
  4. package/dist/session-event.js +12 -14
  5. package/dist/session-input.d.ts +284 -181
  6. package/dist/session-input.js +35 -13
  7. package/package.json +1 -1
package/dist/session-event.d.ts CHANGED
@@ -1,7 +1,7 @@
1
1
  export * as SessionEvent from "./session-event.js";
2
2
  import { Schema } from "effect";
3
3
  import { Event } from "./event.js";
4
- import { FileAttachment, Prompt } from "./prompt.js";
4
+ import { FileAttachment } from "./prompt.js";
5
5
  export { FileAttachment };
6
6
  export declare const Source: Schema.Struct<{
7
7
  readonly start: Schema.Int;
@@ -472,13 +472,13 @@ export declare const Forked: Schema.Struct<{
472
472
  }>;
473
473
  };
474
474
  export type Forked = typeof Forked.Type;
475
- export declare const PromptPromoted: Schema.Struct<{
475
+ export declare const InputPromoted: Schema.Struct<{
476
476
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
477
477
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
478
478
  };
479
479
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
480
480
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
481
- readonly type: Schema.Literal<"session.prompt.promoted">;
481
+ readonly type: Schema.Literal<"session.input.promoted">;
482
482
  readonly durable: Schema.Struct<{
483
483
  readonly aggregateID: Schema.String;
484
484
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -514,7 +514,7 @@ export declare const PromptPromoted: Schema.Struct<{
514
514
  };
515
515
  }>;
516
516
  }> & {
517
- type: "session.prompt.promoted";
517
+ type: "session.input.promoted";
518
518
  durability: "durable";
519
519
  durable: {
520
520
  readonly version: number;
@@ -531,14 +531,14 @@ export declare const PromptPromoted: Schema.Struct<{
531
531
  };
532
532
  }>;
533
533
  };
534
- export type PromptPromoted = typeof PromptPromoted.Type;
535
- export declare const PromptAdmitted: Schema.Struct<{
534
+ export type InputPromoted = typeof InputPromoted.Type;
535
+ export declare const InputAdmitted: Schema.Struct<{
536
536
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
537
537
  create: () => string & import("effect/Brand").Brand<"Event.ID">;
538
538
  };
539
539
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
540
540
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
541
- readonly type: Schema.Literal<"session.prompt.admitted">;
541
+ readonly type: Schema.Literal<"session.input.admitted">;
542
542
  readonly durable: Schema.Struct<{
543
543
  readonly aggregateID: Schema.String;
544
544
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -564,356 +564,266 @@ export declare const PromptAdmitted: Schema.Struct<{
564
564
  }>, never, never>;
565
565
  }>>, never, never>;
566
566
  readonly data: Schema.Struct<{
567
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
567
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
568
568
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
569
569
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
570
570
  };
571
- prompt: Schema.Struct<{
572
- readonly text: Schema.String;
573
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
574
- readonly data: Schema.String;
575
- readonly mime: Schema.String;
576
- readonly source: Schema.Union<readonly [Schema.Struct<{
577
- readonly type: Schema.Literal<"inline">;
578
- }>, Schema.Struct<{
579
- readonly type: Schema.Literal<"uri">;
580
- readonly uri: Schema.String;
581
- }>]>;
582
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
583
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
584
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
585
- readonly start: Schema.Finite;
586
- readonly end: Schema.Finite;
587
- readonly text: Schema.String;
588
- }>>>, Schema.optionalKey<Schema.Struct<{
589
- readonly start: Schema.Finite;
590
- readonly end: Schema.Finite;
591
- readonly text: Schema.String;
592
- }>>, never, never>;
593
- }> & {
594
- create: (input: FileAttachment) => {
595
- readonly data: string;
596
- readonly mime: string;
597
- readonly source: {
598
- readonly type: "inline";
599
- } | {
600
- readonly type: "uri";
601
- readonly uri: string;
571
+ readonly input: Schema.Union<readonly [Schema.Struct<{
572
+ readonly type: Schema.tag<"user">;
573
+ readonly data: Schema.Struct<{
574
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
575
+ readonly text: Schema.String;
576
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
577
+ readonly data: Schema.String;
578
+ readonly mime: Schema.String;
579
+ readonly source: Schema.Union<readonly [Schema.Struct<{
580
+ readonly type: Schema.Literal<"inline">;
581
+ }>, Schema.Struct<{
582
+ readonly type: Schema.Literal<"uri">;
583
+ readonly uri: Schema.String;
584
+ }>]>;
585
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
586
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
587
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
588
+ readonly start: Schema.Finite;
589
+ readonly end: Schema.Finite;
590
+ readonly text: Schema.String;
591
+ }>>>, Schema.optionalKey<Schema.Struct<{
592
+ readonly start: Schema.Finite;
593
+ readonly end: Schema.Finite;
594
+ readonly text: Schema.String;
595
+ }>>, never, never>;
596
+ }> & {
597
+ create: (input: FileAttachment) => {
598
+ readonly data: string;
599
+ readonly mime: string;
600
+ readonly source: {
601
+ readonly type: "inline";
602
+ } | {
603
+ readonly type: "uri";
604
+ readonly uri: string;
605
+ };
606
+ readonly name?: string | undefined;
607
+ readonly description?: string | undefined;
608
+ readonly mention?: {
609
+ readonly start: number;
610
+ readonly end: number;
611
+ readonly text: string;
612
+ } | undefined;
602
613
  };
603
- readonly name?: string | undefined;
604
- readonly description?: string | undefined;
605
- readonly mention?: {
606
- readonly start: number;
607
- readonly end: number;
608
- readonly text: string;
609
- } | undefined;
610
- };
611
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
612
- readonly data: Schema.String;
613
- readonly mime: Schema.String;
614
- readonly source: Schema.Union<readonly [Schema.Struct<{
615
- readonly type: Schema.Literal<"inline">;
616
- }>, Schema.Struct<{
617
- readonly type: Schema.Literal<"uri">;
618
- readonly uri: Schema.String;
619
- }>]>;
620
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
621
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
622
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
623
- readonly start: Schema.Finite;
624
- readonly end: Schema.Finite;
625
- readonly text: Schema.String;
626
- }>>>, Schema.optionalKey<Schema.Struct<{
627
- readonly start: Schema.Finite;
628
- readonly end: Schema.Finite;
629
- readonly text: Schema.String;
630
- }>>, never, never>;
631
- }> & {
632
- create: (input: FileAttachment) => {
633
- readonly data: string;
634
- readonly mime: string;
635
- readonly source: {
636
- readonly type: "inline";
637
- } | {
638
- readonly type: "uri";
639
- readonly uri: string;
614
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
615
+ readonly data: Schema.String;
616
+ readonly mime: Schema.String;
617
+ readonly source: Schema.Union<readonly [Schema.Struct<{
618
+ readonly type: Schema.Literal<"inline">;
619
+ }>, Schema.Struct<{
620
+ readonly type: Schema.Literal<"uri">;
621
+ readonly uri: Schema.String;
622
+ }>]>;
623
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
624
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
625
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
626
+ readonly start: Schema.Finite;
627
+ readonly end: Schema.Finite;
628
+ readonly text: Schema.String;
629
+ }>>>, Schema.optionalKey<Schema.Struct<{
630
+ readonly start: Schema.Finite;
631
+ readonly end: Schema.Finite;
632
+ readonly text: Schema.String;
633
+ }>>, never, never>;
634
+ }> & {
635
+ create: (input: FileAttachment) => {
636
+ readonly data: string;
637
+ readonly mime: string;
638
+ readonly source: {
639
+ readonly type: "inline";
640
+ } | {
641
+ readonly type: "uri";
642
+ readonly uri: string;
643
+ };
644
+ readonly name?: string | undefined;
645
+ readonly description?: string | undefined;
646
+ readonly mention?: {
647
+ readonly start: number;
648
+ readonly end: number;
649
+ readonly text: string;
650
+ } | undefined;
640
651
  };
641
- readonly name?: string | undefined;
642
- readonly description?: string | undefined;
643
- readonly mention?: {
644
- readonly start: number;
645
- readonly end: number;
646
- readonly text: string;
647
- } | undefined;
648
- };
649
- }>>, never, never>;
650
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
651
- readonly name: Schema.String;
652
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
653
- readonly start: Schema.Finite;
654
- readonly end: Schema.Finite;
655
- readonly text: Schema.String;
656
- }>>>, Schema.optionalKey<Schema.Struct<{
657
- readonly start: Schema.Finite;
658
- readonly end: Schema.Finite;
659
- readonly text: Schema.String;
660
652
  }>>, never, never>;
661
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
662
- readonly name: Schema.String;
663
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
664
- readonly start: Schema.Finite;
665
- readonly end: Schema.Finite;
666
- readonly text: Schema.String;
667
- }>>>, Schema.optionalKey<Schema.Struct<{
668
- readonly start: Schema.Finite;
669
- readonly end: Schema.Finite;
670
- readonly text: Schema.String;
671
- }>>, never, never>;
672
- }>>>, never, never>;
673
- }> & {
674
- equivalence: import("effect/Equivalence").Equivalence<{
675
- readonly text: string;
676
- readonly files?: readonly {
677
- readonly data: string;
678
- readonly mime: string;
679
- readonly source: {
680
- readonly type: "inline";
681
- } | {
682
- readonly type: "uri";
683
- readonly uri: string;
684
- };
685
- readonly name?: string | undefined;
686
- readonly description?: string | undefined;
687
- readonly mention?: {
688
- readonly start: number;
689
- readonly end: number;
690
- readonly text: string;
691
- } | undefined;
692
- }[] | undefined;
693
- readonly agents?: readonly {
694
- readonly name: string;
695
- readonly mention?: {
696
- readonly start: number;
697
- readonly end: number;
698
- readonly text: string;
699
- } | undefined;
700
- }[] | undefined;
653
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
654
+ readonly name: Schema.String;
655
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
656
+ readonly start: Schema.Finite;
657
+ readonly end: Schema.Finite;
658
+ readonly text: Schema.String;
659
+ }>>>, Schema.optionalKey<Schema.Struct<{
660
+ readonly start: Schema.Finite;
661
+ readonly end: Schema.Finite;
662
+ readonly text: Schema.String;
663
+ }>>, never, never>;
664
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
665
+ readonly name: Schema.String;
666
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
667
+ readonly start: Schema.Finite;
668
+ readonly end: Schema.Finite;
669
+ readonly text: Schema.String;
670
+ }>>>, Schema.optionalKey<Schema.Struct<{
671
+ readonly start: Schema.Finite;
672
+ readonly end: Schema.Finite;
673
+ readonly text: Schema.String;
674
+ }>>, never, never>;
675
+ }>>>, never, never>;
701
676
  }>;
702
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
703
- readonly text: string;
704
- readonly files?: readonly {
705
- readonly data: string;
706
- readonly mime: string;
707
- readonly source: {
708
- readonly type: "inline";
709
- } | {
710
- readonly type: "uri";
711
- readonly uri: string;
712
- };
713
- readonly name?: string | undefined;
714
- readonly description?: string | undefined;
715
- readonly mention?: {
716
- readonly start: number;
717
- readonly end: number;
718
- readonly text: string;
719
- } | undefined;
720
- }[] | undefined;
721
- readonly agents?: readonly {
722
- readonly name: string;
723
- readonly mention?: {
724
- readonly start: number;
725
- readonly end: number;
726
- readonly text: string;
727
- } | undefined;
728
- }[] | undefined;
729
- };
730
- };
731
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
732
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
677
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
678
+ }>, Schema.Struct<{
679
+ readonly type: Schema.tag<"synthetic">;
680
+ readonly data: Schema.Struct<{
681
+ readonly text: Schema.String;
682
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
683
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
684
+ }>;
685
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
686
+ }>]>;
687
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
733
688
  create: () => string & import("effect/Brand").Brand<"SessionID">;
734
689
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
735
690
  };
736
691
  }>;
737
692
  }> & {
738
- type: "session.prompt.admitted";
693
+ type: "session.input.admitted";
739
694
  durability: "durable";
740
695
  durable: {
741
696
  readonly version: number;
742
697
  readonly aggregate: string;
743
698
  };
744
699
  data: Schema.Struct<{
745
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
700
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
746
701
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
747
702
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
748
703
  };
749
- prompt: Schema.Struct<{
750
- readonly text: Schema.String;
751
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
752
- readonly data: Schema.String;
753
- readonly mime: Schema.String;
754
- readonly source: Schema.Union<readonly [Schema.Struct<{
755
- readonly type: Schema.Literal<"inline">;
756
- }>, Schema.Struct<{
757
- readonly type: Schema.Literal<"uri">;
758
- readonly uri: Schema.String;
759
- }>]>;
760
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
761
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
762
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
763
- readonly start: Schema.Finite;
764
- readonly end: Schema.Finite;
765
- readonly text: Schema.String;
766
- }>>>, Schema.optionalKey<Schema.Struct<{
767
- readonly start: Schema.Finite;
768
- readonly end: Schema.Finite;
769
- readonly text: Schema.String;
770
- }>>, never, never>;
771
- }> & {
772
- create: (input: FileAttachment) => {
773
- readonly data: string;
774
- readonly mime: string;
775
- readonly source: {
776
- readonly type: "inline";
777
- } | {
778
- readonly type: "uri";
779
- readonly uri: string;
704
+ readonly input: Schema.Union<readonly [Schema.Struct<{
705
+ readonly type: Schema.tag<"user">;
706
+ readonly data: Schema.Struct<{
707
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
708
+ readonly text: Schema.String;
709
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
710
+ readonly data: Schema.String;
711
+ readonly mime: Schema.String;
712
+ readonly source: Schema.Union<readonly [Schema.Struct<{
713
+ readonly type: Schema.Literal<"inline">;
714
+ }>, Schema.Struct<{
715
+ readonly type: Schema.Literal<"uri">;
716
+ readonly uri: Schema.String;
717
+ }>]>;
718
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
719
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
720
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
721
+ readonly start: Schema.Finite;
722
+ readonly end: Schema.Finite;
723
+ readonly text: Schema.String;
724
+ }>>>, Schema.optionalKey<Schema.Struct<{
725
+ readonly start: Schema.Finite;
726
+ readonly end: Schema.Finite;
727
+ readonly text: Schema.String;
728
+ }>>, never, never>;
729
+ }> & {
730
+ create: (input: FileAttachment) => {
731
+ readonly data: string;
732
+ readonly mime: string;
733
+ readonly source: {
734
+ readonly type: "inline";
735
+ } | {
736
+ readonly type: "uri";
737
+ readonly uri: string;
738
+ };
739
+ readonly name?: string | undefined;
740
+ readonly description?: string | undefined;
741
+ readonly mention?: {
742
+ readonly start: number;
743
+ readonly end: number;
744
+ readonly text: string;
745
+ } | undefined;
780
746
  };
781
- readonly name?: string | undefined;
782
- readonly description?: string | undefined;
783
- readonly mention?: {
784
- readonly start: number;
785
- readonly end: number;
786
- readonly text: string;
787
- } | undefined;
788
- };
789
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
790
- readonly data: Schema.String;
791
- readonly mime: Schema.String;
792
- readonly source: Schema.Union<readonly [Schema.Struct<{
793
- readonly type: Schema.Literal<"inline">;
794
- }>, Schema.Struct<{
795
- readonly type: Schema.Literal<"uri">;
796
- readonly uri: Schema.String;
797
- }>]>;
798
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
799
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
800
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
801
- readonly start: Schema.Finite;
802
- readonly end: Schema.Finite;
803
- readonly text: Schema.String;
804
- }>>>, Schema.optionalKey<Schema.Struct<{
805
- readonly start: Schema.Finite;
806
- readonly end: Schema.Finite;
807
- readonly text: Schema.String;
808
- }>>, never, never>;
809
- }> & {
810
- create: (input: FileAttachment) => {
811
- readonly data: string;
812
- readonly mime: string;
813
- readonly source: {
814
- readonly type: "inline";
815
- } | {
816
- readonly type: "uri";
817
- readonly uri: string;
747
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
748
+ readonly data: Schema.String;
749
+ readonly mime: Schema.String;
750
+ readonly source: Schema.Union<readonly [Schema.Struct<{
751
+ readonly type: Schema.Literal<"inline">;
752
+ }>, Schema.Struct<{
753
+ readonly type: Schema.Literal<"uri">;
754
+ readonly uri: Schema.String;
755
+ }>]>;
756
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
757
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
758
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
759
+ readonly start: Schema.Finite;
760
+ readonly end: Schema.Finite;
761
+ readonly text: Schema.String;
762
+ }>>>, Schema.optionalKey<Schema.Struct<{
763
+ readonly start: Schema.Finite;
764
+ readonly end: Schema.Finite;
765
+ readonly text: Schema.String;
766
+ }>>, never, never>;
767
+ }> & {
768
+ create: (input: FileAttachment) => {
769
+ readonly data: string;
770
+ readonly mime: string;
771
+ readonly source: {
772
+ readonly type: "inline";
773
+ } | {
774
+ readonly type: "uri";
775
+ readonly uri: string;
776
+ };
777
+ readonly name?: string | undefined;
778
+ readonly description?: string | undefined;
779
+ readonly mention?: {
780
+ readonly start: number;
781
+ readonly end: number;
782
+ readonly text: string;
783
+ } | undefined;
818
784
  };
819
- readonly name?: string | undefined;
820
- readonly description?: string | undefined;
821
- readonly mention?: {
822
- readonly start: number;
823
- readonly end: number;
824
- readonly text: string;
825
- } | undefined;
826
- };
827
- }>>, never, never>;
828
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
829
- readonly name: Schema.String;
830
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
831
- readonly start: Schema.Finite;
832
- readonly end: Schema.Finite;
833
- readonly text: Schema.String;
834
- }>>>, Schema.optionalKey<Schema.Struct<{
835
- readonly start: Schema.Finite;
836
- readonly end: Schema.Finite;
837
- readonly text: Schema.String;
838
785
  }>>, never, never>;
839
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
840
- readonly name: Schema.String;
841
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
842
- readonly start: Schema.Finite;
843
- readonly end: Schema.Finite;
844
- readonly text: Schema.String;
845
- }>>>, Schema.optionalKey<Schema.Struct<{
846
- readonly start: Schema.Finite;
847
- readonly end: Schema.Finite;
848
- readonly text: Schema.String;
849
- }>>, never, never>;
850
- }>>>, never, never>;
851
- }> & {
852
- equivalence: import("effect/Equivalence").Equivalence<{
853
- readonly text: string;
854
- readonly files?: readonly {
855
- readonly data: string;
856
- readonly mime: string;
857
- readonly source: {
858
- readonly type: "inline";
859
- } | {
860
- readonly type: "uri";
861
- readonly uri: string;
862
- };
863
- readonly name?: string | undefined;
864
- readonly description?: string | undefined;
865
- readonly mention?: {
866
- readonly start: number;
867
- readonly end: number;
868
- readonly text: string;
869
- } | undefined;
870
- }[] | undefined;
871
- readonly agents?: readonly {
872
- readonly name: string;
873
- readonly mention?: {
874
- readonly start: number;
875
- readonly end: number;
876
- readonly text: string;
877
- } | undefined;
878
- }[] | undefined;
786
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
787
+ readonly name: Schema.String;
788
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
789
+ readonly start: Schema.Finite;
790
+ readonly end: Schema.Finite;
791
+ readonly text: Schema.String;
792
+ }>>>, Schema.optionalKey<Schema.Struct<{
793
+ readonly start: Schema.Finite;
794
+ readonly end: Schema.Finite;
795
+ readonly text: Schema.String;
796
+ }>>, never, never>;
797
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
798
+ readonly name: Schema.String;
799
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
800
+ readonly start: Schema.Finite;
801
+ readonly end: Schema.Finite;
802
+ readonly text: Schema.String;
803
+ }>>>, Schema.optionalKey<Schema.Struct<{
804
+ readonly start: Schema.Finite;
805
+ readonly end: Schema.Finite;
806
+ readonly text: Schema.String;
807
+ }>>, never, never>;
808
+ }>>>, never, never>;
879
809
  }>;
880
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
881
- readonly text: string;
882
- readonly files?: readonly {
883
- readonly data: string;
884
- readonly mime: string;
885
- readonly source: {
886
- readonly type: "inline";
887
- } | {
888
- readonly type: "uri";
889
- readonly uri: string;
890
- };
891
- readonly name?: string | undefined;
892
- readonly description?: string | undefined;
893
- readonly mention?: {
894
- readonly start: number;
895
- readonly end: number;
896
- readonly text: string;
897
- } | undefined;
898
- }[] | undefined;
899
- readonly agents?: readonly {
900
- readonly name: string;
901
- readonly mention?: {
902
- readonly start: number;
903
- readonly end: number;
904
- readonly text: string;
905
- } | undefined;
906
- }[] | undefined;
907
- };
908
- };
909
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
910
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
810
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
811
+ }>, Schema.Struct<{
812
+ readonly type: Schema.tag<"synthetic">;
813
+ readonly data: Schema.Struct<{
814
+ readonly text: Schema.String;
815
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
816
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
817
+ }>;
818
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
819
+ }>]>;
820
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
911
821
  create: () => string & import("effect/Brand").Brand<"SessionID">;
912
822
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
913
823
  };
914
824
  }>;
915
825
  };
916
- export type PromptAdmitted = typeof PromptAdmitted.Type;
826
+ export type InputAdmitted = typeof InputAdmitted.Type;
917
827
  export declare namespace Execution {
918
828
  const Started: Schema.Struct<{
919
829
  readonly id: Schema.brand<Schema.String, "Event.ID"> & {
@@ -3719,7 +3629,7 @@ export declare const Definitions: readonly [Schema.Struct<{
3719
3629
  };
3720
3630
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
3721
3631
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
3722
- readonly type: Schema.Literal<"session.prompt.promoted">;
3632
+ readonly type: Schema.Literal<"session.input.promoted">;
3723
3633
  readonly durable: Schema.Struct<{
3724
3634
  readonly aggregateID: Schema.String;
3725
3635
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -3755,7 +3665,7 @@ export declare const Definitions: readonly [Schema.Struct<{
3755
3665
  };
3756
3666
  }>;
3757
3667
  }> & {
3758
- type: "session.prompt.promoted";
3668
+ type: "session.input.promoted";
3759
3669
  durability: "durable";
3760
3670
  durable: {
3761
3671
  readonly version: number;
@@ -3777,7 +3687,7 @@ export declare const Definitions: readonly [Schema.Struct<{
3777
3687
  };
3778
3688
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
3779
3689
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
3780
- readonly type: Schema.Literal<"session.prompt.admitted">;
3690
+ readonly type: Schema.Literal<"session.input.admitted">;
3781
3691
  readonly durable: Schema.Struct<{
3782
3692
  readonly aggregateID: Schema.String;
3783
3693
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -3803,350 +3713,260 @@ export declare const Definitions: readonly [Schema.Struct<{
3803
3713
  }>, never, never>;
3804
3714
  }>>, never, never>;
3805
3715
  readonly data: Schema.Struct<{
3806
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
3716
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
3807
3717
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
3808
3718
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
3809
3719
  };
3810
- prompt: Schema.Struct<{
3811
- readonly text: Schema.String;
3812
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3813
- readonly data: Schema.String;
3814
- readonly mime: Schema.String;
3815
- readonly source: Schema.Union<readonly [Schema.Struct<{
3816
- readonly type: Schema.Literal<"inline">;
3817
- }>, Schema.Struct<{
3818
- readonly type: Schema.Literal<"uri">;
3819
- readonly uri: Schema.String;
3820
- }>]>;
3821
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3822
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3823
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3824
- readonly start: Schema.Finite;
3825
- readonly end: Schema.Finite;
3826
- readonly text: Schema.String;
3827
- }>>>, Schema.optionalKey<Schema.Struct<{
3828
- readonly start: Schema.Finite;
3829
- readonly end: Schema.Finite;
3830
- readonly text: Schema.String;
3831
- }>>, never, never>;
3832
- }> & {
3833
- create: (input: FileAttachment) => {
3834
- readonly data: string;
3835
- readonly mime: string;
3836
- readonly source: {
3837
- readonly type: "inline";
3838
- } | {
3839
- readonly type: "uri";
3840
- readonly uri: string;
3720
+ readonly input: Schema.Union<readonly [Schema.Struct<{
3721
+ readonly type: Schema.tag<"user">;
3722
+ readonly data: Schema.Struct<{
3723
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
3724
+ readonly text: Schema.String;
3725
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3726
+ readonly data: Schema.String;
3727
+ readonly mime: Schema.String;
3728
+ readonly source: Schema.Union<readonly [Schema.Struct<{
3729
+ readonly type: Schema.Literal<"inline">;
3730
+ }>, Schema.Struct<{
3731
+ readonly type: Schema.Literal<"uri">;
3732
+ readonly uri: Schema.String;
3733
+ }>]>;
3734
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3735
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3736
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3737
+ readonly start: Schema.Finite;
3738
+ readonly end: Schema.Finite;
3739
+ readonly text: Schema.String;
3740
+ }>>>, Schema.optionalKey<Schema.Struct<{
3741
+ readonly start: Schema.Finite;
3742
+ readonly end: Schema.Finite;
3743
+ readonly text: Schema.String;
3744
+ }>>, never, never>;
3745
+ }> & {
3746
+ create: (input: FileAttachment) => {
3747
+ readonly data: string;
3748
+ readonly mime: string;
3749
+ readonly source: {
3750
+ readonly type: "inline";
3751
+ } | {
3752
+ readonly type: "uri";
3753
+ readonly uri: string;
3754
+ };
3755
+ readonly name?: string | undefined;
3756
+ readonly description?: string | undefined;
3757
+ readonly mention?: {
3758
+ readonly start: number;
3759
+ readonly end: number;
3760
+ readonly text: string;
3761
+ } | undefined;
3841
3762
  };
3842
- readonly name?: string | undefined;
3843
- readonly description?: string | undefined;
3844
- readonly mention?: {
3845
- readonly start: number;
3846
- readonly end: number;
3847
- readonly text: string;
3848
- } | undefined;
3849
- };
3850
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
3851
- readonly data: Schema.String;
3852
- readonly mime: Schema.String;
3853
- readonly source: Schema.Union<readonly [Schema.Struct<{
3854
- readonly type: Schema.Literal<"inline">;
3855
- }>, Schema.Struct<{
3856
- readonly type: Schema.Literal<"uri">;
3857
- readonly uri: Schema.String;
3858
- }>]>;
3859
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3860
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3861
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3862
- readonly start: Schema.Finite;
3863
- readonly end: Schema.Finite;
3864
- readonly text: Schema.String;
3865
- }>>>, Schema.optionalKey<Schema.Struct<{
3866
- readonly start: Schema.Finite;
3867
- readonly end: Schema.Finite;
3868
- readonly text: Schema.String;
3869
- }>>, never, never>;
3870
- }> & {
3871
- create: (input: FileAttachment) => {
3872
- readonly data: string;
3873
- readonly mime: string;
3874
- readonly source: {
3875
- readonly type: "inline";
3876
- } | {
3877
- readonly type: "uri";
3878
- readonly uri: string;
3763
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
3764
+ readonly data: Schema.String;
3765
+ readonly mime: Schema.String;
3766
+ readonly source: Schema.Union<readonly [Schema.Struct<{
3767
+ readonly type: Schema.Literal<"inline">;
3768
+ }>, Schema.Struct<{
3769
+ readonly type: Schema.Literal<"uri">;
3770
+ readonly uri: Schema.String;
3771
+ }>]>;
3772
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3773
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3774
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3775
+ readonly start: Schema.Finite;
3776
+ readonly end: Schema.Finite;
3777
+ readonly text: Schema.String;
3778
+ }>>>, Schema.optionalKey<Schema.Struct<{
3779
+ readonly start: Schema.Finite;
3780
+ readonly end: Schema.Finite;
3781
+ readonly text: Schema.String;
3782
+ }>>, never, never>;
3783
+ }> & {
3784
+ create: (input: FileAttachment) => {
3785
+ readonly data: string;
3786
+ readonly mime: string;
3787
+ readonly source: {
3788
+ readonly type: "inline";
3789
+ } | {
3790
+ readonly type: "uri";
3791
+ readonly uri: string;
3792
+ };
3793
+ readonly name?: string | undefined;
3794
+ readonly description?: string | undefined;
3795
+ readonly mention?: {
3796
+ readonly start: number;
3797
+ readonly end: number;
3798
+ readonly text: string;
3799
+ } | undefined;
3879
3800
  };
3880
- readonly name?: string | undefined;
3881
- readonly description?: string | undefined;
3882
- readonly mention?: {
3883
- readonly start: number;
3884
- readonly end: number;
3885
- readonly text: string;
3886
- } | undefined;
3887
- };
3888
- }>>, never, never>;
3889
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3890
- readonly name: Schema.String;
3891
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3892
- readonly start: Schema.Finite;
3893
- readonly end: Schema.Finite;
3894
- readonly text: Schema.String;
3895
- }>>>, Schema.optionalKey<Schema.Struct<{
3896
- readonly start: Schema.Finite;
3897
- readonly end: Schema.Finite;
3898
- readonly text: Schema.String;
3899
- }>>, never, never>;
3900
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
3901
- readonly name: Schema.String;
3902
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3903
- readonly start: Schema.Finite;
3904
- readonly end: Schema.Finite;
3905
- readonly text: Schema.String;
3906
- }>>>, Schema.optionalKey<Schema.Struct<{
3907
- readonly start: Schema.Finite;
3908
- readonly end: Schema.Finite;
3909
- readonly text: Schema.String;
3910
3801
  }>>, never, never>;
3911
- }>>>, never, never>;
3912
- }> & {
3913
- equivalence: import("effect/Equivalence").Equivalence<{
3914
- readonly text: string;
3915
- readonly files?: readonly {
3916
- readonly data: string;
3917
- readonly mime: string;
3918
- readonly source: {
3919
- readonly type: "inline";
3920
- } | {
3921
- readonly type: "uri";
3922
- readonly uri: string;
3923
- };
3924
- readonly name?: string | undefined;
3925
- readonly description?: string | undefined;
3926
- readonly mention?: {
3927
- readonly start: number;
3928
- readonly end: number;
3929
- readonly text: string;
3930
- } | undefined;
3931
- }[] | undefined;
3932
- readonly agents?: readonly {
3933
- readonly name: string;
3934
- readonly mention?: {
3935
- readonly start: number;
3936
- readonly end: number;
3937
- readonly text: string;
3938
- } | undefined;
3939
- }[] | undefined;
3802
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3803
+ readonly name: Schema.String;
3804
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3805
+ readonly start: Schema.Finite;
3806
+ readonly end: Schema.Finite;
3807
+ readonly text: Schema.String;
3808
+ }>>>, Schema.optionalKey<Schema.Struct<{
3809
+ readonly start: Schema.Finite;
3810
+ readonly end: Schema.Finite;
3811
+ readonly text: Schema.String;
3812
+ }>>, never, never>;
3813
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
3814
+ readonly name: Schema.String;
3815
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3816
+ readonly start: Schema.Finite;
3817
+ readonly end: Schema.Finite;
3818
+ readonly text: Schema.String;
3819
+ }>>>, Schema.optionalKey<Schema.Struct<{
3820
+ readonly start: Schema.Finite;
3821
+ readonly end: Schema.Finite;
3822
+ readonly text: Schema.String;
3823
+ }>>, never, never>;
3824
+ }>>>, never, never>;
3940
3825
  }>;
3941
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
3942
- readonly text: string;
3943
- readonly files?: readonly {
3944
- readonly data: string;
3945
- readonly mime: string;
3946
- readonly source: {
3947
- readonly type: "inline";
3948
- } | {
3949
- readonly type: "uri";
3950
- readonly uri: string;
3951
- };
3952
- readonly name?: string | undefined;
3953
- readonly description?: string | undefined;
3954
- readonly mention?: {
3955
- readonly start: number;
3956
- readonly end: number;
3957
- readonly text: string;
3958
- } | undefined;
3959
- }[] | undefined;
3960
- readonly agents?: readonly {
3961
- readonly name: string;
3962
- readonly mention?: {
3963
- readonly start: number;
3964
- readonly end: number;
3965
- readonly text: string;
3966
- } | undefined;
3967
- }[] | undefined;
3968
- };
3969
- };
3970
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
3971
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
3826
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
3827
+ }>, Schema.Struct<{
3828
+ readonly type: Schema.tag<"synthetic">;
3829
+ readonly data: Schema.Struct<{
3830
+ readonly text: Schema.String;
3831
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3832
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
3833
+ }>;
3834
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
3835
+ }>]>;
3836
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
3972
3837
  create: () => string & import("effect/Brand").Brand<"SessionID">;
3973
3838
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
3974
3839
  };
3975
3840
  }>;
3976
3841
  }> & {
3977
- type: "session.prompt.admitted";
3842
+ type: "session.input.admitted";
3978
3843
  durability: "durable";
3979
3844
  durable: {
3980
3845
  readonly version: number;
3981
3846
  readonly aggregate: string;
3982
3847
  };
3983
3848
  data: Schema.Struct<{
3984
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
3849
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
3985
3850
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
3986
3851
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
3987
3852
  };
3988
- prompt: Schema.Struct<{
3989
- readonly text: Schema.String;
3990
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3991
- readonly data: Schema.String;
3992
- readonly mime: Schema.String;
3993
- readonly source: Schema.Union<readonly [Schema.Struct<{
3994
- readonly type: Schema.Literal<"inline">;
3995
- }>, Schema.Struct<{
3996
- readonly type: Schema.Literal<"uri">;
3997
- readonly uri: Schema.String;
3998
- }>]>;
3999
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
4000
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
4001
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4002
- readonly start: Schema.Finite;
4003
- readonly end: Schema.Finite;
4004
- readonly text: Schema.String;
4005
- }>>>, Schema.optionalKey<Schema.Struct<{
4006
- readonly start: Schema.Finite;
4007
- readonly end: Schema.Finite;
4008
- readonly text: Schema.String;
4009
- }>>, never, never>;
4010
- }> & {
4011
- create: (input: FileAttachment) => {
4012
- readonly data: string;
4013
- readonly mime: string;
4014
- readonly source: {
4015
- readonly type: "inline";
4016
- } | {
4017
- readonly type: "uri";
4018
- readonly uri: string;
3853
+ readonly input: Schema.Union<readonly [Schema.Struct<{
3854
+ readonly type: Schema.tag<"user">;
3855
+ readonly data: Schema.Struct<{
3856
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
3857
+ readonly text: Schema.String;
3858
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3859
+ readonly data: Schema.String;
3860
+ readonly mime: Schema.String;
3861
+ readonly source: Schema.Union<readonly [Schema.Struct<{
3862
+ readonly type: Schema.Literal<"inline">;
3863
+ }>, Schema.Struct<{
3864
+ readonly type: Schema.Literal<"uri">;
3865
+ readonly uri: Schema.String;
3866
+ }>]>;
3867
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3868
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3869
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3870
+ readonly start: Schema.Finite;
3871
+ readonly end: Schema.Finite;
3872
+ readonly text: Schema.String;
3873
+ }>>>, Schema.optionalKey<Schema.Struct<{
3874
+ readonly start: Schema.Finite;
3875
+ readonly end: Schema.Finite;
3876
+ readonly text: Schema.String;
3877
+ }>>, never, never>;
3878
+ }> & {
3879
+ create: (input: FileAttachment) => {
3880
+ readonly data: string;
3881
+ readonly mime: string;
3882
+ readonly source: {
3883
+ readonly type: "inline";
3884
+ } | {
3885
+ readonly type: "uri";
3886
+ readonly uri: string;
3887
+ };
3888
+ readonly name?: string | undefined;
3889
+ readonly description?: string | undefined;
3890
+ readonly mention?: {
3891
+ readonly start: number;
3892
+ readonly end: number;
3893
+ readonly text: string;
3894
+ } | undefined;
4019
3895
  };
4020
- readonly name?: string | undefined;
4021
- readonly description?: string | undefined;
4022
- readonly mention?: {
4023
- readonly start: number;
4024
- readonly end: number;
4025
- readonly text: string;
4026
- } | undefined;
4027
- };
4028
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
4029
- readonly data: Schema.String;
4030
- readonly mime: Schema.String;
4031
- readonly source: Schema.Union<readonly [Schema.Struct<{
4032
- readonly type: Schema.Literal<"inline">;
4033
- }>, Schema.Struct<{
4034
- readonly type: Schema.Literal<"uri">;
4035
- readonly uri: Schema.String;
4036
- }>]>;
4037
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
4038
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
4039
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4040
- readonly start: Schema.Finite;
4041
- readonly end: Schema.Finite;
4042
- readonly text: Schema.String;
4043
- }>>>, Schema.optionalKey<Schema.Struct<{
4044
- readonly start: Schema.Finite;
4045
- readonly end: Schema.Finite;
4046
- readonly text: Schema.String;
4047
- }>>, never, never>;
4048
- }> & {
4049
- create: (input: FileAttachment) => {
4050
- readonly data: string;
4051
- readonly mime: string;
4052
- readonly source: {
4053
- readonly type: "inline";
4054
- } | {
4055
- readonly type: "uri";
4056
- readonly uri: string;
3896
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
3897
+ readonly data: Schema.String;
3898
+ readonly mime: Schema.String;
3899
+ readonly source: Schema.Union<readonly [Schema.Struct<{
3900
+ readonly type: Schema.Literal<"inline">;
3901
+ }>, Schema.Struct<{
3902
+ readonly type: Schema.Literal<"uri">;
3903
+ readonly uri: Schema.String;
3904
+ }>]>;
3905
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3906
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3907
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3908
+ readonly start: Schema.Finite;
3909
+ readonly end: Schema.Finite;
3910
+ readonly text: Schema.String;
3911
+ }>>>, Schema.optionalKey<Schema.Struct<{
3912
+ readonly start: Schema.Finite;
3913
+ readonly end: Schema.Finite;
3914
+ readonly text: Schema.String;
3915
+ }>>, never, never>;
3916
+ }> & {
3917
+ create: (input: FileAttachment) => {
3918
+ readonly data: string;
3919
+ readonly mime: string;
3920
+ readonly source: {
3921
+ readonly type: "inline";
3922
+ } | {
3923
+ readonly type: "uri";
3924
+ readonly uri: string;
3925
+ };
3926
+ readonly name?: string | undefined;
3927
+ readonly description?: string | undefined;
3928
+ readonly mention?: {
3929
+ readonly start: number;
3930
+ readonly end: number;
3931
+ readonly text: string;
3932
+ } | undefined;
4057
3933
  };
4058
- readonly name?: string | undefined;
4059
- readonly description?: string | undefined;
4060
- readonly mention?: {
4061
- readonly start: number;
4062
- readonly end: number;
4063
- readonly text: string;
4064
- } | undefined;
4065
- };
4066
- }>>, never, never>;
4067
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
4068
- readonly name: Schema.String;
4069
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4070
- readonly start: Schema.Finite;
4071
- readonly end: Schema.Finite;
4072
- readonly text: Schema.String;
4073
- }>>>, Schema.optionalKey<Schema.Struct<{
4074
- readonly start: Schema.Finite;
4075
- readonly end: Schema.Finite;
4076
- readonly text: Schema.String;
4077
- }>>, never, never>;
4078
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
4079
- readonly name: Schema.String;
4080
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
4081
- readonly start: Schema.Finite;
4082
- readonly end: Schema.Finite;
4083
- readonly text: Schema.String;
4084
- }>>>, Schema.optionalKey<Schema.Struct<{
4085
- readonly start: Schema.Finite;
4086
- readonly end: Schema.Finite;
4087
- readonly text: Schema.String;
4088
3934
  }>>, never, never>;
4089
- }>>>, never, never>;
4090
- }> & {
4091
- equivalence: import("effect/Equivalence").Equivalence<{
4092
- readonly text: string;
4093
- readonly files?: readonly {
4094
- readonly data: string;
4095
- readonly mime: string;
4096
- readonly source: {
4097
- readonly type: "inline";
4098
- } | {
4099
- readonly type: "uri";
4100
- readonly uri: string;
4101
- };
4102
- readonly name?: string | undefined;
4103
- readonly description?: string | undefined;
4104
- readonly mention?: {
4105
- readonly start: number;
4106
- readonly end: number;
4107
- readonly text: string;
4108
- } | undefined;
4109
- }[] | undefined;
4110
- readonly agents?: readonly {
4111
- readonly name: string;
4112
- readonly mention?: {
4113
- readonly start: number;
4114
- readonly end: number;
4115
- readonly text: string;
4116
- } | undefined;
4117
- }[] | undefined;
3935
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
3936
+ readonly name: Schema.String;
3937
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3938
+ readonly start: Schema.Finite;
3939
+ readonly end: Schema.Finite;
3940
+ readonly text: Schema.String;
3941
+ }>>>, Schema.optionalKey<Schema.Struct<{
3942
+ readonly start: Schema.Finite;
3943
+ readonly end: Schema.Finite;
3944
+ readonly text: Schema.String;
3945
+ }>>, never, never>;
3946
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
3947
+ readonly name: Schema.String;
3948
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
3949
+ readonly start: Schema.Finite;
3950
+ readonly end: Schema.Finite;
3951
+ readonly text: Schema.String;
3952
+ }>>>, Schema.optionalKey<Schema.Struct<{
3953
+ readonly start: Schema.Finite;
3954
+ readonly end: Schema.Finite;
3955
+ readonly text: Schema.String;
3956
+ }>>, never, never>;
3957
+ }>>>, never, never>;
4118
3958
  }>;
4119
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
4120
- readonly text: string;
4121
- readonly files?: readonly {
4122
- readonly data: string;
4123
- readonly mime: string;
4124
- readonly source: {
4125
- readonly type: "inline";
4126
- } | {
4127
- readonly type: "uri";
4128
- readonly uri: string;
4129
- };
4130
- readonly name?: string | undefined;
4131
- readonly description?: string | undefined;
4132
- readonly mention?: {
4133
- readonly start: number;
4134
- readonly end: number;
4135
- readonly text: string;
4136
- } | undefined;
4137
- }[] | undefined;
4138
- readonly agents?: readonly {
4139
- readonly name: string;
4140
- readonly mention?: {
4141
- readonly start: number;
4142
- readonly end: number;
4143
- readonly text: string;
4144
- } | undefined;
4145
- }[] | undefined;
4146
- };
4147
- };
4148
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
4149
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
3959
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
3960
+ }>, Schema.Struct<{
3961
+ readonly type: Schema.tag<"synthetic">;
3962
+ readonly data: Schema.Struct<{
3963
+ readonly text: Schema.String;
3964
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
3965
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
3966
+ }>;
3967
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
3968
+ }>]>;
3969
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
4150
3970
  create: () => string & import("effect/Brand").Brand<"SessionID">;
4151
3971
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
4152
3972
  };
@@ -6802,7 +6622,7 @@ export declare const DurableDefinitions: readonly ((Schema.Struct<{
6802
6622
  };
6803
6623
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
6804
6624
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
6805
- readonly type: Schema.Literal<"session.prompt.promoted">;
6625
+ readonly type: Schema.Literal<"session.input.promoted">;
6806
6626
  readonly durable: Schema.Struct<{
6807
6627
  readonly aggregateID: Schema.String;
6808
6628
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -6838,7 +6658,7 @@ export declare const DurableDefinitions: readonly ((Schema.Struct<{
6838
6658
  };
6839
6659
  }>;
6840
6660
  }> & {
6841
- type: "session.prompt.promoted";
6661
+ type: "session.input.promoted";
6842
6662
  durability: "durable";
6843
6663
  durable: {
6844
6664
  readonly version: number;
@@ -6860,7 +6680,7 @@ export declare const DurableDefinitions: readonly ((Schema.Struct<{
6860
6680
  };
6861
6681
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
6862
6682
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
6863
- readonly type: Schema.Literal<"session.prompt.admitted">;
6683
+ readonly type: Schema.Literal<"session.input.admitted">;
6864
6684
  readonly durable: Schema.Struct<{
6865
6685
  readonly aggregateID: Schema.String;
6866
6686
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -6886,350 +6706,260 @@ export declare const DurableDefinitions: readonly ((Schema.Struct<{
6886
6706
  }>, never, never>;
6887
6707
  }>>, never, never>;
6888
6708
  readonly data: Schema.Struct<{
6889
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6709
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6890
6710
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
6891
6711
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
6892
6712
  };
6893
- prompt: Schema.Struct<{
6894
- readonly text: Schema.String;
6895
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6896
- readonly data: Schema.String;
6897
- readonly mime: Schema.String;
6898
- readonly source: Schema.Union<readonly [Schema.Struct<{
6899
- readonly type: Schema.Literal<"inline">;
6900
- }>, Schema.Struct<{
6901
- readonly type: Schema.Literal<"uri">;
6902
- readonly uri: Schema.String;
6903
- }>]>;
6904
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6905
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6906
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6907
- readonly start: Schema.Finite;
6908
- readonly end: Schema.Finite;
6909
- readonly text: Schema.String;
6910
- }>>>, Schema.optionalKey<Schema.Struct<{
6911
- readonly start: Schema.Finite;
6912
- readonly end: Schema.Finite;
6913
- readonly text: Schema.String;
6914
- }>>, never, never>;
6915
- }> & {
6916
- create: (input: FileAttachment) => {
6917
- readonly data: string;
6918
- readonly mime: string;
6919
- readonly source: {
6920
- readonly type: "inline";
6921
- } | {
6922
- readonly type: "uri";
6923
- readonly uri: string;
6713
+ readonly input: Schema.Union<readonly [Schema.Struct<{
6714
+ readonly type: Schema.tag<"user">;
6715
+ readonly data: Schema.Struct<{
6716
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
6717
+ readonly text: Schema.String;
6718
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6719
+ readonly data: Schema.String;
6720
+ readonly mime: Schema.String;
6721
+ readonly source: Schema.Union<readonly [Schema.Struct<{
6722
+ readonly type: Schema.Literal<"inline">;
6723
+ }>, Schema.Struct<{
6724
+ readonly type: Schema.Literal<"uri">;
6725
+ readonly uri: Schema.String;
6726
+ }>]>;
6727
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6728
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6729
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6730
+ readonly start: Schema.Finite;
6731
+ readonly end: Schema.Finite;
6732
+ readonly text: Schema.String;
6733
+ }>>>, Schema.optionalKey<Schema.Struct<{
6734
+ readonly start: Schema.Finite;
6735
+ readonly end: Schema.Finite;
6736
+ readonly text: Schema.String;
6737
+ }>>, never, never>;
6738
+ }> & {
6739
+ create: (input: FileAttachment) => {
6740
+ readonly data: string;
6741
+ readonly mime: string;
6742
+ readonly source: {
6743
+ readonly type: "inline";
6744
+ } | {
6745
+ readonly type: "uri";
6746
+ readonly uri: string;
6747
+ };
6748
+ readonly name?: string | undefined;
6749
+ readonly description?: string | undefined;
6750
+ readonly mention?: {
6751
+ readonly start: number;
6752
+ readonly end: number;
6753
+ readonly text: string;
6754
+ } | undefined;
6924
6755
  };
6925
- readonly name?: string | undefined;
6926
- readonly description?: string | undefined;
6927
- readonly mention?: {
6928
- readonly start: number;
6929
- readonly end: number;
6930
- readonly text: string;
6931
- } | undefined;
6932
- };
6933
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6934
- readonly data: Schema.String;
6935
- readonly mime: Schema.String;
6936
- readonly source: Schema.Union<readonly [Schema.Struct<{
6937
- readonly type: Schema.Literal<"inline">;
6938
- }>, Schema.Struct<{
6939
- readonly type: Schema.Literal<"uri">;
6940
- readonly uri: Schema.String;
6941
- }>]>;
6942
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6943
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6944
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6945
- readonly start: Schema.Finite;
6946
- readonly end: Schema.Finite;
6947
- readonly text: Schema.String;
6948
- }>>>, Schema.optionalKey<Schema.Struct<{
6949
- readonly start: Schema.Finite;
6950
- readonly end: Schema.Finite;
6951
- readonly text: Schema.String;
6952
- }>>, never, never>;
6953
- }> & {
6954
- create: (input: FileAttachment) => {
6955
- readonly data: string;
6956
- readonly mime: string;
6957
- readonly source: {
6958
- readonly type: "inline";
6959
- } | {
6960
- readonly type: "uri";
6961
- readonly uri: string;
6756
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6757
+ readonly data: Schema.String;
6758
+ readonly mime: Schema.String;
6759
+ readonly source: Schema.Union<readonly [Schema.Struct<{
6760
+ readonly type: Schema.Literal<"inline">;
6761
+ }>, Schema.Struct<{
6762
+ readonly type: Schema.Literal<"uri">;
6763
+ readonly uri: Schema.String;
6764
+ }>]>;
6765
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6766
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6767
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6768
+ readonly start: Schema.Finite;
6769
+ readonly end: Schema.Finite;
6770
+ readonly text: Schema.String;
6771
+ }>>>, Schema.optionalKey<Schema.Struct<{
6772
+ readonly start: Schema.Finite;
6773
+ readonly end: Schema.Finite;
6774
+ readonly text: Schema.String;
6775
+ }>>, never, never>;
6776
+ }> & {
6777
+ create: (input: FileAttachment) => {
6778
+ readonly data: string;
6779
+ readonly mime: string;
6780
+ readonly source: {
6781
+ readonly type: "inline";
6782
+ } | {
6783
+ readonly type: "uri";
6784
+ readonly uri: string;
6785
+ };
6786
+ readonly name?: string | undefined;
6787
+ readonly description?: string | undefined;
6788
+ readonly mention?: {
6789
+ readonly start: number;
6790
+ readonly end: number;
6791
+ readonly text: string;
6792
+ } | undefined;
6962
6793
  };
6963
- readonly name?: string | undefined;
6964
- readonly description?: string | undefined;
6965
- readonly mention?: {
6966
- readonly start: number;
6967
- readonly end: number;
6968
- readonly text: string;
6969
- } | undefined;
6970
- };
6971
- }>>, never, never>;
6972
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6973
- readonly name: Schema.String;
6974
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6975
- readonly start: Schema.Finite;
6976
- readonly end: Schema.Finite;
6977
- readonly text: Schema.String;
6978
- }>>>, Schema.optionalKey<Schema.Struct<{
6979
- readonly start: Schema.Finite;
6980
- readonly end: Schema.Finite;
6981
- readonly text: Schema.String;
6982
6794
  }>>, never, never>;
6983
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6984
- readonly name: Schema.String;
6985
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6986
- readonly start: Schema.Finite;
6987
- readonly end: Schema.Finite;
6988
- readonly text: Schema.String;
6989
- }>>>, Schema.optionalKey<Schema.Struct<{
6990
- readonly start: Schema.Finite;
6991
- readonly end: Schema.Finite;
6992
- readonly text: Schema.String;
6993
- }>>, never, never>;
6994
- }>>>, never, never>;
6995
- }> & {
6996
- equivalence: import("effect/Equivalence").Equivalence<{
6997
- readonly text: string;
6998
- readonly files?: readonly {
6999
- readonly data: string;
7000
- readonly mime: string;
7001
- readonly source: {
7002
- readonly type: "inline";
7003
- } | {
7004
- readonly type: "uri";
7005
- readonly uri: string;
7006
- };
7007
- readonly name?: string | undefined;
7008
- readonly description?: string | undefined;
7009
- readonly mention?: {
7010
- readonly start: number;
7011
- readonly end: number;
7012
- readonly text: string;
7013
- } | undefined;
7014
- }[] | undefined;
7015
- readonly agents?: readonly {
7016
- readonly name: string;
7017
- readonly mention?: {
7018
- readonly start: number;
7019
- readonly end: number;
7020
- readonly text: string;
7021
- } | undefined;
7022
- }[] | undefined;
6795
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6796
+ readonly name: Schema.String;
6797
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6798
+ readonly start: Schema.Finite;
6799
+ readonly end: Schema.Finite;
6800
+ readonly text: Schema.String;
6801
+ }>>>, Schema.optionalKey<Schema.Struct<{
6802
+ readonly start: Schema.Finite;
6803
+ readonly end: Schema.Finite;
6804
+ readonly text: Schema.String;
6805
+ }>>, never, never>;
6806
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6807
+ readonly name: Schema.String;
6808
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6809
+ readonly start: Schema.Finite;
6810
+ readonly end: Schema.Finite;
6811
+ readonly text: Schema.String;
6812
+ }>>>, Schema.optionalKey<Schema.Struct<{
6813
+ readonly start: Schema.Finite;
6814
+ readonly end: Schema.Finite;
6815
+ readonly text: Schema.String;
6816
+ }>>, never, never>;
6817
+ }>>>, never, never>;
7023
6818
  }>;
7024
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
7025
- readonly text: string;
7026
- readonly files?: readonly {
7027
- readonly data: string;
7028
- readonly mime: string;
7029
- readonly source: {
7030
- readonly type: "inline";
7031
- } | {
7032
- readonly type: "uri";
7033
- readonly uri: string;
7034
- };
7035
- readonly name?: string | undefined;
7036
- readonly description?: string | undefined;
7037
- readonly mention?: {
7038
- readonly start: number;
7039
- readonly end: number;
7040
- readonly text: string;
7041
- } | undefined;
7042
- }[] | undefined;
7043
- readonly agents?: readonly {
7044
- readonly name: string;
7045
- readonly mention?: {
7046
- readonly start: number;
7047
- readonly end: number;
7048
- readonly text: string;
7049
- } | undefined;
7050
- }[] | undefined;
7051
- };
7052
- };
7053
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
7054
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
6819
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
6820
+ }>, Schema.Struct<{
6821
+ readonly type: Schema.tag<"synthetic">;
6822
+ readonly data: Schema.Struct<{
6823
+ readonly text: Schema.String;
6824
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6825
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
6826
+ }>;
6827
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
6828
+ }>]>;
6829
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
7055
6830
  create: () => string & import("effect/Brand").Brand<"SessionID">;
7056
6831
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
7057
6832
  };
7058
6833
  }>;
7059
6834
  }> & {
7060
- type: "session.prompt.admitted";
6835
+ type: "session.input.admitted";
7061
6836
  durability: "durable";
7062
6837
  durable: {
7063
6838
  readonly version: number;
7064
6839
  readonly aggregate: string;
7065
6840
  };
7066
6841
  data: Schema.Struct<{
7067
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
6842
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
7068
6843
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
7069
6844
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
7070
6845
  };
7071
- prompt: Schema.Struct<{
7072
- readonly text: Schema.String;
7073
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
7074
- readonly data: Schema.String;
7075
- readonly mime: Schema.String;
7076
- readonly source: Schema.Union<readonly [Schema.Struct<{
7077
- readonly type: Schema.Literal<"inline">;
7078
- }>, Schema.Struct<{
7079
- readonly type: Schema.Literal<"uri">;
7080
- readonly uri: Schema.String;
7081
- }>]>;
7082
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
7083
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
7084
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
7085
- readonly start: Schema.Finite;
7086
- readonly end: Schema.Finite;
7087
- readonly text: Schema.String;
7088
- }>>>, Schema.optionalKey<Schema.Struct<{
7089
- readonly start: Schema.Finite;
7090
- readonly end: Schema.Finite;
7091
- readonly text: Schema.String;
7092
- }>>, never, never>;
7093
- }> & {
7094
- create: (input: FileAttachment) => {
7095
- readonly data: string;
7096
- readonly mime: string;
7097
- readonly source: {
7098
- readonly type: "inline";
7099
- } | {
7100
- readonly type: "uri";
7101
- readonly uri: string;
6846
+ readonly input: Schema.Union<readonly [Schema.Struct<{
6847
+ readonly type: Schema.tag<"user">;
6848
+ readonly data: Schema.Struct<{
6849
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
6850
+ readonly text: Schema.String;
6851
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6852
+ readonly data: Schema.String;
6853
+ readonly mime: Schema.String;
6854
+ readonly source: Schema.Union<readonly [Schema.Struct<{
6855
+ readonly type: Schema.Literal<"inline">;
6856
+ }>, Schema.Struct<{
6857
+ readonly type: Schema.Literal<"uri">;
6858
+ readonly uri: Schema.String;
6859
+ }>]>;
6860
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6861
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6862
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6863
+ readonly start: Schema.Finite;
6864
+ readonly end: Schema.Finite;
6865
+ readonly text: Schema.String;
6866
+ }>>>, Schema.optionalKey<Schema.Struct<{
6867
+ readonly start: Schema.Finite;
6868
+ readonly end: Schema.Finite;
6869
+ readonly text: Schema.String;
6870
+ }>>, never, never>;
6871
+ }> & {
6872
+ create: (input: FileAttachment) => {
6873
+ readonly data: string;
6874
+ readonly mime: string;
6875
+ readonly source: {
6876
+ readonly type: "inline";
6877
+ } | {
6878
+ readonly type: "uri";
6879
+ readonly uri: string;
6880
+ };
6881
+ readonly name?: string | undefined;
6882
+ readonly description?: string | undefined;
6883
+ readonly mention?: {
6884
+ readonly start: number;
6885
+ readonly end: number;
6886
+ readonly text: string;
6887
+ } | undefined;
7102
6888
  };
7103
- readonly name?: string | undefined;
7104
- readonly description?: string | undefined;
7105
- readonly mention?: {
7106
- readonly start: number;
7107
- readonly end: number;
7108
- readonly text: string;
7109
- } | undefined;
7110
- };
7111
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
7112
- readonly data: Schema.String;
7113
- readonly mime: Schema.String;
7114
- readonly source: Schema.Union<readonly [Schema.Struct<{
7115
- readonly type: Schema.Literal<"inline">;
7116
- }>, Schema.Struct<{
7117
- readonly type: Schema.Literal<"uri">;
7118
- readonly uri: Schema.String;
7119
- }>]>;
7120
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
7121
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
7122
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
7123
- readonly start: Schema.Finite;
7124
- readonly end: Schema.Finite;
7125
- readonly text: Schema.String;
7126
- }>>>, Schema.optionalKey<Schema.Struct<{
7127
- readonly start: Schema.Finite;
7128
- readonly end: Schema.Finite;
7129
- readonly text: Schema.String;
7130
- }>>, never, never>;
7131
- }> & {
7132
- create: (input: FileAttachment) => {
7133
- readonly data: string;
7134
- readonly mime: string;
7135
- readonly source: {
7136
- readonly type: "inline";
7137
- } | {
7138
- readonly type: "uri";
7139
- readonly uri: string;
6889
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6890
+ readonly data: Schema.String;
6891
+ readonly mime: Schema.String;
6892
+ readonly source: Schema.Union<readonly [Schema.Struct<{
6893
+ readonly type: Schema.Literal<"inline">;
6894
+ }>, Schema.Struct<{
6895
+ readonly type: Schema.Literal<"uri">;
6896
+ readonly uri: Schema.String;
6897
+ }>]>;
6898
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6899
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6900
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6901
+ readonly start: Schema.Finite;
6902
+ readonly end: Schema.Finite;
6903
+ readonly text: Schema.String;
6904
+ }>>>, Schema.optionalKey<Schema.Struct<{
6905
+ readonly start: Schema.Finite;
6906
+ readonly end: Schema.Finite;
6907
+ readonly text: Schema.String;
6908
+ }>>, never, never>;
6909
+ }> & {
6910
+ create: (input: FileAttachment) => {
6911
+ readonly data: string;
6912
+ readonly mime: string;
6913
+ readonly source: {
6914
+ readonly type: "inline";
6915
+ } | {
6916
+ readonly type: "uri";
6917
+ readonly uri: string;
6918
+ };
6919
+ readonly name?: string | undefined;
6920
+ readonly description?: string | undefined;
6921
+ readonly mention?: {
6922
+ readonly start: number;
6923
+ readonly end: number;
6924
+ readonly text: string;
6925
+ } | undefined;
7140
6926
  };
7141
- readonly name?: string | undefined;
7142
- readonly description?: string | undefined;
7143
- readonly mention?: {
7144
- readonly start: number;
7145
- readonly end: number;
7146
- readonly text: string;
7147
- } | undefined;
7148
- };
7149
- }>>, never, never>;
7150
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
7151
- readonly name: Schema.String;
7152
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
7153
- readonly start: Schema.Finite;
7154
- readonly end: Schema.Finite;
7155
- readonly text: Schema.String;
7156
- }>>>, Schema.optionalKey<Schema.Struct<{
7157
- readonly start: Schema.Finite;
7158
- readonly end: Schema.Finite;
7159
- readonly text: Schema.String;
7160
6927
  }>>, never, never>;
7161
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
7162
- readonly name: Schema.String;
7163
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
7164
- readonly start: Schema.Finite;
7165
- readonly end: Schema.Finite;
7166
- readonly text: Schema.String;
7167
- }>>>, Schema.optionalKey<Schema.Struct<{
7168
- readonly start: Schema.Finite;
7169
- readonly end: Schema.Finite;
7170
- readonly text: Schema.String;
7171
- }>>, never, never>;
7172
- }>>>, never, never>;
7173
- }> & {
7174
- equivalence: import("effect/Equivalence").Equivalence<{
7175
- readonly text: string;
7176
- readonly files?: readonly {
7177
- readonly data: string;
7178
- readonly mime: string;
7179
- readonly source: {
7180
- readonly type: "inline";
7181
- } | {
7182
- readonly type: "uri";
7183
- readonly uri: string;
7184
- };
7185
- readonly name?: string | undefined;
7186
- readonly description?: string | undefined;
7187
- readonly mention?: {
7188
- readonly start: number;
7189
- readonly end: number;
7190
- readonly text: string;
7191
- } | undefined;
7192
- }[] | undefined;
7193
- readonly agents?: readonly {
7194
- readonly name: string;
7195
- readonly mention?: {
7196
- readonly start: number;
7197
- readonly end: number;
7198
- readonly text: string;
7199
- } | undefined;
7200
- }[] | undefined;
6928
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
6929
+ readonly name: Schema.String;
6930
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6931
+ readonly start: Schema.Finite;
6932
+ readonly end: Schema.Finite;
6933
+ readonly text: Schema.String;
6934
+ }>>>, Schema.optionalKey<Schema.Struct<{
6935
+ readonly start: Schema.Finite;
6936
+ readonly end: Schema.Finite;
6937
+ readonly text: Schema.String;
6938
+ }>>, never, never>;
6939
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
6940
+ readonly name: Schema.String;
6941
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
6942
+ readonly start: Schema.Finite;
6943
+ readonly end: Schema.Finite;
6944
+ readonly text: Schema.String;
6945
+ }>>>, Schema.optionalKey<Schema.Struct<{
6946
+ readonly start: Schema.Finite;
6947
+ readonly end: Schema.Finite;
6948
+ readonly text: Schema.String;
6949
+ }>>, never, never>;
6950
+ }>>>, never, never>;
7201
6951
  }>;
7202
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
7203
- readonly text: string;
7204
- readonly files?: readonly {
7205
- readonly data: string;
7206
- readonly mime: string;
7207
- readonly source: {
7208
- readonly type: "inline";
7209
- } | {
7210
- readonly type: "uri";
7211
- readonly uri: string;
7212
- };
7213
- readonly name?: string | undefined;
7214
- readonly description?: string | undefined;
7215
- readonly mention?: {
7216
- readonly start: number;
7217
- readonly end: number;
7218
- readonly text: string;
7219
- } | undefined;
7220
- }[] | undefined;
7221
- readonly agents?: readonly {
7222
- readonly name: string;
7223
- readonly mention?: {
7224
- readonly start: number;
7225
- readonly end: number;
7226
- readonly text: string;
7227
- } | undefined;
7228
- }[] | undefined;
7229
- };
7230
- };
7231
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
7232
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
6952
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
6953
+ }>, Schema.Struct<{
6954
+ readonly type: Schema.tag<"synthetic">;
6955
+ readonly data: Schema.Struct<{
6956
+ readonly text: Schema.String;
6957
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
6958
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
6959
+ }>;
6960
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
6961
+ }>]>;
6962
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
7233
6963
  create: () => string & import("effect/Brand").Brand<"SessionID">;
7234
6964
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
7235
6965
  };
@@ -9679,7 +9409,7 @@ export declare const Durable: Schema.Union<readonly ((Schema.Struct<{
9679
9409
  };
9680
9410
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9681
9411
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9682
- readonly type: Schema.Literal<"session.prompt.promoted">;
9412
+ readonly type: Schema.Literal<"session.input.promoted">;
9683
9413
  readonly durable: Schema.Struct<{
9684
9414
  readonly aggregateID: Schema.String;
9685
9415
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -9715,7 +9445,7 @@ export declare const Durable: Schema.Union<readonly ((Schema.Struct<{
9715
9445
  };
9716
9446
  }>;
9717
9447
  }> & {
9718
- type: "session.prompt.promoted";
9448
+ type: "session.input.promoted";
9719
9449
  durability: "durable";
9720
9450
  durable: {
9721
9451
  readonly version: number;
@@ -9737,7 +9467,7 @@ export declare const Durable: Schema.Union<readonly ((Schema.Struct<{
9737
9467
  };
9738
9468
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
9739
9469
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9740
- readonly type: Schema.Literal<"session.prompt.admitted">;
9470
+ readonly type: Schema.Literal<"session.input.admitted">;
9741
9471
  readonly durable: Schema.Struct<{
9742
9472
  readonly aggregateID: Schema.String;
9743
9473
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -9763,350 +9493,260 @@ export declare const Durable: Schema.Union<readonly ((Schema.Struct<{
9763
9493
  }>, never, never>;
9764
9494
  }>>, never, never>;
9765
9495
  readonly data: Schema.Struct<{
9766
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
9496
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
9767
9497
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
9768
9498
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
9769
9499
  };
9770
- prompt: Schema.Struct<{
9771
- readonly text: Schema.String;
9772
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9773
- readonly data: Schema.String;
9774
- readonly mime: Schema.String;
9775
- readonly source: Schema.Union<readonly [Schema.Struct<{
9776
- readonly type: Schema.Literal<"inline">;
9777
- }>, Schema.Struct<{
9778
- readonly type: Schema.Literal<"uri">;
9779
- readonly uri: Schema.String;
9780
- }>]>;
9781
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9782
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9783
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9784
- readonly start: Schema.Finite;
9785
- readonly end: Schema.Finite;
9786
- readonly text: Schema.String;
9787
- }>>>, Schema.optionalKey<Schema.Struct<{
9788
- readonly start: Schema.Finite;
9789
- readonly end: Schema.Finite;
9790
- readonly text: Schema.String;
9791
- }>>, never, never>;
9792
- }> & {
9793
- create: (input: FileAttachment) => {
9794
- readonly data: string;
9795
- readonly mime: string;
9796
- readonly source: {
9797
- readonly type: "inline";
9798
- } | {
9799
- readonly type: "uri";
9800
- readonly uri: string;
9500
+ readonly input: Schema.Union<readonly [Schema.Struct<{
9501
+ readonly type: Schema.tag<"user">;
9502
+ readonly data: Schema.Struct<{
9503
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9504
+ readonly text: Schema.String;
9505
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9506
+ readonly data: Schema.String;
9507
+ readonly mime: Schema.String;
9508
+ readonly source: Schema.Union<readonly [Schema.Struct<{
9509
+ readonly type: Schema.Literal<"inline">;
9510
+ }>, Schema.Struct<{
9511
+ readonly type: Schema.Literal<"uri">;
9512
+ readonly uri: Schema.String;
9513
+ }>]>;
9514
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9515
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9516
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9517
+ readonly start: Schema.Finite;
9518
+ readonly end: Schema.Finite;
9519
+ readonly text: Schema.String;
9520
+ }>>>, Schema.optionalKey<Schema.Struct<{
9521
+ readonly start: Schema.Finite;
9522
+ readonly end: Schema.Finite;
9523
+ readonly text: Schema.String;
9524
+ }>>, never, never>;
9525
+ }> & {
9526
+ create: (input: FileAttachment) => {
9527
+ readonly data: string;
9528
+ readonly mime: string;
9529
+ readonly source: {
9530
+ readonly type: "inline";
9531
+ } | {
9532
+ readonly type: "uri";
9533
+ readonly uri: string;
9534
+ };
9535
+ readonly name?: string | undefined;
9536
+ readonly description?: string | undefined;
9537
+ readonly mention?: {
9538
+ readonly start: number;
9539
+ readonly end: number;
9540
+ readonly text: string;
9541
+ } | undefined;
9801
9542
  };
9802
- readonly name?: string | undefined;
9803
- readonly description?: string | undefined;
9804
- readonly mention?: {
9805
- readonly start: number;
9806
- readonly end: number;
9807
- readonly text: string;
9808
- } | undefined;
9809
- };
9810
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9811
- readonly data: Schema.String;
9812
- readonly mime: Schema.String;
9813
- readonly source: Schema.Union<readonly [Schema.Struct<{
9814
- readonly type: Schema.Literal<"inline">;
9815
- }>, Schema.Struct<{
9816
- readonly type: Schema.Literal<"uri">;
9817
- readonly uri: Schema.String;
9818
- }>]>;
9819
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9820
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9821
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9822
- readonly start: Schema.Finite;
9823
- readonly end: Schema.Finite;
9824
- readonly text: Schema.String;
9825
- }>>>, Schema.optionalKey<Schema.Struct<{
9826
- readonly start: Schema.Finite;
9827
- readonly end: Schema.Finite;
9828
- readonly text: Schema.String;
9829
- }>>, never, never>;
9830
- }> & {
9831
- create: (input: FileAttachment) => {
9832
- readonly data: string;
9833
- readonly mime: string;
9834
- readonly source: {
9835
- readonly type: "inline";
9836
- } | {
9837
- readonly type: "uri";
9838
- readonly uri: string;
9543
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9544
+ readonly data: Schema.String;
9545
+ readonly mime: Schema.String;
9546
+ readonly source: Schema.Union<readonly [Schema.Struct<{
9547
+ readonly type: Schema.Literal<"inline">;
9548
+ }>, Schema.Struct<{
9549
+ readonly type: Schema.Literal<"uri">;
9550
+ readonly uri: Schema.String;
9551
+ }>]>;
9552
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9553
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9554
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9555
+ readonly start: Schema.Finite;
9556
+ readonly end: Schema.Finite;
9557
+ readonly text: Schema.String;
9558
+ }>>>, Schema.optionalKey<Schema.Struct<{
9559
+ readonly start: Schema.Finite;
9560
+ readonly end: Schema.Finite;
9561
+ readonly text: Schema.String;
9562
+ }>>, never, never>;
9563
+ }> & {
9564
+ create: (input: FileAttachment) => {
9565
+ readonly data: string;
9566
+ readonly mime: string;
9567
+ readonly source: {
9568
+ readonly type: "inline";
9569
+ } | {
9570
+ readonly type: "uri";
9571
+ readonly uri: string;
9572
+ };
9573
+ readonly name?: string | undefined;
9574
+ readonly description?: string | undefined;
9575
+ readonly mention?: {
9576
+ readonly start: number;
9577
+ readonly end: number;
9578
+ readonly text: string;
9579
+ } | undefined;
9839
9580
  };
9840
- readonly name?: string | undefined;
9841
- readonly description?: string | undefined;
9842
- readonly mention?: {
9843
- readonly start: number;
9844
- readonly end: number;
9845
- readonly text: string;
9846
- } | undefined;
9847
- };
9848
- }>>, never, never>;
9849
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9850
- readonly name: Schema.String;
9851
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9852
- readonly start: Schema.Finite;
9853
- readonly end: Schema.Finite;
9854
- readonly text: Schema.String;
9855
- }>>>, Schema.optionalKey<Schema.Struct<{
9856
- readonly start: Schema.Finite;
9857
- readonly end: Schema.Finite;
9858
- readonly text: Schema.String;
9859
9581
  }>>, never, never>;
9860
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9861
- readonly name: Schema.String;
9862
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9863
- readonly start: Schema.Finite;
9864
- readonly end: Schema.Finite;
9865
- readonly text: Schema.String;
9866
- }>>>, Schema.optionalKey<Schema.Struct<{
9867
- readonly start: Schema.Finite;
9868
- readonly end: Schema.Finite;
9869
- readonly text: Schema.String;
9870
- }>>, never, never>;
9871
- }>>>, never, never>;
9872
- }> & {
9873
- equivalence: import("effect/Equivalence").Equivalence<{
9874
- readonly text: string;
9875
- readonly files?: readonly {
9876
- readonly data: string;
9877
- readonly mime: string;
9878
- readonly source: {
9879
- readonly type: "inline";
9880
- } | {
9881
- readonly type: "uri";
9882
- readonly uri: string;
9883
- };
9884
- readonly name?: string | undefined;
9885
- readonly description?: string | undefined;
9886
- readonly mention?: {
9887
- readonly start: number;
9888
- readonly end: number;
9889
- readonly text: string;
9890
- } | undefined;
9891
- }[] | undefined;
9892
- readonly agents?: readonly {
9893
- readonly name: string;
9894
- readonly mention?: {
9895
- readonly start: number;
9896
- readonly end: number;
9897
- readonly text: string;
9898
- } | undefined;
9899
- }[] | undefined;
9582
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9583
+ readonly name: Schema.String;
9584
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9585
+ readonly start: Schema.Finite;
9586
+ readonly end: Schema.Finite;
9587
+ readonly text: Schema.String;
9588
+ }>>>, Schema.optionalKey<Schema.Struct<{
9589
+ readonly start: Schema.Finite;
9590
+ readonly end: Schema.Finite;
9591
+ readonly text: Schema.String;
9592
+ }>>, never, never>;
9593
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9594
+ readonly name: Schema.String;
9595
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9596
+ readonly start: Schema.Finite;
9597
+ readonly end: Schema.Finite;
9598
+ readonly text: Schema.String;
9599
+ }>>>, Schema.optionalKey<Schema.Struct<{
9600
+ readonly start: Schema.Finite;
9601
+ readonly end: Schema.Finite;
9602
+ readonly text: Schema.String;
9603
+ }>>, never, never>;
9604
+ }>>>, never, never>;
9900
9605
  }>;
9901
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
9902
- readonly text: string;
9903
- readonly files?: readonly {
9904
- readonly data: string;
9905
- readonly mime: string;
9906
- readonly source: {
9907
- readonly type: "inline";
9908
- } | {
9909
- readonly type: "uri";
9910
- readonly uri: string;
9911
- };
9912
- readonly name?: string | undefined;
9913
- readonly description?: string | undefined;
9914
- readonly mention?: {
9915
- readonly start: number;
9916
- readonly end: number;
9917
- readonly text: string;
9918
- } | undefined;
9919
- }[] | undefined;
9920
- readonly agents?: readonly {
9921
- readonly name: string;
9922
- readonly mention?: {
9923
- readonly start: number;
9924
- readonly end: number;
9925
- readonly text: string;
9926
- } | undefined;
9927
- }[] | undefined;
9928
- };
9929
- };
9930
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
9931
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
9606
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
9607
+ }>, Schema.Struct<{
9608
+ readonly type: Schema.tag<"synthetic">;
9609
+ readonly data: Schema.Struct<{
9610
+ readonly text: Schema.String;
9611
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9612
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9613
+ }>;
9614
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
9615
+ }>]>;
9616
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
9932
9617
  create: () => string & import("effect/Brand").Brand<"SessionID">;
9933
9618
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
9934
9619
  };
9935
9620
  }>;
9936
9621
  }> & {
9937
- type: "session.prompt.admitted";
9622
+ type: "session.input.admitted";
9938
9623
  durability: "durable";
9939
9624
  durable: {
9940
9625
  readonly version: number;
9941
9626
  readonly aggregate: string;
9942
9627
  };
9943
9628
  data: Schema.Struct<{
9944
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
9629
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
9945
9630
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
9946
9631
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
9947
9632
  };
9948
- prompt: Schema.Struct<{
9949
- readonly text: Schema.String;
9950
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9951
- readonly data: Schema.String;
9952
- readonly mime: Schema.String;
9953
- readonly source: Schema.Union<readonly [Schema.Struct<{
9954
- readonly type: Schema.Literal<"inline">;
9955
- }>, Schema.Struct<{
9956
- readonly type: Schema.Literal<"uri">;
9957
- readonly uri: Schema.String;
9958
- }>]>;
9959
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9960
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9961
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9962
- readonly start: Schema.Finite;
9963
- readonly end: Schema.Finite;
9964
- readonly text: Schema.String;
9965
- }>>>, Schema.optionalKey<Schema.Struct<{
9966
- readonly start: Schema.Finite;
9967
- readonly end: Schema.Finite;
9968
- readonly text: Schema.String;
9969
- }>>, never, never>;
9970
- }> & {
9971
- create: (input: FileAttachment) => {
9972
- readonly data: string;
9973
- readonly mime: string;
9974
- readonly source: {
9975
- readonly type: "inline";
9976
- } | {
9977
- readonly type: "uri";
9978
- readonly uri: string;
9633
+ readonly input: Schema.Union<readonly [Schema.Struct<{
9634
+ readonly type: Schema.tag<"user">;
9635
+ readonly data: Schema.Struct<{
9636
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9637
+ readonly text: Schema.String;
9638
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9639
+ readonly data: Schema.String;
9640
+ readonly mime: Schema.String;
9641
+ readonly source: Schema.Union<readonly [Schema.Struct<{
9642
+ readonly type: Schema.Literal<"inline">;
9643
+ }>, Schema.Struct<{
9644
+ readonly type: Schema.Literal<"uri">;
9645
+ readonly uri: Schema.String;
9646
+ }>]>;
9647
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9648
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9649
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9650
+ readonly start: Schema.Finite;
9651
+ readonly end: Schema.Finite;
9652
+ readonly text: Schema.String;
9653
+ }>>>, Schema.optionalKey<Schema.Struct<{
9654
+ readonly start: Schema.Finite;
9655
+ readonly end: Schema.Finite;
9656
+ readonly text: Schema.String;
9657
+ }>>, never, never>;
9658
+ }> & {
9659
+ create: (input: FileAttachment) => {
9660
+ readonly data: string;
9661
+ readonly mime: string;
9662
+ readonly source: {
9663
+ readonly type: "inline";
9664
+ } | {
9665
+ readonly type: "uri";
9666
+ readonly uri: string;
9667
+ };
9668
+ readonly name?: string | undefined;
9669
+ readonly description?: string | undefined;
9670
+ readonly mention?: {
9671
+ readonly start: number;
9672
+ readonly end: number;
9673
+ readonly text: string;
9674
+ } | undefined;
9979
9675
  };
9980
- readonly name?: string | undefined;
9981
- readonly description?: string | undefined;
9982
- readonly mention?: {
9983
- readonly start: number;
9984
- readonly end: number;
9985
- readonly text: string;
9986
- } | undefined;
9987
- };
9988
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9989
- readonly data: Schema.String;
9990
- readonly mime: Schema.String;
9991
- readonly source: Schema.Union<readonly [Schema.Struct<{
9992
- readonly type: Schema.Literal<"inline">;
9993
- }>, Schema.Struct<{
9994
- readonly type: Schema.Literal<"uri">;
9995
- readonly uri: Schema.String;
9996
- }>]>;
9997
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9998
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9999
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
10000
- readonly start: Schema.Finite;
10001
- readonly end: Schema.Finite;
10002
- readonly text: Schema.String;
10003
- }>>>, Schema.optionalKey<Schema.Struct<{
10004
- readonly start: Schema.Finite;
10005
- readonly end: Schema.Finite;
10006
- readonly text: Schema.String;
10007
- }>>, never, never>;
10008
- }> & {
10009
- create: (input: FileAttachment) => {
10010
- readonly data: string;
10011
- readonly mime: string;
10012
- readonly source: {
10013
- readonly type: "inline";
10014
- } | {
10015
- readonly type: "uri";
10016
- readonly uri: string;
9676
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9677
+ readonly data: Schema.String;
9678
+ readonly mime: Schema.String;
9679
+ readonly source: Schema.Union<readonly [Schema.Struct<{
9680
+ readonly type: Schema.Literal<"inline">;
9681
+ }>, Schema.Struct<{
9682
+ readonly type: Schema.Literal<"uri">;
9683
+ readonly uri: Schema.String;
9684
+ }>]>;
9685
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9686
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9687
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9688
+ readonly start: Schema.Finite;
9689
+ readonly end: Schema.Finite;
9690
+ readonly text: Schema.String;
9691
+ }>>>, Schema.optionalKey<Schema.Struct<{
9692
+ readonly start: Schema.Finite;
9693
+ readonly end: Schema.Finite;
9694
+ readonly text: Schema.String;
9695
+ }>>, never, never>;
9696
+ }> & {
9697
+ create: (input: FileAttachment) => {
9698
+ readonly data: string;
9699
+ readonly mime: string;
9700
+ readonly source: {
9701
+ readonly type: "inline";
9702
+ } | {
9703
+ readonly type: "uri";
9704
+ readonly uri: string;
9705
+ };
9706
+ readonly name?: string | undefined;
9707
+ readonly description?: string | undefined;
9708
+ readonly mention?: {
9709
+ readonly start: number;
9710
+ readonly end: number;
9711
+ readonly text: string;
9712
+ } | undefined;
10017
9713
  };
10018
- readonly name?: string | undefined;
10019
- readonly description?: string | undefined;
10020
- readonly mention?: {
10021
- readonly start: number;
10022
- readonly end: number;
10023
- readonly text: string;
10024
- } | undefined;
10025
- };
10026
- }>>, never, never>;
10027
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
10028
- readonly name: Schema.String;
10029
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
10030
- readonly start: Schema.Finite;
10031
- readonly end: Schema.Finite;
10032
- readonly text: Schema.String;
10033
- }>>>, Schema.optionalKey<Schema.Struct<{
10034
- readonly start: Schema.Finite;
10035
- readonly end: Schema.Finite;
10036
- readonly text: Schema.String;
10037
- }>>, never, never>;
10038
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
10039
- readonly name: Schema.String;
10040
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
10041
- readonly start: Schema.Finite;
10042
- readonly end: Schema.Finite;
10043
- readonly text: Schema.String;
10044
- }>>>, Schema.optionalKey<Schema.Struct<{
10045
- readonly start: Schema.Finite;
10046
- readonly end: Schema.Finite;
10047
- readonly text: Schema.String;
10048
9714
  }>>, never, never>;
10049
- }>>>, never, never>;
10050
- }> & {
10051
- equivalence: import("effect/Equivalence").Equivalence<{
10052
- readonly text: string;
10053
- readonly files?: readonly {
10054
- readonly data: string;
10055
- readonly mime: string;
10056
- readonly source: {
10057
- readonly type: "inline";
10058
- } | {
10059
- readonly type: "uri";
10060
- readonly uri: string;
10061
- };
10062
- readonly name?: string | undefined;
10063
- readonly description?: string | undefined;
10064
- readonly mention?: {
10065
- readonly start: number;
10066
- readonly end: number;
10067
- readonly text: string;
10068
- } | undefined;
10069
- }[] | undefined;
10070
- readonly agents?: readonly {
10071
- readonly name: string;
10072
- readonly mention?: {
10073
- readonly start: number;
10074
- readonly end: number;
10075
- readonly text: string;
10076
- } | undefined;
10077
- }[] | undefined;
9715
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
9716
+ readonly name: Schema.String;
9717
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9718
+ readonly start: Schema.Finite;
9719
+ readonly end: Schema.Finite;
9720
+ readonly text: Schema.String;
9721
+ }>>>, Schema.optionalKey<Schema.Struct<{
9722
+ readonly start: Schema.Finite;
9723
+ readonly end: Schema.Finite;
9724
+ readonly text: Schema.String;
9725
+ }>>, never, never>;
9726
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
9727
+ readonly name: Schema.String;
9728
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
9729
+ readonly start: Schema.Finite;
9730
+ readonly end: Schema.Finite;
9731
+ readonly text: Schema.String;
9732
+ }>>>, Schema.optionalKey<Schema.Struct<{
9733
+ readonly start: Schema.Finite;
9734
+ readonly end: Schema.Finite;
9735
+ readonly text: Schema.String;
9736
+ }>>, never, never>;
9737
+ }>>>, never, never>;
10078
9738
  }>;
10079
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
10080
- readonly text: string;
10081
- readonly files?: readonly {
10082
- readonly data: string;
10083
- readonly mime: string;
10084
- readonly source: {
10085
- readonly type: "inline";
10086
- } | {
10087
- readonly type: "uri";
10088
- readonly uri: string;
10089
- };
10090
- readonly name?: string | undefined;
10091
- readonly description?: string | undefined;
10092
- readonly mention?: {
10093
- readonly start: number;
10094
- readonly end: number;
10095
- readonly text: string;
10096
- } | undefined;
10097
- }[] | undefined;
10098
- readonly agents?: readonly {
10099
- readonly name: string;
10100
- readonly mention?: {
10101
- readonly start: number;
10102
- readonly end: number;
10103
- readonly text: string;
10104
- } | undefined;
10105
- }[] | undefined;
10106
- };
10107
- };
10108
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
10109
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
9739
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
9740
+ }>, Schema.Struct<{
9741
+ readonly type: Schema.tag<"synthetic">;
9742
+ readonly data: Schema.Struct<{
9743
+ readonly text: Schema.String;
9744
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
9745
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
9746
+ }>;
9747
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
9748
+ }>]>;
9749
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
10110
9750
  create: () => string & import("effect/Brand").Brand<"SessionID">;
10111
9751
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
10112
9752
  };
@@ -12623,7 +12263,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
12623
12263
  };
12624
12264
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12625
12265
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12626
- readonly type: Schema.Literal<"session.prompt.promoted">;
12266
+ readonly type: Schema.Literal<"session.input.promoted">;
12627
12267
  readonly durable: Schema.Struct<{
12628
12268
  readonly aggregateID: Schema.String;
12629
12269
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -12659,7 +12299,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
12659
12299
  };
12660
12300
  }>;
12661
12301
  }> & {
12662
- type: "session.prompt.promoted";
12302
+ type: "session.input.promoted";
12663
12303
  durability: "durable";
12664
12304
  durable: {
12665
12305
  readonly version: number;
@@ -12681,7 +12321,7 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
12681
12321
  };
12682
12322
  readonly created: Schema.decodeTo<Schema.DateTimeUtc, Schema.Finite, never, never>;
12683
12323
  readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12684
- readonly type: Schema.Literal<"session.prompt.admitted">;
12324
+ readonly type: Schema.Literal<"session.input.admitted">;
12685
12325
  readonly durable: Schema.Struct<{
12686
12326
  readonly aggregateID: Schema.String;
12687
12327
  readonly seq: Schema.brand<Schema.Int, "Event.Seq">;
@@ -12707,350 +12347,260 @@ export declare const All: Schema.toTaggedUnion<"type", readonly [Schema.Struct<{
12707
12347
  }>, never, never>;
12708
12348
  }>>, never, never>;
12709
12349
  readonly data: Schema.Struct<{
12710
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
12350
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
12711
12351
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
12712
12352
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
12713
12353
  };
12714
- prompt: Schema.Struct<{
12715
- readonly text: Schema.String;
12716
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12717
- readonly data: Schema.String;
12718
- readonly mime: Schema.String;
12719
- readonly source: Schema.Union<readonly [Schema.Struct<{
12720
- readonly type: Schema.Literal<"inline">;
12721
- }>, Schema.Struct<{
12722
- readonly type: Schema.Literal<"uri">;
12723
- readonly uri: Schema.String;
12724
- }>]>;
12725
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12726
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12727
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12728
- readonly start: Schema.Finite;
12729
- readonly end: Schema.Finite;
12730
- readonly text: Schema.String;
12731
- }>>>, Schema.optionalKey<Schema.Struct<{
12732
- readonly start: Schema.Finite;
12733
- readonly end: Schema.Finite;
12734
- readonly text: Schema.String;
12735
- }>>, never, never>;
12736
- }> & {
12737
- create: (input: FileAttachment) => {
12738
- readonly data: string;
12739
- readonly mime: string;
12740
- readonly source: {
12741
- readonly type: "inline";
12742
- } | {
12743
- readonly type: "uri";
12744
- readonly uri: string;
12354
+ readonly input: Schema.Union<readonly [Schema.Struct<{
12355
+ readonly type: Schema.tag<"user">;
12356
+ readonly data: Schema.Struct<{
12357
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12358
+ readonly text: Schema.String;
12359
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12360
+ readonly data: Schema.String;
12361
+ readonly mime: Schema.String;
12362
+ readonly source: Schema.Union<readonly [Schema.Struct<{
12363
+ readonly type: Schema.Literal<"inline">;
12364
+ }>, Schema.Struct<{
12365
+ readonly type: Schema.Literal<"uri">;
12366
+ readonly uri: Schema.String;
12367
+ }>]>;
12368
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12369
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12370
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12371
+ readonly start: Schema.Finite;
12372
+ readonly end: Schema.Finite;
12373
+ readonly text: Schema.String;
12374
+ }>>>, Schema.optionalKey<Schema.Struct<{
12375
+ readonly start: Schema.Finite;
12376
+ readonly end: Schema.Finite;
12377
+ readonly text: Schema.String;
12378
+ }>>, never, never>;
12379
+ }> & {
12380
+ create: (input: FileAttachment) => {
12381
+ readonly data: string;
12382
+ readonly mime: string;
12383
+ readonly source: {
12384
+ readonly type: "inline";
12385
+ } | {
12386
+ readonly type: "uri";
12387
+ readonly uri: string;
12388
+ };
12389
+ readonly name?: string | undefined;
12390
+ readonly description?: string | undefined;
12391
+ readonly mention?: {
12392
+ readonly start: number;
12393
+ readonly end: number;
12394
+ readonly text: string;
12395
+ } | undefined;
12745
12396
  };
12746
- readonly name?: string | undefined;
12747
- readonly description?: string | undefined;
12748
- readonly mention?: {
12749
- readonly start: number;
12750
- readonly end: number;
12751
- readonly text: string;
12752
- } | undefined;
12753
- };
12754
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12755
- readonly data: Schema.String;
12756
- readonly mime: Schema.String;
12757
- readonly source: Schema.Union<readonly [Schema.Struct<{
12758
- readonly type: Schema.Literal<"inline">;
12759
- }>, Schema.Struct<{
12760
- readonly type: Schema.Literal<"uri">;
12761
- readonly uri: Schema.String;
12762
- }>]>;
12763
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12764
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12765
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12766
- readonly start: Schema.Finite;
12767
- readonly end: Schema.Finite;
12768
- readonly text: Schema.String;
12769
- }>>>, Schema.optionalKey<Schema.Struct<{
12770
- readonly start: Schema.Finite;
12771
- readonly end: Schema.Finite;
12772
- readonly text: Schema.String;
12773
- }>>, never, never>;
12774
- }> & {
12775
- create: (input: FileAttachment) => {
12776
- readonly data: string;
12777
- readonly mime: string;
12778
- readonly source: {
12779
- readonly type: "inline";
12780
- } | {
12781
- readonly type: "uri";
12782
- readonly uri: string;
12397
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12398
+ readonly data: Schema.String;
12399
+ readonly mime: Schema.String;
12400
+ readonly source: Schema.Union<readonly [Schema.Struct<{
12401
+ readonly type: Schema.Literal<"inline">;
12402
+ }>, Schema.Struct<{
12403
+ readonly type: Schema.Literal<"uri">;
12404
+ readonly uri: Schema.String;
12405
+ }>]>;
12406
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12407
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12408
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12409
+ readonly start: Schema.Finite;
12410
+ readonly end: Schema.Finite;
12411
+ readonly text: Schema.String;
12412
+ }>>>, Schema.optionalKey<Schema.Struct<{
12413
+ readonly start: Schema.Finite;
12414
+ readonly end: Schema.Finite;
12415
+ readonly text: Schema.String;
12416
+ }>>, never, never>;
12417
+ }> & {
12418
+ create: (input: FileAttachment) => {
12419
+ readonly data: string;
12420
+ readonly mime: string;
12421
+ readonly source: {
12422
+ readonly type: "inline";
12423
+ } | {
12424
+ readonly type: "uri";
12425
+ readonly uri: string;
12426
+ };
12427
+ readonly name?: string | undefined;
12428
+ readonly description?: string | undefined;
12429
+ readonly mention?: {
12430
+ readonly start: number;
12431
+ readonly end: number;
12432
+ readonly text: string;
12433
+ } | undefined;
12783
12434
  };
12784
- readonly name?: string | undefined;
12785
- readonly description?: string | undefined;
12786
- readonly mention?: {
12787
- readonly start: number;
12788
- readonly end: number;
12789
- readonly text: string;
12790
- } | undefined;
12791
- };
12792
- }>>, never, never>;
12793
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12794
- readonly name: Schema.String;
12795
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12796
- readonly start: Schema.Finite;
12797
- readonly end: Schema.Finite;
12798
- readonly text: Schema.String;
12799
- }>>>, Schema.optionalKey<Schema.Struct<{
12800
- readonly start: Schema.Finite;
12801
- readonly end: Schema.Finite;
12802
- readonly text: Schema.String;
12803
- }>>, never, never>;
12804
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12805
- readonly name: Schema.String;
12806
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12807
- readonly start: Schema.Finite;
12808
- readonly end: Schema.Finite;
12809
- readonly text: Schema.String;
12810
- }>>>, Schema.optionalKey<Schema.Struct<{
12811
- readonly start: Schema.Finite;
12812
- readonly end: Schema.Finite;
12813
- readonly text: Schema.String;
12814
12435
  }>>, never, never>;
12815
- }>>>, never, never>;
12816
- }> & {
12817
- equivalence: import("effect/Equivalence").Equivalence<{
12818
- readonly text: string;
12819
- readonly files?: readonly {
12820
- readonly data: string;
12821
- readonly mime: string;
12822
- readonly source: {
12823
- readonly type: "inline";
12824
- } | {
12825
- readonly type: "uri";
12826
- readonly uri: string;
12827
- };
12828
- readonly name?: string | undefined;
12829
- readonly description?: string | undefined;
12830
- readonly mention?: {
12831
- readonly start: number;
12832
- readonly end: number;
12833
- readonly text: string;
12834
- } | undefined;
12835
- }[] | undefined;
12836
- readonly agents?: readonly {
12837
- readonly name: string;
12838
- readonly mention?: {
12839
- readonly start: number;
12840
- readonly end: number;
12841
- readonly text: string;
12842
- } | undefined;
12843
- }[] | undefined;
12436
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12437
+ readonly name: Schema.String;
12438
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12439
+ readonly start: Schema.Finite;
12440
+ readonly end: Schema.Finite;
12441
+ readonly text: Schema.String;
12442
+ }>>>, Schema.optionalKey<Schema.Struct<{
12443
+ readonly start: Schema.Finite;
12444
+ readonly end: Schema.Finite;
12445
+ readonly text: Schema.String;
12446
+ }>>, never, never>;
12447
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12448
+ readonly name: Schema.String;
12449
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12450
+ readonly start: Schema.Finite;
12451
+ readonly end: Schema.Finite;
12452
+ readonly text: Schema.String;
12453
+ }>>>, Schema.optionalKey<Schema.Struct<{
12454
+ readonly start: Schema.Finite;
12455
+ readonly end: Schema.Finite;
12456
+ readonly text: Schema.String;
12457
+ }>>, never, never>;
12458
+ }>>>, never, never>;
12844
12459
  }>;
12845
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
12846
- readonly text: string;
12847
- readonly files?: readonly {
12848
- readonly data: string;
12849
- readonly mime: string;
12850
- readonly source: {
12851
- readonly type: "inline";
12852
- } | {
12853
- readonly type: "uri";
12854
- readonly uri: string;
12855
- };
12856
- readonly name?: string | undefined;
12857
- readonly description?: string | undefined;
12858
- readonly mention?: {
12859
- readonly start: number;
12860
- readonly end: number;
12861
- readonly text: string;
12862
- } | undefined;
12863
- }[] | undefined;
12864
- readonly agents?: readonly {
12865
- readonly name: string;
12866
- readonly mention?: {
12867
- readonly start: number;
12868
- readonly end: number;
12869
- readonly text: string;
12870
- } | undefined;
12871
- }[] | undefined;
12872
- };
12873
- };
12874
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
12875
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
12460
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
12461
+ }>, Schema.Struct<{
12462
+ readonly type: Schema.tag<"synthetic">;
12463
+ readonly data: Schema.Struct<{
12464
+ readonly text: Schema.String;
12465
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12466
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12467
+ }>;
12468
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
12469
+ }>]>;
12470
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
12876
12471
  create: () => string & import("effect/Brand").Brand<"SessionID">;
12877
12472
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
12878
12473
  };
12879
12474
  }>;
12880
12475
  }> & {
12881
- type: "session.prompt.admitted";
12476
+ type: "session.input.admitted";
12882
12477
  durability: "durable";
12883
12478
  durable: {
12884
12479
  readonly version: number;
12885
12480
  readonly aggregate: string;
12886
12481
  };
12887
12482
  data: Schema.Struct<{
12888
- inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
12483
+ readonly inputID: Schema.brand<Schema.String, "Session.Message.ID"> & {
12889
12484
  create: () => string & import("effect/Brand").Brand<"Session.Message.ID">;
12890
12485
  fromEvent: (eventID: Event.ID) => string & import("effect/Brand").Brand<"Session.Message.ID">;
12891
12486
  };
12892
- prompt: Schema.Struct<{
12893
- readonly text: Schema.String;
12894
- readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12895
- readonly data: Schema.String;
12896
- readonly mime: Schema.String;
12897
- readonly source: Schema.Union<readonly [Schema.Struct<{
12898
- readonly type: Schema.Literal<"inline">;
12899
- }>, Schema.Struct<{
12900
- readonly type: Schema.Literal<"uri">;
12901
- readonly uri: Schema.String;
12902
- }>]>;
12903
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12904
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12905
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12906
- readonly start: Schema.Finite;
12907
- readonly end: Schema.Finite;
12908
- readonly text: Schema.String;
12909
- }>>>, Schema.optionalKey<Schema.Struct<{
12910
- readonly start: Schema.Finite;
12911
- readonly end: Schema.Finite;
12912
- readonly text: Schema.String;
12913
- }>>, never, never>;
12914
- }> & {
12915
- create: (input: FileAttachment) => {
12916
- readonly data: string;
12917
- readonly mime: string;
12918
- readonly source: {
12919
- readonly type: "inline";
12920
- } | {
12921
- readonly type: "uri";
12922
- readonly uri: string;
12487
+ readonly input: Schema.Union<readonly [Schema.Struct<{
12488
+ readonly type: Schema.tag<"user">;
12489
+ readonly data: Schema.Struct<{
12490
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12491
+ readonly text: Schema.String;
12492
+ readonly files: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12493
+ readonly data: Schema.String;
12494
+ readonly mime: Schema.String;
12495
+ readonly source: Schema.Union<readonly [Schema.Struct<{
12496
+ readonly type: Schema.Literal<"inline">;
12497
+ }>, Schema.Struct<{
12498
+ readonly type: Schema.Literal<"uri">;
12499
+ readonly uri: Schema.String;
12500
+ }>]>;
12501
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12502
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12503
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12504
+ readonly start: Schema.Finite;
12505
+ readonly end: Schema.Finite;
12506
+ readonly text: Schema.String;
12507
+ }>>>, Schema.optionalKey<Schema.Struct<{
12508
+ readonly start: Schema.Finite;
12509
+ readonly end: Schema.Finite;
12510
+ readonly text: Schema.String;
12511
+ }>>, never, never>;
12512
+ }> & {
12513
+ create: (input: FileAttachment) => {
12514
+ readonly data: string;
12515
+ readonly mime: string;
12516
+ readonly source: {
12517
+ readonly type: "inline";
12518
+ } | {
12519
+ readonly type: "uri";
12520
+ readonly uri: string;
12521
+ };
12522
+ readonly name?: string | undefined;
12523
+ readonly description?: string | undefined;
12524
+ readonly mention?: {
12525
+ readonly start: number;
12526
+ readonly end: number;
12527
+ readonly text: string;
12528
+ } | undefined;
12923
12529
  };
12924
- readonly name?: string | undefined;
12925
- readonly description?: string | undefined;
12926
- readonly mention?: {
12927
- readonly start: number;
12928
- readonly end: number;
12929
- readonly text: string;
12930
- } | undefined;
12931
- };
12932
- }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12933
- readonly data: Schema.String;
12934
- readonly mime: Schema.String;
12935
- readonly source: Schema.Union<readonly [Schema.Struct<{
12936
- readonly type: Schema.Literal<"inline">;
12937
- }>, Schema.Struct<{
12938
- readonly type: Schema.Literal<"uri">;
12939
- readonly uri: Schema.String;
12940
- }>]>;
12941
- readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12942
- readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12943
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12944
- readonly start: Schema.Finite;
12945
- readonly end: Schema.Finite;
12946
- readonly text: Schema.String;
12947
- }>>>, Schema.optionalKey<Schema.Struct<{
12948
- readonly start: Schema.Finite;
12949
- readonly end: Schema.Finite;
12950
- readonly text: Schema.String;
12951
- }>>, never, never>;
12952
- }> & {
12953
- create: (input: FileAttachment) => {
12954
- readonly data: string;
12955
- readonly mime: string;
12956
- readonly source: {
12957
- readonly type: "inline";
12958
- } | {
12959
- readonly type: "uri";
12960
- readonly uri: string;
12530
+ }>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12531
+ readonly data: Schema.String;
12532
+ readonly mime: Schema.String;
12533
+ readonly source: Schema.Union<readonly [Schema.Struct<{
12534
+ readonly type: Schema.Literal<"inline">;
12535
+ }>, Schema.Struct<{
12536
+ readonly type: Schema.Literal<"uri">;
12537
+ readonly uri: Schema.String;
12538
+ }>]>;
12539
+ readonly name: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12540
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12541
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12542
+ readonly start: Schema.Finite;
12543
+ readonly end: Schema.Finite;
12544
+ readonly text: Schema.String;
12545
+ }>>>, Schema.optionalKey<Schema.Struct<{
12546
+ readonly start: Schema.Finite;
12547
+ readonly end: Schema.Finite;
12548
+ readonly text: Schema.String;
12549
+ }>>, never, never>;
12550
+ }> & {
12551
+ create: (input: FileAttachment) => {
12552
+ readonly data: string;
12553
+ readonly mime: string;
12554
+ readonly source: {
12555
+ readonly type: "inline";
12556
+ } | {
12557
+ readonly type: "uri";
12558
+ readonly uri: string;
12559
+ };
12560
+ readonly name?: string | undefined;
12561
+ readonly description?: string | undefined;
12562
+ readonly mention?: {
12563
+ readonly start: number;
12564
+ readonly end: number;
12565
+ readonly text: string;
12566
+ } | undefined;
12961
12567
  };
12962
- readonly name?: string | undefined;
12963
- readonly description?: string | undefined;
12964
- readonly mention?: {
12965
- readonly start: number;
12966
- readonly end: number;
12967
- readonly text: string;
12968
- } | undefined;
12969
- };
12970
- }>>, never, never>;
12971
- readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12972
- readonly name: Schema.String;
12973
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12974
- readonly start: Schema.Finite;
12975
- readonly end: Schema.Finite;
12976
- readonly text: Schema.String;
12977
- }>>>, Schema.optionalKey<Schema.Struct<{
12978
- readonly start: Schema.Finite;
12979
- readonly end: Schema.Finite;
12980
- readonly text: Schema.String;
12981
12568
  }>>, never, never>;
12982
- }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12983
- readonly name: Schema.String;
12984
- readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12985
- readonly start: Schema.Finite;
12986
- readonly end: Schema.Finite;
12987
- readonly text: Schema.String;
12988
- }>>>, Schema.optionalKey<Schema.Struct<{
12989
- readonly start: Schema.Finite;
12990
- readonly end: Schema.Finite;
12991
- readonly text: Schema.String;
12992
- }>>, never, never>;
12993
- }>>>, never, never>;
12994
- }> & {
12995
- equivalence: import("effect/Equivalence").Equivalence<{
12996
- readonly text: string;
12997
- readonly files?: readonly {
12998
- readonly data: string;
12999
- readonly mime: string;
13000
- readonly source: {
13001
- readonly type: "inline";
13002
- } | {
13003
- readonly type: "uri";
13004
- readonly uri: string;
13005
- };
13006
- readonly name?: string | undefined;
13007
- readonly description?: string | undefined;
13008
- readonly mention?: {
13009
- readonly start: number;
13010
- readonly end: number;
13011
- readonly text: string;
13012
- } | undefined;
13013
- }[] | undefined;
13014
- readonly agents?: readonly {
13015
- readonly name: string;
13016
- readonly mention?: {
13017
- readonly start: number;
13018
- readonly end: number;
13019
- readonly text: string;
13020
- } | undefined;
13021
- }[] | undefined;
12569
+ readonly agents: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Array<Schema.Struct<{
12570
+ readonly name: Schema.String;
12571
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12572
+ readonly start: Schema.Finite;
12573
+ readonly end: Schema.Finite;
12574
+ readonly text: Schema.String;
12575
+ }>>>, Schema.optionalKey<Schema.Struct<{
12576
+ readonly start: Schema.Finite;
12577
+ readonly end: Schema.Finite;
12578
+ readonly text: Schema.String;
12579
+ }>>, never, never>;
12580
+ }>>>>, Schema.optionalKey<Schema.$Array<Schema.Struct<{
12581
+ readonly name: Schema.String;
12582
+ readonly mention: Schema.decodeTo<Schema.optional<Schema.toType<Schema.Struct<{
12583
+ readonly start: Schema.Finite;
12584
+ readonly end: Schema.Finite;
12585
+ readonly text: Schema.String;
12586
+ }>>>, Schema.optionalKey<Schema.Struct<{
12587
+ readonly start: Schema.Finite;
12588
+ readonly end: Schema.Finite;
12589
+ readonly text: Schema.String;
12590
+ }>>, never, never>;
12591
+ }>>>, never, never>;
13022
12592
  }>;
13023
- fromUserMessage: (input: Pick<Prompt, "text" | "files" | "agents">) => {
13024
- readonly text: string;
13025
- readonly files?: readonly {
13026
- readonly data: string;
13027
- readonly mime: string;
13028
- readonly source: {
13029
- readonly type: "inline";
13030
- } | {
13031
- readonly type: "uri";
13032
- readonly uri: string;
13033
- };
13034
- readonly name?: string | undefined;
13035
- readonly description?: string | undefined;
13036
- readonly mention?: {
13037
- readonly start: number;
13038
- readonly end: number;
13039
- readonly text: string;
13040
- } | undefined;
13041
- }[] | undefined;
13042
- readonly agents?: readonly {
13043
- readonly name: string;
13044
- readonly mention?: {
13045
- readonly start: number;
13046
- readonly end: number;
13047
- readonly text: string;
13048
- } | undefined;
13049
- }[] | undefined;
13050
- };
13051
- };
13052
- delivery: Schema.Literals<readonly ["steer", "queue"]>;
13053
- sessionID: Schema.brand<Schema.String, "SessionID"> & {
12593
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
12594
+ }>, Schema.Struct<{
12595
+ readonly type: Schema.tag<"synthetic">;
12596
+ readonly data: Schema.Struct<{
12597
+ readonly text: Schema.String;
12598
+ readonly description: Schema.decodeTo<Schema.optional<Schema.toType<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
12599
+ readonly metadata: Schema.decodeTo<Schema.optional<Schema.toType<Schema.$Record<Schema.String, Schema.Unknown>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Unknown>>, never, never>;
12600
+ }>;
12601
+ readonly delivery: Schema.Literals<readonly ["steer", "queue"]>;
12602
+ }>]>;
12603
+ readonly sessionID: Schema.brand<Schema.String, "SessionID"> & {
13054
12604
  create: () => string & import("effect/Brand").Brand<"SessionID">;
13055
12605
  descending: (id?: string) => string & import("effect/Brand").Brand<"SessionID">;
13056
12606
  };