475. 475 ),
476. 476 (
477. 477 "coding.test_report",
478. 478 vec!["tests", "pass_fail"],
479. 479 vec!["test.report"],
480. 480 vec!["desktop", "terminal", "telegram"],
481. 481 ),
482. 482 (
483. 483 "terminal.session",
484. 484 vec!["terminal", "command_exec"],
485. 485 vec!["terminal.view"],
486. 486 vec!["desktop", "terminal"],
487. 487 ),
488. 488 (
489. 489 "data.multi_chart",
490. 490 vec!["chart", "telemetry"],
491. 491 vec!["chart"],
492. 492 vec!["desktop", "terminal"],
493. 493 ),
494. 494 (
495. 495 "data.spreadsheet_grid",
496. 496 // A markdown table is structurally unambiguous on its own. The
497. 497 // former second signal (`table_data`, keywords like "dataset" or
498. 498 // "MRR") made a plain table of index levels or prices — no such
499. 499 // word — match nothing, so it was never recognised as a grid.
500. 500 vec!["tabular"],
501. 501 vec!["data.grid"],
502. 502 vec!["desktop", "terminal"],
503. 503 ),
504. 504 (
505. 505 "lifestyle.culinary_recipe",
506. 506 vec!["recipe", "ingredients"],
507. 507 vec!["recipe.card"],
508. 508 vec!["desktop"],
509. 509 ),
510. 510 (
511. 511 "workflow.approval",
512. 512 vec!["approval", "action"],
513. 513 vec!["approval"],
514. 514 vec!["desktop", "telegram"],
515. 515 ),
516. 516 (
517. 517 "artifact.collection",
518. 518 vec!["artifact"],
519. 519 vec!["artifact.collection"],
520. 520 vec!["desktop", "terminal", "telegram"],
521. 521 ),
522. 522 (
523. 523 "ui.preview",
524. 524 vec![],
525. 525 vec!["ui.preview"],
526. 526 vec!["desktop", "terminal", "telegram"],
527. 527 ),
528. 528 (
529. 529 "plan.timeline",
530. 530 vec!["plan", "timeline"],
531. 531 vec!["plan.timeline"],
532. 532 vec!["desktop", "terminal", "telegram"],
533. 533 ),
534. 534 (
535. 535 "universal.map",
536. 536 vec!["location", "coordinates", "route"],
537. 537 vec!["map"],
538. 538 vec!["desktop", "terminal", "telegram"],
539. 539 ),
540. 540 (
541. 541 "universal.calendar",
542. 542 vec!["event", "meeting", "availability"],
543. 543 vec!["calendar"],
544. 544 vec!["desktop", "terminal", "telegram"],
545. 545 ),
546. 546 (
547. 547 "universal.board",
548. 548 vec!["board", "kanban", "column"],
549. 549 vec!["board"],
550. 550 vec!["desktop", "terminal"],
551. 551 ),
552. 552 (
553. 553 "universal.entity",
554. 554 vec!["person", "company", "place", "product"],
555. 555 vec!["entity"],
556. 556 vec!["desktop", "terminal", "telegram"],
557. 557 ),
558. 558 (
559. 559 "universal.evidence",
560. 560 vec!["source", "citation", "provenance"],
561. 561 vec!["evidence"],
562. 562 vec!["desktop", "terminal", "telegram"],
563. 563 ),
564. 564 (
565. 565 "universal.document",
566. 566 vec!["document", "pdf", "report"],
567. 567 vec!["document"],
568. 568 vec!["desktop", "terminal", "telegram"],
569. 569 ),
570. 570 (
571. 571 "universal.graph",
572. 572 vec!["graph", "network", "dependency"],
573. 573 vec!["graph"],
574. 574 vec!["desktop", "terminal"],
575. 575 ),
576. 576 (
577. 577 "universal.form",
578. 578 vec!["form", "input", "survey"],
579. 579 vec!["form"],
580. 580 vec!["desktop", "terminal"],
581. 581 ),
582. 582 (
583. 583 "universal.transaction",
584. 584 vec!["invoice", "payment", "booking"],
585. 585 vec!["transaction"],
586. 586 vec!["desktop", "terminal", "telegram"],
587. 587 ),
588. 588 (
589. 589 "universal.alert",
590. 590 vec!["alert", "warning", "incident"],
591. 591 vec!["alert"],
592. 592 vec!["desktop", "terminal", "telegram"],
593. 593 ),
594. 594 (
595. 595 "universal.conversation",
596. 596 vec!["conversation", "thread", "message"],
597. 597 vec!["conversation"],
598. 598 vec!["desktop", "terminal", "telegram"],
599. 599 ),
600. 600 (
601. 601 "universal.simulation",
602. 602 vec!["forecast", "scenario", "what_if"],
603. 603 vec!["simulation"],
604. 604 vec!["desktop", "terminal"],
605. 605 ),
606. 606 ] {
607. 607 let requires_typed_output = matches!(recipe.0, "coding.test_report" | "ui.preview");
608. 608 let typed_output_types: Vec<String> = match recipe.0 {
609. 609 "coding.test_report" => vec!["test.report".into()],
610. 610 "ui.preview" => vec!["ui.preview".into()],
611. 611 _ => Vec::new(),
612. 612 };
613. 613 let _ = catalog.register(PresentationRecipe {
614. 614 id: recipe.0.into(),
615. 615 version: "1.0.0".into(),
616. 616 owner_skill: None,
617. 617 priority: 0,
618. 618 match_signals: recipe.1.into_iter().map(String::from).collect(),
619. 619 primary: recipe.2.into_iter().map(String::from).collect(),
620. 620 optional: Vec::new(),
621. 621 fallback: BTreeMap::new(),
622. 622 surfaces: recipe.3.into_iter().map(String::from).collect(),
623. 623 default_recipe: recipe.0 == "answer.basic",
624. 624 requires_typed_output,
625. 625 typed_output_types,
626. 626 });
627. 627 }
628. 628 catalog
629. 629}
630. 630
631. 631pub fn built_in_skill_registry() -> SkillRegistry {
632. 632 let mut registry = SkillRegistry::default();
633. 633 let mut renderers = BTreeMap::new();
634. 634 renderers.insert(
635. 635 "desktop".into(),
636. 636 RendererBinding {
637. 637 renderer: "native:structured".into(),
638. 638 interactive: false,
639. 639 requires: vec![],
640. 640 },
641. 641 );
642. 642 renderers.insert(
643. 643 "terminal".into(),
644. 644 RendererBinding {
645. 645 renderer: "builtin:generic".into(),
646. 646 interactive: false,
647. 647 requires: vec![],
648. 648 },
649. 649 );
650. 650 renderers.insert(
651. 651 "telegram".into(),
652. 652 RendererBinding {
653. 653 renderer: "builtin:compact".into(),
654. 654 interactive: false,
655. 655 requires: vec![],
656. 656 },
657. 657 );
658. 658 let _ = registry.register(PresentationSkillManifest {
659. 659 id: "core".into(),
660. 660 version: "1.0.0".into(),
661. 661 api: PRESENTATION_SKILL_API.into(),
662. 662 provides: vec![
663. 663 "link.preview",
664. 664 "metric",
665. 665 "chart",
666. 666 // `chart` synonyms `emit_chart_card` accepts; the client has
667. 667 // renderers for all three (PresentationRenderer.tsx), and a
668. 668 // type the registry rejects degrades a valid card to fallback
669. 669 // text.
670. 670 "trend",
671. 671 "timeseries",
672. 672 "bar_chart",
673. 673 // Same gap, same shape: the client (PresentationRenderer.tsx
674. 674 // STRUCTURED_RENDERERS) has had renderers for these ten since
675. 675 // commits 85408ebc and 1d34cd6b ("support all 62+ outcome
676. 676 // render types") but this registry was never updated alongside
677. 677 // them, so every one of them was rejected by
678. 678 // SkillRegistry::validate() with UnknownType before ever
679. 679 // reaching that client code — confirmed by diffing
680. 680 // built_in_semantic_types() against STRUCTURED_RENDERERS' keys
681. 681 // while building the emit_*_card tool-calling path (2026-09-18,
682. 682 // see docs/design/67-presentation-renderer-guide.md Step 0).
683. 683 // None of them need a dedicated validate_payload() arm: each
684. 684 // shares its shape with an already-registered sibling
685. 685 // (metric_chart/comparison_chart/telemetry.chart with chart;
686. 686 // telemetry.metric/weather with metric; decision_matrix/
687. 687 // criteria_matrix/tradeoff_analysis with table;
688. 688 // lifestyle.recipe/lifestyle.culinary_recipe with recipe.card),
689. 689 // so the shared, permissive fallthrough in validate_payload
690. 690 // already covers them.
691. 691 "metric_chart",
692. 692 "comparison_chart",
693. 693 "telemetry.chart",
694. 694 "telemetry.metric",
695. 695 "weather",
696. 696 "decision_matrix",
697. 697 "criteria_matrix",
698. 698 "tradeoff_analysis",
699. 699 "lifestyle.recipe",
700. 700 "lifestyle.culinary_recipe",
701. 701 "media.image",
702. 702 "media.video",
703. 703 "media.audio",
704. 704 "research.synthesis",
705. 705 "itinerary",
706. 706 "coding.diff",
707. 707 "test.report",
708. 708 "terminal.view",
709. 709 "data.grid",
710. 710 "recipe.card",
711. 711 "ui.preview",
712. 712 "plan.timeline",
713. 713 "overview",
714. 714 "checklist",
715. 715 "schedule",
716. 716 "comparison",
717. 717 "decision",
718. 718 "budget",
719. 719 "collection",
720. 720 "detail",
721. 721 "steps",
722. 722 "summary",
723. 723 "notes",
724. 724 "agenda",
725. 725 "follow_up",
726. 726 "reminder",
727. 727 "comparison_table",
728. 728 "pros_cons",
729. 729 "scorecard",
730. 730 "milestones",
731. 731 "progress",
732. 732 "status",
733. 733 "inventory",
734. 734 "shopping_list",
735. 735 "meal_plan",
736. 736 "lesson",
737. 737 "reading_list",
738. 738 "habit_plan",
739. 739 "project_plan",
740. 740 "meeting_notes",
741. 741 "contact_log",
742. 742 "finance_summary",
743. 743 "invoice_summary",
744. 744 "recipe_summary",
745. 745 "travel_options",
746. 746 "home_project",
747. 747 "care_plan",
748. 748 "event_plan",
749. 749 "media_list",
750. 750 "research_brief",
751. 751 "faq",
752. 752 "timeline",
753. 753 "table",
754. 754 "dataframe",
755. 755 "recipe",
756. 756 "news",
757. 757 "coding.deployment",
758. 758 "coding.incident",
759. 759 "coding.benchmark",
760. 760 "coding.architecture",
761. 761 "coding.dependencies",
762. 762 "coding.release",
763. 763 "coding.search",
764. 764 "map",
765. 765 "route_map",
766. 766 "calendar",
767. 767 "availability",
768. 768 "board",
769. 769 "entity",
770. 770 "search_results",
771. 771 "evidence",
772. 772 "decision_analysis",
773. 773 "document",
774. 774 "graph",
775. 775 "form",
776. 776 "action",
777. 777 "transaction",
778. 778 "alert",
779. 779 "conversation",
780. 780 "progress_dashboard",
781. 781 "simulation",
782. 782 ]
783. 783 .into_iter()
784. 784 .map(String::from)
785. 785 .collect(),
786. 786 renderers,
787. 787 schema: None,
788. 788 outcome_requirements: Vec::new(),
789. 789 });
790. 790 registry
791. 791}
792. 792
793. 793/// Every `semantic_type` the built-in registry will accept, sorted and
794. 794/// de-duplicated. This is the compiled-in vocabulary a model may legally
795. 795/// emit in a ```vak block; prompt building reads it so the advertised
796. 796/// catalogue cannot drift from what the server actually validates.
797. 797pub fn built_in_semantic_types() -> Vec<String> {
798. 798 let mut types: Vec<String> = built_in_skill_registry()
799. 799 .skills
800. 800 .values()
801. 801 .flat_map(|skill| skill.provides.iter().cloned())
802. 802 .collect();
803. 803 types.sort();
804. 804 types.dedup();
805. 805 types
806. 806}
807. 807
808. 808pub fn signals_from_text(text: &str) -> Vec<String> {
809. 809 let lower = text.to_ascii_lowercase();
810. 810 let checks = [
811. 811 (
812. 812 "citations",
813. 813 &["http://", "https://", "source:", "sources:"][..],
814. 814 ),
815. 815 (
816. 816 "multiple_sources",
817. 817 &["sources:", "according to", "references"][..],
818. 818 ),
819. 819 (
820. 820 "research",
821. 821 &[
822. 822 "research",
823. 823 "key takeaways",
824. 824 "findings",
825. 825 "research synthesis",
826. 826 "verified sources",
827. 827 ][..],
828. 828 ),
829. 829 (
830. 830 "synthesis",
831. 831 &["synthesis", "key takeaways", "findings", "verified sources"][..],
832. 832 ),
833. 833 (
834. 834 "takeaways",
835. 835 &[
836. 836 "key takeaways",
837. 837 "takeaways",
838. 838 "findings",
839. 839 "research synthesis",
840. 840 ][..],
841. 841 ),
842. 842 ("temperature", &["temperature", "°c", "°f"][..]),
843. 843 ("forecast", &["forecast", "humidity", "wind speed"][..]),
844. 844 (
845. 845 "travel",
846. 846 &["travel", "trip", "itinerary", "flight", "hotel", "vacation"][..],
847. 847 ),
848. 848 (
849. 849 "news",
850. 850 &[
851. 851 "news",
852. 852 "latest",
853. 853 "headlines",
854. 854 "what happened",
855. 855 "current events",
856. 856 ][..],
857. 857 ),
858. 858 (
859. 859 "files_changed",
860. 860 &["files changed", "modified:", "created:"][..],
861. 861 ),
862. 862 ("tests", &["tests", "test suite", "test report"][..]),
863. 863 ("pass_fail", &["passed", "failed", "failures"][..]),
864. 864 (
865. 865 "benchmark",
866. 866 &[
867. 867 "benchmark",
868. 868 "req/sec",
869. 869 "req/s",
870. 870 "p99",
871. 871 "throughput",
872. 872 "concurrency",
873. 873 ][..],
874. 874 ),
875. 875 (
876. 876 "chart",
877. 877 &["chart", "plot", "graph", "trend", "time series"][..],
878. 878 ),
879. 879 (
880. 880 "telemetry",
881. 881 &[
882. 882 "telemetry",
883. 883 "metrics",
884. 884 "kpi",
885. 885 "latency",
886. 886 "req/sec",
887. 887 "req/s",
888. 888 "p99",
889. 889 "throughput",
890. 890 ][..],
891. 891 ),
892. 892 (
893. 893 "table_data",
894. 894 &[
895. 895 "table",
896. 896 "dataset",
897. 897 "mrr",
898. 898 "active orgs",
899. 899 "revenue breakdown",
900. 900 ][..],
901. 901 ),
902. 902 (
903. 903 "recipe",
904. 904 &["recipe", "servings", "cook time", "prep time", "baste"][..],
905. 905 ),
906. 906 (
907. 907 "ingredients",
908. 908 &[
909. 909 "ingredients",
910. 910 "tbsp",
911. 911 "tsp",
912. 912 "fillet",
913. 913 "tablespoon",
914. 914 "teaspoon",
915. 915 "cups",
916. 916 ][..],
917. 917 ),
918. 918 ("artifact", &["artifact", "download", "generated file"][..]),
919. 919 ("approval", &["approval", "approve", "permission"][..]),
920. 920 ("action", &["allow once", "deny", "run this"][..]),
921. 921 (
922. 922 "terminal",
923. 923 &["docker ps", "kubectl", "exit 0", "exit 1", "command line"][..],
924. 924 ),
925. 925 (
926. 926 "command_exec",
927. 927 &["$ ", "user@", "exit 0", "exit 1", "stdout:", "stderr:"][..],
928. 928 ),
929. 929 (
930. 930 "docker",
931. 931 &["docker", "container", "microservices", "ports"][..],
932. 932 ),
933. 933 ];
934. 934 let mut signals: Vec<String> = checks
935. 935 .iter()
936. 936 .filter_map(|(signal, needles)| {
937. 937 needles
938. 938 .iter()
939. 939 .any(|needle| signal_text_hit(&lower, needle))
940. 940 .then_some((*signal).into())
941. 941 })
942. 942 .collect();
943. 943 signals.extend(structural_signals(text).into_iter().map(String::from));
944. 944 signals
945. 945}
946. 946
947. 947/// Signals about the *structure* of a piece of Markdown, read from the parsed
948. 948/// document rather than from characters in the raw text: a table is a table
949. 949/// block, a diff is a code block in diff form. (These used to be substring
950. 950/// hits on `| ---`, a fenced ```` ```diff ```` marker and a literal tab, which
951. 951/// miss an indented table, match a table inside a code sample, and cannot tell
952. 952/// a real tab-separated block from one stray tab.)
953. 953fn structural_signals(text: &str) -> Vec<&'static str> {
954. 954 use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag, TagEnd};
955. 955 let mut signals = Vec::new();
956. 956 let mut code: Option<(bool, String)> = None; // (declared diff/patch, body)
957. 957 for event in Parser::new_ext(text, Options::ENABLE_TABLES) {
958. 958 match event {
959. 959 Event::Start(Tag::Table(_)) => signals.push("tabular"),
960. 960 Event::Start(Tag::CodeBlock(kind)) => {
961. 961 let declared_diff = matches!(&kind, CodeBlockKind::Fenced(info)
962. 962 if matches!(info.split_whitespace().next(), Some("diff" | "patch")));
963. 963 code = Some((declared_diff, String::new()));
964. 964 }
965. 965 Event::Text(chunk) => {
966. 966 if let Some((_, body)) = code.as_mut() {
967. 967 body.push_str(&chunk);
968. 968 }
969. 969 }
970. 970 Event::End(TagEnd::CodeBlock) => {
971. 971 if let Some((declared_diff, body)) = code.take() {
972. 972 let first = body.lines().next().unwrap_or_default();
973. 973 if declared_diff || first.starts_with("diff --git") || first.starts_with("@@ ")
974. 974 {
975. 975 signals.push("diff");
976. 976 }
977. 977 if is_tab_separated(&body) {
978. 978 signals.push("tabular");
979. 979 }
980. 980 }
981. 981 }
982. 982 _ => {}
983. 983 }
984. 984 }
985. 985 if is_tab_separated(text) {
986. 986 signals.push("tabular");
987. 987 }
988. 988 // An unfenced unified diff is still a diff: a `diff --git` header line or a
989. 989 // hunk header (`@@ -1,2 +1,3 @@`) at the start of a line.
990. 990 if text
991. 991 .lines()
992. 992 .any(|line| line.starts_with("diff --git ") || is_hunk_header(line))
993. 993 {
994. 994 signals.push("diff");
995. 995 }
996. 996 signals
997. 997}
998. 998
999. 999/// `@@ -a[,b] +c[,d] @@` at the start of a line.
1000. 1000fn is_hunk_header(line: &str) -> bool {
1001. 1001 let Some(rest) = line.strip_prefix("@@ -") else {
1002. 1002 return false;
1003. 1003 };
1004. 1004 let mut parts = rest.splitn(2, " +");
1005. 1005 let (old, new) = (
1006. 1006 parts.next().unwrap_or_default(),
1007. 1007 parts.next().unwrap_or_default(),
1008. 1008 );
1009. 1009 let range = |text: &str| {
1010. 1010 let text = text.split(" @@").next().unwrap_or_default();
1011. 1011 !text.is_empty()
1012. 1012 && text
1013. 1013 .split(',')
1014. 1014 .all(|n| !n.is_empty() && n.chars().all(|c| c.is_ascii_digit()))
1015. 1015 };
1016. 1016 range(old) && range(new) && line.contains(" @@")
1017. 1017}
1018. 1018
1019. 1019/// Two or more consecutive lines that each split into the same number (at
1020. 1020/// least two) of tab-separated fields — a pasted spreadsheet range — as
1021. 1021/// opposed to a stray tab in prose.
1022. 1022fn is_tab_separated(text: &str) -> bool {
1023. 1023 let mut previous: Option<usize> = None;
1024. 1024 let mut run = 0;
1025. 1025 for line in text.lines() {
1026. 1026 let fields = line.split('\t').count();
1027. 1027 if fields >= 2 && previous.is_none_or(|p| p == fields) {
1028. 1028 run += 1;
1029. 1029 previous = Some(fields);
1030. 1030 if run >= 2 {
1031. 1031 return true;
1032. 1032 }
1033. 1033 } else {
1034. 1034 run = usize::from(fields >= 2);
1035. 1035 previous = (fields >= 2).then_some(fields);
1036. 1036 }
1037. 1037 }
1038. 1038 false
1039. 1039}
1040. 1040
1041. 1041/// Match standalone lexical terms without allowing incidental substrings in
1042. 1042/// ordinary prose. Compound phrases retain substring matching because their
1043. 1043/// spaces provide the boundary. Needles that themselves contain non-word
1044. 1044/// boundary characters (e.g. `https://`, `source:`, `°c`) fall back to
1045. 1045/// substring matching, since tokenization would strip those characters and
1046. 1046/// make a match impossible. Presentation signals are hints only; typed
1047. 1047/// result provenance remains the authority for specialized recipes.
1048. 1048fn signal_text_hit(lower: &str, needle: &str) -> bool {
1049. 1049 if needle.chars().any(char::is_whitespace)
1050. 1050 || needle.chars().any(|c| !c.is_alphanumeric() && c != '_')
1051. 1051 {
1052. 1052 return lower.contains(needle);
1053. 1053 }
1054. 1054 lower
1055. 1055 .split(|character: char| !character.is_alphanumeric() && character != '_')
1056. 1056 .any(|token| token == needle)
1057. 1057}
1058. 1058
1059. 1059#[derive(Debug, Clone, Default)]
1060. 1060pub struct SignalContext<'a> {
1061. 1061 pub text: &'a str,
1062. 1062 pub tool_name: Option<&'a str>,
1063. 1063 pub tool_input: Option<&'a serde_json::Value>,
1064. 1064 pub tool_output: Option<&'a str>,
1065. 1065 pub is_error: bool,
1066. 1066 /// Domain names the calling capability declares it serves (e.g. `"web"`,
1067. 1067 /// `"live-data"`), as recorded by `vak_core::capability::domain::Domain`.
1068. 1068 /// Drives presentation signals that depend on external retrieval; a
1069. 1069 /// tool's name or identity is never matched for this.
1070. 1070 pub domains: &'a [&'a str],
1071. 1071}
1072. 1072
1073. 1073pub fn signals_from_context(ctx: &SignalContext<'_>) -> Vec<String> {
1074. 1074 let mut signals = signals_from_text(ctx.text);
1075. 1075 if let Some(tool) = ctx.tool_name {
1076. 1076 match tool {
1077. 1077 "bash" => {
1078. 1078 signals.push("terminal".into());
1079. 1079 signals.push("command_exec".into());
1080. 1080 if let Some(input) = ctx.tool_input {
1081. 1081 let cmd = input
1082. 1082 .get("command")
1083. 1083 .or_else(|| input.get("cmd"))
1084. 1084 .and_then(|v| v.as_str())
1085. 1085 .unwrap_or("");
1086. 1086 let lower = cmd.to_ascii_lowercase();
1087. 1087 if lower.contains("test")
1088. 1088 || lower.contains("pytest")
1089. 1089 || lower.contains("cargo test")
1090. 1090 || lower.contains("npm test")
1091. 1091 {
1092. 1092 signals.push("tests".into());
1093. 1093 signals.push("pass_fail".into());
1094. 1094 }
1095. 1095 if lower.contains("docker") || lower.contains("kubectl") {
1096. 1096 signals.push("docker".into());
1097. 1097 signals.push("terminal".into());
1098. 1098 }
1099. 1099 if lower.contains("diff") || lower.contains("git diff") {
1100. 1100 signals.push("diff".into());
1101. 1101 signals.push("files_changed".into());
1102. 1102 }
1103. 1103 }
1104. 1104 }
1105. 1105 "edit" | "write" | "apply_patch" => {
1106. 1106 signals.push("diff".into());
1107. 1107 signals.push("files_changed".into());
1108. 1108 }
1109. 1109 _ => {}
1110. 1110 }
1111. 1111 }
1112. 1112 // Retrieval-flavoured presentation signals come from what the calling
1113. 1113 // capability declares it serves, never from the tool's name: a vendor
1114. 1114 // renamed or replaced still serves `web`/`live-data`, and an
1115. 1115 // undeclared capability contributes nothing here rather than being
1116. 1116 // guessed at.
1117. 1117 if ctx
1118. 1118 .domains
1119. 1119 .iter()
1120. 1120 .any(|domain| matches!(*domain, "web" | "live-data"))
1121. 1121 {
1122. 1122 signals.push("citations".into());
1123. 1123 signals.push("multiple_sources".into());
1124. 1124 signals.push("research".into());
1125. 1125 signals.push("synthesis".into());
1126. 1126 signals.push("takeaways".into());
1127. 1127 }
1128. 1128 if let Some(output) = ctx.tool_output {
1129. 1129 let lower = output.to_ascii_lowercase();
1130. 1130 if lower.contains("test result:")
1131. 1131 || lower.contains("tests passed")
1132. 1132 || lower.contains("failures:")
1133. 1133 {
1134. 1134 signals.push("tests".into());
1135. 1135 signals.push("pass_fail".into());
1136. 1136 }
1137. 1137 if lower.contains("diff --git") || lower.contains("@@ ") {
1138. 1138 signals.push("diff".into());
1139. 1139 signals.push("files_changed".into());
1140. 1140 }
1141. 1141 }
1142. 1142 signals.sort();
1143. 1143 signals.dedup();
1144. 1144 signals
1145. 1145}
1146. 1146
1147. 1147pub fn link_previews_from_text(text: &str) -> Vec<StructuredOutput> {
1148. 1148 let mut seen = std::collections::BTreeSet::new();
1149. 1149 text.split_whitespace()
1150. 1150 .filter_map(|token| {
1151. 1151 let url = token.trim_matches(|character: char| "()[]{}<>.,;\"'".contains(character));
1152. 1152 (url.starts_with("https://") || url.starts_with("http://")).then(|| url.to_string())
1153. 1153 })
1154. 1154 .filter(|url| seen.insert(url.clone()))
1155. 1155 .take(12)
1156. 1156 .map(|url| StructuredOutput {
1157. 1157 semantic_type: "link.preview".into(),
1158. 1158 schema_version: crate::PRESENTATION_SCHEMA_VERSION,
1159. 1159 skill_id: "core".into(),
1160. 1160 skill_version: "1.0.0".into(),
1161. 1161 payload: serde_json::json!({"url": url, "title": "Open source link"}),
1162. 1162 })
1163. 1163 .collect()
1164. 1164}
1165. 1165
1166. 1166/// Extract explicitly typed `vak` fragments from model/tool text. This is
1167. 1167/// intentionally domain-neutral: the registry, not this parser, decides what
1168. 1168/// semantic types exist and whether a surface may render them.
1169. 1169///
1170. 1170/// A tool result is usually not Markdown at all — it's just the JSON its
1171. 1171/// implementation returned. Requiring a ```vak fence around it would force
1172. 1172/// every tool wrapper to know about Markdown just to be found here, which is
1173. 1173/// its own kind of special-casing. So the *whole* text is tried as one bare
1174. 1174/// `{"semantic_type": ..., "payload": ...}` envelope first — the identical
1175. 1175/// two-field contract a fenced fragment uses, just without the fence. Any
1176. 1176/// tool, or any future one, opts in the same way a model does: declare what
1177. 1177/// it produced. Nothing here inspects a tool's name or its payload's field
1178. 1178/// names to guess a type.
1179. 1179pub fn structured_outputs_from_text(text: &str) -> Vec<StructuredOutput> {
1180. 1180 structured_outputs_from_text_with(text, &built_in_skill_registry())
1181. 1181}
1182. 1182
1183. 1183/// Locate byte spans `(start, end)` of candidate JSON objects containing
1184. 1184/// `"semantic_type"` within arbitrary text.
1185. 1185pub(crate) fn find_semantic_json_spans(text: &str) -> Vec<(usize, usize)> {
1186. 1186 let mut spans = Vec::new();
1187. 1187 let bytes = text.as_bytes();
1188. 1188 let len = bytes.len();
1189. 1189 let marker = b"\"semantic_type\"";
1190. 1190 let marker_len = marker.len();
1191. 1191
1192. 1192 let mut search_start = 0;
1193. 1193 while search_start + marker_len <= len {
1194. 1194 let Some(rel_pos) = text[search_start..].find("\"semantic_type\"") else {
1195. 1195 break;
1196. 1196 };
1197. 1197 let marker_pos = search_start + rel_pos;
1198. 1198
1199. 1199 let mut candidate = None;
1200. 1200 for i in (0..=marker_pos).rev() {
1201. 1201 if bytes[i] == b'{' {
1202. 1202 let mut depth = 0;
1203. 1203 let mut in_str = false;
1204. 1204 let mut escape = false;
1205. 1205 let mut closed_at = None;
1206. 1206 #[allow(clippy::needless_range_loop)]
1207. 1207 for j in i..len {
1208. 1208 let b = bytes[j];
1209. 1209 if escape {
1210. 1210 escape = false;
1211. 1211 continue;
1212. 1212 }
1213. 1213 if b == b'\\' && in_str {
1214. 1214 escape = true;
1215. 1215 continue;
1216. 1216 }
1217. 1217 if b == b'"' {
1218. 1218 in_str = !in_str;
1219. 1219 continue;
1220. 1220 }
1221. 1221 if !in_str {
1222. 1222 if b == b'{' {
1223. 1223 depth += 1;
1224. 1224 } else if b == b'}' {
1225. 1225 depth -= 1;
1226. 1226 if depth == 0 {
1227. 1227 closed_at = Some(j);
1228. 1228 break;
1229. 1229 }
1230. 1230 }
1231. 1231 }
1232. 1232 }
1233. 1233 if let Some(end_idx) = closed_at
1234. 1234 && end_idx >= marker_pos
1235. 1235 {
1236. 1236 candidate = Some((i, end_idx + 1));
1237. 1237 }
1238. 1238 }
1239. 1239 }
1240. 1240
1241. 1241 if let Some((start, end)) = candidate {
1242. 1242 if !spans.iter().any(|(s, e)| *s == start && *e == end) {
1243. 1243 spans.push((start, end));
1244. 1244 }
1245. 1245 search_start = end;
1246. 1246 } else {
1247. 1247 search_start = marker_pos + marker_len;
1248. 1248 }
1249. 1249 }
1250. 1250 spans
1251. 1251}
1252. 1252
1253. 1253/// Like [`structured_outputs_from_text`] but validates against a
1254. 1254/// plugin-extended skill registry. The Core passes its merged registry
1255. 1255/// (builtins + plugin skills) so that plugin-declared semantic types are
1256. 1256/// recognized in model/tool text.
1257. 1257pub fn structured_outputs_from_text_with(
1258. 1258 text: &str,
1259. 1259 skills: &SkillRegistry,
1260. 1260) -> Vec<StructuredOutput> {
1261. 1261 if let Ok(output) = parse_fragment_with(text.trim(), skills) {
1262. 1262 return vec![output];
1263. 1263 }
1264. 1264 let mut outputs = Vec::new();
1265. 1265 let mut remainder = text;
1266. 1266 while let Some(start) = remainder.find("```vak") {
1267. 1267 let after = &remainder[start + 6..];
1268. 1268 let body = if let Some(nl) = after.find('\n') {
1269. 1269 &after[nl + 1..]
1270. 1270 } else {
1271. 1271 after
1272. 1272 };
1273. 1273 let Some(end) = body.find("```") else { break };
1274. 1274 if let Ok(output) = parse_fragment_with(&body[..end], skills)
1275. 1275 && !outputs
1276. 1276 .iter()
1277. 1277 .any(|existing: &StructuredOutput| existing == &output)
1278. 1278 {
1279. 1279 outputs.push(output);
1280. 1280 }
1281. 1281 remainder = &body[end + 3..];
1282. 1282 }
1283. 1283 for (start, end) in find_semantic_json_spans(text) {
1284. 1284 let candidate = &text[start..end];
1285. 1285 if let Ok(output) = parse_fragment_with(candidate, skills)
1286. 1286 && !outputs
1287. 1287 .iter()
1288. 1288 .any(|existing: &StructuredOutput| existing == &output)
1289. 1289 {
1290. 1290 outputs.push(output);
1291. 1291 }
1292. 1292 }
1293. 1293 outputs
1294. 1294}
1295. 1295
1296. 1296#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1297. 1297pub struct PresentationSkillManifest {
1298. 1298 pub id: String,
1299. 1299 pub version: String,
1300. 1300 pub api: String,
1301. 1301 #[serde(default)]
1302. 1302 pub provides: Vec<String>,
1303. 1303 #[serde(default)]
1304. 1304 pub renderers: BTreeMap<String, RendererBinding>,
1305. 1305 /// Optional JSON Schema for payload validation. When present, payloads
1306. 1306 /// are validated against it. When absent (plugin skills that don't
1307. 1307 /// declare one), the payload shape is accepted as-is — the plugin's own
1308. 1308 /// renderer owns correctness of its data.
1309. 1309 #[serde(default, skip_serializing_if = "Option::is_none")]
1310. 1310 pub schema: Option<serde_json::Value>,
1311. 1311 /// Declarative requirements that a consumer may merge into its shared
1312. 1312 /// outcome contract when this skill owns the produced semantic type.
1313. 1313 #[serde(default)]
1314. 1314 pub outcome_requirements: Vec<OutcomeRequirementDeclaration>,
1315. 1315}
1316. 1316
1317. 1317#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1318. 1318pub struct OutcomeRequirementDeclaration {
1319. 1319 pub id: String,
1320. 1320 pub kind: String,
1321. 1321 pub description: String,
1322. 1322 #[serde(default)]
1323. 1323 pub importance: String,
1324. 1324}
1325. 1325
1326. 1326#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1327. 1327pub struct RendererBinding {
1328. 1328 pub renderer: String,
1329. 1329 #[serde(default)]
1330. 1330 pub interactive: bool,
1331. 1331 #[serde(default)]
1332. 1332 pub requires: Vec<String>,
1333. 1333}
1334. 1334
1335. 1335#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
1336. 1336pub struct StructuredOutput {
1337. 1337 pub semantic_type: String,
1338. 1338 pub schema_version: u16,
1339. 1339 pub skill_id: String,
1340. 1340 pub skill_version: String,
1341. 1341 pub payload: Value,
1342. 1342}
1343. 1343
1344. 1344/// The only model-authored rich block envelope. The host supplies versions
1345. 1345/// and renderer identity; models supply data, never executable UI or receipts.
1346. 1346///
1347. 1347/// Uses the built-in skill registry for validation. For plugin-contributed
1348. 1348/// semantic types, use [`parse_fragment_with`].
1349. 1349pub fn parse_fragment(source: &str) -> Result<StructuredOutput, SkillError> {
1350. 1350 parse_fragment_with(source, &built_in_skill_registry())
1351. 1351}
1352. 1352
1353. 1353/// Like [`parse_fragment`] but validates against an arbitrary (possibly
1354. 1354/// plugin-extended) skill registry. The worker receives the merged registry
1355. 1355/// through the `DeliveryJob.skill_registry` field.
1356. 1356pub fn parse_fragment_with(
1357. 1357 source: &str,
1358. 1358 skills: &SkillRegistry,
1359. 1359) -> Result<StructuredOutput, SkillError> {
1360. 1360 #[derive(Deserialize)]
1361. 1361 #[serde(deny_unknown_fields)]
1362. 1362 struct Fragment {
1363. 1363 semantic_type: String,
1364. 1364 payload: Value,
1365. 1365 }
1366. 1366 let fragment: Fragment = match serde_json::from_str(source) {
1367. 1367 Ok(f) => f,
1368. 1368 Err(err) => {
1369. 1369 if let Ok(value) = toml::from_str::<serde_json::Value>(source) {
1370. 1370 if let (Some(st), Some(p)) = (value.get("semantic_type"), value.get("payload")) {
1371. 1371 Fragment {
1372. 1372 semantic_type: st.as_str().unwrap_or("metric").to_string(),
1373. 1373 payload: p.clone(),
1374. 1374 }
1375. 1375 } else {
1376. 1376 return Err(SkillError::InvalidPayload(err.to_string()));
1377. 1377 }
1378. 1378 } else {
1379. 1379 return Err(SkillError::InvalidPayload(err.to_string()));
1380. 1380 }
1381. 1381 }
1382. 1382 };
1383. 1383 // Resolve the owning skill by the semantic type it declares, rather than
1384. 1384 // assuming "core" — plugin-contributed types are registered under their
1385. 1385 // own skill id and must validate against their own manifest.
1386. 1386 let (skill_id, skill_version) = skills
1387. 1387 .find_by_type(&fragment.semantic_type)
1388. 1388 .map(|(id, version)| (id.to_string(), version.to_string()))
1389. 1389 .unwrap_or_else(|| ("core".to_string(), "1.0.0".to_string()));
1390. 1390 let output = StructuredOutput {
1391. 1391 semantic_type: fragment.semantic_type,
1392. 1392 payload: fragment.payload,
1393. 1393 schema_version: crate::PRESENTATION_SCHEMA_VERSION,
1394. 1394 skill_id,
1395. 1395 skill_version,
1396. 1396 };
1397. 1397 skills.validate(&output, "desktop", &[])?;
1398. 1398 Ok(output)
1399. 1399}
1400. 1400
1401. 1401/// Deterministic text projection of validated data. It preserves every supplied
1402. 1402/// field in an inspectable data appendix rather than trusting a second summary.
1403. 1403pub fn structured_markdown(output: &StructuredOutput) -> String {
1404. 1404 let p = &output.payload;
1405. 1405 let title = p["title"].as_str().unwrap_or(&output.semantic_type);
1406. 1406 let mut lines = vec![format!("### {title}")];
1407. 1407 match output.semantic_type.as_str() {
1408. 1408 "metric" => {
1409. 1409 if p.get("label").is_some() && p.get("value").is_some() {
1410. 1410 lines.push(format!(
1411. 1411 "{}: {} {}",
1412. 1412 p["label"].as_str().unwrap_or_default(),
1413. 1413 p["value"]
1414. 1414 .as_str()
1415. 1415 .map(String::from)
1416. 1416 .unwrap_or_else(|| p["value"].to_string()),
1417. 1417 p["unit"].as_str().unwrap_or_default()
1418. 1418 ));
1419. 1419 } else if let Some(obj) = p.as_object() {
1420. 1420 for (k, v) in obj {
1421. 1421 if k == "title" {
1422. 1422 continue;
1423. 1423 }
1424. 1424 let val_str = v
1425. 1425 .as_str()
1426. 1426 .map(String::from)
1427. 1427 .unwrap_or_else(|| v.to_string());
1428. 1428 lines.push(format!("{k}: {val_str}"));
1429. 1429 }
1430. 1430 }
1431. 1431 }
1432. 1432 "link.preview" => lines.push(format!(
1433. 1433 "{}\n{}",
1434. 1434 title,
1435. 1435 p["url"].as_str().unwrap_or_default()
1436. 1436 )),
1437. 1437 "chart" => lines.push(p["accessible_summary"].as_str().unwrap_or_default().into()),
1438. 1438 "terminal.view" => lines.push(format!(
1439. 1439 "Command: {}\nExit: {}",
1440. 1440 p["command"].as_str().unwrap_or("not supplied"),
1441. 1441 p.get("exit_code")
1442. 1442 .map(Value::to_string)
1443. 1443 .unwrap_or_else(|| "not supplied".into())
1444. 1444 )),
1445. 1445 "plan.timeline" => {
1446. 1446 if let Some(items) = p["items"].as_array() {
1447. 1447 for item in items.iter().take(100) {
1448. 1448 let label = item["label"].as_str().unwrap_or("Step");
1449. 1449 let label = match item["time"].as_str() {
1450. 1450 Some(time) => format!("{label} ({time})"),
1451. 1451 None => label.to_string(),
1452. 1452 };
1453. 1453 let detail = item["detail"].as_str().unwrap_or_default();
1454. 1454 if detail.is_empty() {
1455. 1455 lines.push(format!("- {label}"));
1456. 1456 } else {
1457. 1457 lines.push(format!("- {label}: {detail}"));
1458. 1458 }
1459. 1459 for option in item["options"].as_array().into_iter().flatten().take(20) {
1460. 1460 let name = option["label"].as_str().unwrap_or("Option");
1461. 1461 let facts = option["facts"]
1462. 1462 .as_array()
1463. 1463 .map(|facts| {
1464. 1464 facts
1465. 1465 .iter()
1466. 1466 .filter_map(Value::as_str)
1467. 1467 .collect::<Vec<_>>()
1468. 1468 .join(", ")
1469. 1469 })
1470. 1470 .unwrap_or_default();
1471. 1471 let text = [
1472. 1472 option["detail"].as_str().unwrap_or_default(),
1473. 1473 facts.as_str(),
1474. 1474 ]