1use serde::{Deserialize, Deserializer, Serialize, Serializer};
25use serde_json::{Map, Value};
26
27use crate::Principal;
28
29#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
43#[non_exhaustive]
44pub struct CallOrigin {
45 pub carrier: Principal,
47 pub call_key: String,
50 #[serde(default, skip_serializing_if = "Option::is_none")]
53 pub message_position: Option<MessagePosition>,
54 #[serde(default, skip_serializing_if = "Option::is_none")]
61 pub schema_pin: Option<String>,
62}
63
64impl CallOrigin {
65 pub fn new(carrier: Principal, call_key: impl Into<String>) -> Self {
68 Self {
69 carrier,
70 call_key: call_key.into(),
71 message_position: None,
72 schema_pin: None,
73 }
74 }
75
76 pub fn with_message_position(mut self, position: MessagePosition) -> Self {
78 self.message_position = Some(position);
79 self
80 }
81
82 pub fn with_schema_pin(mut self, pin: impl Into<String>) -> Self {
84 self.schema_pin = Some(pin.into());
85 self
86 }
87}
88
89#[derive(Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
100#[non_exhaustive]
101pub struct MessagePosition {
102 pub message_id: String,
105 pub index: u32,
108}
109
110impl MessagePosition {
111 pub fn new(message_id: impl Into<String>, index: u32) -> Self {
113 Self {
114 message_id: message_id.into(),
115 index,
116 }
117 }
118}
119
120#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
122pub struct ToolCallRequest {
123 pub name: String,
125 pub arguments: Value,
129 #[serde(default, skip_serializing_if = "Option::is_none")]
144 pub tool_call_id: Option<String>,
145 #[serde(default, skip_serializing_if = "Option::is_none")]
148 pub progress_token: Option<Value>,
149 #[serde(default, skip_serializing_if = "Option::is_none")]
159 pub call_key: Option<String>,
160 #[serde(default, skip_serializing_if = "Option::is_none")]
167 pub schema_pin: Option<String>,
168 #[serde(default, skip_serializing_if = "Option::is_none")]
179 pub preset: Option<String>,
180 #[serde(default, skip_serializing_if = "Option::is_none")]
185 pub origin: Option<CallOrigin>,
186 #[serde(default, skip_serializing_if = "Option::is_none")]
197 pub output_refs: Option<OutputRefs>,
198}
199
200impl ToolCallRequest {
201 pub fn new(name: impl Into<String>, arguments: Value) -> Self {
205 Self {
206 name: name.into(),
207 arguments,
208 tool_call_id: None,
209 progress_token: None,
210 call_key: None,
211 schema_pin: None,
212 preset: None,
213 origin: None,
214 output_refs: None,
215 }
216 }
217}
218
219pub const CALL_KEY_FIELD: &str = "call_key";
222
223pub const SCHEMA_PIN_FIELD: &str = "schema_pin";
226
227pub const PRESET_FIELD: &str = "preset";
230
231pub const PRESET_MAX_LEN: usize = 64;
233
234#[derive(Clone, Debug, PartialEq, Eq)]
237#[non_exhaustive]
238pub enum PresetError {
239 Empty,
240 TooLong { length: usize },
241 InvalidCharacter { index: usize },
242}
243
244impl PresetError {
245 pub fn field(&self) -> &'static str {
246 PRESET_FIELD
247 }
248}
249
250impl std::fmt::Display for PresetError {
251 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
252 match self {
253 Self::Empty => write!(f, "preset must not be empty"),
254 Self::TooLong { length } => write!(
255 f,
256 "preset is {length} bytes; at most {PRESET_MAX_LEN} are allowed"
257 ),
258 Self::InvalidCharacter { index } => {
259 write!(
260 f,
261 "preset has a character at byte {index} outside [a-z0-9_-]"
262 )
263 }
264 }
265 }
266}
267
268impl std::error::Error for PresetError {}
269
270pub const ORIGIN_CALL_KEY_FIELD: &str = "origin.call_key";
273
274pub const ORIGIN_MESSAGE_ID_FIELD: &str = "origin.message_position.message_id";
278
279pub const ORIGIN_SCHEMA_PIN_FIELD: &str = "origin.schema_pin";
283
284pub const OPAQUE_FIELD_MAX_LEN: usize = 256;
287
288pub const CALL_KEY_MAX_LEN: usize = OPAQUE_FIELD_MAX_LEN;
290
291pub const SCHEMA_PIN_MAX_LEN: usize = OPAQUE_FIELD_MAX_LEN;
293
294#[derive(Clone, Debug, PartialEq, Eq)]
298pub enum OpaqueFieldError {
299 Empty { field: &'static str },
301 TooLong { field: &'static str, length: usize },
303 InvalidCharacter { field: &'static str, index: usize },
305}
306
307pub type CallKeyError = OpaqueFieldError;
310
311impl OpaqueFieldError {
312 pub fn field(&self) -> &'static str {
314 match self {
315 Self::Empty { field }
316 | Self::TooLong { field, .. }
317 | Self::InvalidCharacter { field, .. } => field,
318 }
319 }
320}
321
322impl std::fmt::Display for OpaqueFieldError {
323 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
324 match self {
325 Self::Empty { field } => write!(f, "{field} must not be empty"),
326 Self::TooLong { field, length } => write!(
327 f,
328 "{field} is {length} bytes; at most {OPAQUE_FIELD_MAX_LEN} are allowed"
329 ),
330 Self::InvalidCharacter { field, index } => write!(
331 f,
332 "{field} has a character at byte {index} outside printable ASCII \
333 (0x21 to 0x7E; space is not allowed)"
334 ),
335 }
336 }
337}
338
339impl std::error::Error for OpaqueFieldError {}
340
341pub(crate) fn validate_opaque_field(
352 field: &'static str,
353 value: &str,
354) -> Result<(), OpaqueFieldError> {
355 if value.is_empty() {
356 return Err(OpaqueFieldError::Empty { field });
357 }
358 if value.len() > OPAQUE_FIELD_MAX_LEN {
359 return Err(OpaqueFieldError::TooLong {
360 field,
361 length: value.len(),
362 });
363 }
364 if let Some(index) = value
365 .bytes()
366 .position(|byte| !(0x21..=0x7e).contains(&byte))
367 {
368 return Err(OpaqueFieldError::InvalidCharacter { field, index });
369 }
370 Ok(())
371}
372
373pub fn validate_call_key(key: &str) -> Result<(), CallKeyError> {
376 validate_opaque_field(CALL_KEY_FIELD, key)
377}
378
379pub fn validate_schema_pin(pin: &str) -> Result<(), OpaqueFieldError> {
382 validate_opaque_field(SCHEMA_PIN_FIELD, pin)
383}
384
385pub fn validate_preset(preset: &str) -> Result<(), PresetError> {
388 if preset.is_empty() {
389 return Err(PresetError::Empty);
390 }
391 if preset.len() > PRESET_MAX_LEN {
392 return Err(PresetError::TooLong {
393 length: preset.len(),
394 });
395 }
396 if let Some(index) = preset.bytes().position(|byte| {
397 !(byte.is_ascii_lowercase() || byte.is_ascii_digit() || b"_-".contains(&byte))
398 }) {
399 return Err(PresetError::InvalidCharacter { index });
400 }
401 Ok(())
402}
403
404pub fn validate_call_origin(origin: &CallOrigin) -> Result<(), OpaqueFieldError> {
410 validate_opaque_field(ORIGIN_CALL_KEY_FIELD, &origin.call_key)?;
411 if let Some(position) = &origin.message_position {
412 validate_opaque_field(ORIGIN_MESSAGE_ID_FIELD, &position.message_id)?;
413 }
414 if let Some(pin) = &origin.schema_pin {
415 validate_opaque_field(ORIGIN_SCHEMA_PIN_FIELD, pin)?;
416 }
417 Ok(())
418}
419
420pub const OUTPUT_REFS_FIELD: &str = "output_refs";
423
424pub const MAX_OUTPUT_REFS_BYTES: usize = 4 * 1024;
428
429#[derive(Clone, Debug, PartialEq, Eq)]
442pub struct OutputRefs(Map<String, Value>);
443
444impl OutputRefs {
445 pub fn new(value: Value) -> Result<Self, OutputRefsError> {
448 let Value::Object(map) = value else {
449 return Err(OutputRefsError::NotAnObject);
450 };
451 let length = serde_json::to_vec(&map).map_or(usize::MAX, |bytes| bytes.len());
453 if length > MAX_OUTPUT_REFS_BYTES {
454 return Err(OutputRefsError::TooLarge { length });
455 }
456 Ok(Self(map))
457 }
458
459 pub fn as_map(&self) -> &Map<String, Value> {
462 &self.0
463 }
464
465 pub fn into_value(self) -> Value {
467 Value::Object(self.0)
468 }
469}
470
471impl TryFrom<Value> for OutputRefs {
472 type Error = OutputRefsError;
473
474 fn try_from(value: Value) -> Result<Self, Self::Error> {
475 Self::new(value)
476 }
477}
478
479impl From<OutputRefs> for Value {
480 fn from(refs: OutputRefs) -> Self {
481 refs.into_value()
482 }
483}
484
485impl Serialize for OutputRefs {
486 fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
487 self.0.serialize(serializer)
488 }
489}
490
491impl<'de> Deserialize<'de> for OutputRefs {
492 fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
493 let value = Value::deserialize(deserializer)?;
494 Self::new(value).map_err(serde::de::Error::custom)
495 }
496}
497
498#[derive(Clone, Debug, PartialEq, Eq)]
501#[non_exhaustive]
502pub enum OutputRefsError {
503 NotAnObject,
505 TooLarge { length: usize },
508}
509
510impl OutputRefsError {
511 pub fn field(&self) -> &'static str {
513 OUTPUT_REFS_FIELD
514 }
515}
516
517impl std::fmt::Display for OutputRefsError {
518 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
519 match self {
520 Self::NotAnObject => write!(f, "{OUTPUT_REFS_FIELD} must be a JSON object"),
521 Self::TooLarge { length } => write!(
522 f,
523 "{OUTPUT_REFS_FIELD} is {length} bytes as compact JSON; at most \
524 {MAX_OUTPUT_REFS_BYTES} are allowed"
525 ),
526 }
527 }
528}
529
530impl std::error::Error for OutputRefsError {}
531
532#[cfg(test)]
533mod tests {
534 use super::*;
535 use serde_json::json;
536
537 #[test]
538 fn omitted_optionals_decode_as_none() {
539 let request: ToolCallRequest =
540 serde_json::from_value(json!({ "name": "grep", "arguments": { "q": "x" } }))
541 .expect("two-field body decodes");
542 assert_eq!(request.tool_call_id, None);
543 assert_eq!(request.progress_token, None);
544 assert_eq!(request.call_key, None);
545 assert_eq!(request.schema_pin, None);
546 assert_eq!(request.preset, None);
547 assert_eq!(request.origin, None);
548 }
549
550 #[test]
551 fn call_key_round_trips_as_a_top_level_member() {
552 let request = ToolCallRequest {
553 name: "grep".to_string(),
554 arguments: json!({ "q": "x" }),
555 tool_call_id: None,
556 progress_token: None,
557 call_key: Some("run-7:call-3".to_string()),
558 schema_pin: None,
559 preset: None,
560 origin: None,
561 output_refs: None,
562 };
563 let encoded = serde_json::to_value(&request).expect("encode");
564 assert_eq!(
565 encoded,
566 json!({ "name": "grep", "arguments": { "q": "x" }, "call_key": "run-7:call-3" })
567 );
568 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
569 assert_eq!(decoded, request);
570 }
571
572 #[test]
573 fn a_request_without_a_call_key_omits_the_member_and_round_trips() {
574 let request = ToolCallRequest::new("grep", json!({}));
575 let encoded = serde_json::to_value(&request).expect("encode");
576 assert!(encoded.get("call_key").is_none(), "{encoded}");
577 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
578 assert_eq!(decoded.call_key, None);
579 assert_eq!(decoded, request);
580 }
581
582 #[test]
585 fn opaque_field_bounds_are_one_to_256_printable_non_space_ascii() {
586 type Validate = fn(&str) -> Result<(), OpaqueFieldError>;
587 let validators: [(&str, Validate); 2] = [
588 (CALL_KEY_FIELD, validate_call_key),
589 (SCHEMA_PIN_FIELD, validate_schema_pin),
590 ];
591 for (field, validate) in validators {
592 assert_eq!(validate(""), Err(OpaqueFieldError::Empty { field }));
593 assert_eq!(validate("k"), Ok(()));
594 assert_eq!(validate(&"k".repeat(256)), Ok(()));
595 assert_eq!(
596 validate(&"k".repeat(257)),
597 Err(OpaqueFieldError::TooLong { field, length: 257 })
598 );
599 assert_eq!(validate("!~"), Ok(()), "both ends of 0x21..=0x7E");
600 for bad in ["ké", "a\tb", "a\u{7f}", "a b"] {
601 assert_eq!(
602 validate(bad),
603 Err(OpaqueFieldError::InvalidCharacter { field, index: 1 }),
604 "{field}: {bad:?}"
605 );
606 }
607 let error = validate("").unwrap_err();
608 assert_eq!(error.field(), field);
609 assert!(error.to_string().starts_with(field), "{error}");
610 }
611 }
612
613 #[test]
614 fn schema_pin_round_trips_as_a_top_level_member() {
615 let request = ToolCallRequest {
616 schema_pin: Some("sha256:0f1e2d".to_string()),
617 ..ToolCallRequest::new("grep", json!({ "q": "x" }))
618 };
619 let encoded = serde_json::to_value(&request).expect("encode");
620 assert_eq!(
621 encoded,
622 json!({ "name": "grep", "arguments": { "q": "x" }, "schema_pin": "sha256:0f1e2d" })
623 );
624 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
625 assert_eq!(decoded, request);
626 }
627
628 #[test]
629 fn preset_round_trips_outside_arguments_and_absence_keeps_the_bytes() {
630 let mut request = ToolCallRequest::new("grep", json!({ "q": "x" }));
631 let absent = serde_json::to_string(&request).unwrap();
632 assert_eq!(absent, r#"{"name":"grep","arguments":{"q":"x"}}"#);
633 let decoded: ToolCallRequest = serde_json::from_str(&absent).unwrap();
634 assert_eq!(decoded, request);
635 assert_eq!(decoded.preset, None);
636
637 request.preset = Some("read_only-2".to_string());
638 let encoded = serde_json::to_value(&request).unwrap();
639 assert_eq!(
640 encoded,
641 json!({
642 "name": "grep", "arguments": { "q": "x" }, "preset": "read_only-2"
643 })
644 );
645 assert_eq!(
646 serde_json::from_value::<ToolCallRequest>(encoded).unwrap(),
647 request
648 );
649 }
650
651 #[test]
652 fn preset_bounds_are_one_to_64_lowercase_digits_underscore_or_hyphen() {
653 assert_eq!(validate_preset(""), Err(PresetError::Empty));
654 assert_eq!(validate_preset("a"), Ok(()));
655 assert_eq!(validate_preset(&"a".repeat(64)), Ok(()));
656 assert_eq!(
657 validate_preset(&"a".repeat(65)),
658 Err(PresetError::TooLong { length: 65 })
659 );
660 assert_eq!(validate_preset("a0_-z9"), Ok(()));
661 for bad in ["A", ".", "é", " "] {
662 let error = validate_preset(bad).unwrap_err();
663 assert_eq!(error, PresetError::InvalidCharacter { index: 0 });
664 assert_eq!(error.field(), "preset");
665 assert!(error.to_string().starts_with("preset"));
666 let refusal =
667 crate::ErrorBody::new(crate::error_codes::INVALID_REQUEST, error.to_string())
668 .with_detail(json!({ "field": error.field() }));
669 assert_eq!(refusal.code, "invalid_request");
670 assert_eq!(refusal.detail.unwrap()["field"], "preset");
671 }
672 }
673
674 #[test]
675 fn a_request_without_a_schema_pin_omits_the_member_and_round_trips() {
676 let request = ToolCallRequest::new("grep", json!({}));
677 let encoded = serde_json::to_value(&request).expect("encode");
678 assert!(encoded.get("schema_pin").is_none(), "{encoded}");
679 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
680 assert_eq!(decoded.schema_pin, None);
681 assert_eq!(decoded, request);
682 }
683
684 #[test]
685 fn none_optionals_are_omitted_so_the_wire_matches_the_two_field_shape() {
686 let request = ToolCallRequest::new("grep", json!({ "q": "x" }));
687 let encoded = serde_json::to_value(&request).expect("encode");
688 assert_eq!(
689 encoded,
690 json!({ "name": "grep", "arguments": { "q": "x" } })
691 );
692 }
693
694 #[test]
695 fn tool_call_id_round_trips() {
696 let request = ToolCallRequest {
697 name: "grep".to_string(),
698 arguments: json!({ "q": "x" }),
699 tool_call_id: Some("wal-intent-42".to_string()),
700 progress_token: None,
701 call_key: None,
702 schema_pin: None,
703 preset: None,
704 origin: None,
705 output_refs: None,
706 };
707 let encoded = serde_json::to_value(&request).expect("encode");
708 assert_eq!(encoded["tool_call_id"], json!("wal-intent-42"));
709 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
710 assert_eq!(decoded, request);
711 }
712
713 #[test]
714 fn unknown_members_do_not_fail_a_provider_decode() {
715 let request: ToolCallRequest = serde_json::from_value(json!({
718 "name": "grep",
719 "arguments": {},
720 "some_future_key": { "nested": true }
721 }))
722 .expect("unknown members are tolerated");
723 assert_eq!(request.name, "grep");
724 }
725
726 fn relayed_origin() -> CallOrigin {
727 CallOrigin::new(
728 Principal::Reserved {
729 module_id: "broca".to_string(),
730 },
731 "broca:run-7/call-3",
732 )
733 }
734
735 #[test]
738 fn origin_round_trips_as_a_top_level_member_with_a_tagged_carrier() {
739 let request = ToolCallRequest {
740 call_key: Some("pf:relay/991".to_string()),
741 origin: Some(relayed_origin()),
742 ..ToolCallRequest::new("grep", json!({ "q": "x" }))
743 };
744 let encoded = serde_json::to_value(&request).expect("encode");
745 assert_eq!(
746 encoded,
747 json!({
748 "name": "grep",
749 "arguments": { "q": "x" },
750 "call_key": "pf:relay/991",
751 "origin": {
752 "carrier": { "kind": "reserved", "module_id": "broca" },
753 "call_key": "broca:run-7/call-3"
754 }
755 })
756 );
757 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
758 assert_eq!(decoded, request);
759 }
760
761 #[test]
764 fn message_position_round_trips_and_is_omitted_when_unknown() {
765 let origin = relayed_origin().with_message_position(MessagePosition::new("msg_01AbC", 2));
766 let encoded = serde_json::to_value(&origin).expect("encode");
767 assert_eq!(
768 encoded,
769 json!({
770 "carrier": { "kind": "reserved", "module_id": "broca" },
771 "call_key": "broca:run-7/call-3",
772 "message_position": { "message_id": "msg_01AbC", "index": 2 }
773 })
774 );
775 let decoded: CallOrigin = serde_json::from_value(encoded).expect("decode");
776 assert_eq!(decoded, origin);
777
778 let without = serde_json::to_value(relayed_origin()).expect("encode");
779 assert!(without.get("message_position").is_none(), "{without}");
780 let decoded: CallOrigin = serde_json::from_value(without).expect("decode");
781 assert_eq!(decoded.message_position, None);
782 }
783
784 #[test]
787 fn a_message_position_missing_either_member_does_not_decode() {
788 for position in [json!({ "index": 0 }), json!({ "message_id": "m" })] {
789 let body = json!({
790 "carrier": { "kind": "direct" },
791 "call_key": "k",
792 "message_position": position
793 });
794 assert!(
795 serde_json::from_value::<CallOrigin>(body.clone()).is_err(),
796 "{body}"
797 );
798 }
799 }
800
801 #[test]
804 fn unknown_members_inside_a_message_position_are_tolerated() {
805 let decoded: CallOrigin = serde_json::from_value(json!({
806 "carrier": { "kind": "direct" },
807 "call_key": "k",
808 "message_position": { "message_id": "m", "index": 4, "later": true }
809 }))
810 .expect("unknown members inside a position are tolerated");
811 assert_eq!(decoded.message_position, Some(MessagePosition::new("m", 4)));
812 }
813
814 #[test]
815 fn a_malformed_message_id_is_refused_by_its_field() {
816 for bad in [
817 String::new(),
818 "has space".to_string(),
819 "x".repeat(OPAQUE_FIELD_MAX_LEN + 1),
820 ] {
821 let origin = CallOrigin::new(Principal::Direct, "k")
822 .with_message_position(MessagePosition::new(bad.clone(), 0));
823 let error = validate_call_origin(&origin).expect_err(&bad);
824 assert_eq!(error.field(), ORIGIN_MESSAGE_ID_FIELD, "{bad:?}");
825 }
826 let good = CallOrigin::new(Principal::Direct, "k")
827 .with_message_position(MessagePosition::new("msg_01AbC", u32::MAX));
828 assert_eq!(validate_call_origin(&good), Ok(()));
829 }
830
831 #[test]
832 fn a_request_without_an_origin_omits_the_member_and_decodes_as_none() {
833 let request = ToolCallRequest::new("grep", json!({}));
834 let encoded = serde_json::to_value(&request).expect("encode");
835 assert!(encoded.get("origin").is_none(), "{encoded}");
836 let decoded: ToolCallRequest = serde_json::from_value(encoded).expect("decode");
837 assert_eq!(decoded.origin, None);
838 assert_eq!(decoded, request);
839 }
840
841 #[test]
842 fn a_request_with_an_origin_and_an_unknown_member_still_decodes() {
843 let request: ToolCallRequest = serde_json::from_value(json!({
844 "name": "grep",
845 "arguments": {},
846 "origin": {
847 "carrier": { "kind": "direct" },
848 "call_key": "k",
849 "some_future_origin_key": 1
850 },
851 "some_future_key": { "nested": true }
852 }))
853 .expect("unknown members are tolerated");
854 assert_eq!(
855 request.origin,
856 Some(CallOrigin::new(Principal::Direct, "k"))
857 );
858 }
859
860 #[test]
861 fn call_origin_key_refusals_name_the_origin_call_key_field() {
862 let carrier = Principal::Direct;
863 let field = ORIGIN_CALL_KEY_FIELD;
864 assert_eq!(field, "origin.call_key");
865 let cases = [
866 (String::new(), OpaqueFieldError::Empty { field }),
867 (
868 "k".repeat(257),
869 OpaqueFieldError::TooLong { field, length: 257 },
870 ),
871 (
872 "pf:relay 991".to_string(),
873 OpaqueFieldError::InvalidCharacter { field, index: 8 },
874 ),
875 ];
876 for (key, expected) in cases {
877 let error = validate_call_origin(&CallOrigin::new(carrier.clone(), key.clone()))
878 .expect_err("malformed origin key is refused");
879 assert_eq!(error, expected, "{key:?}");
880 assert_eq!(error.field(), "origin.call_key", "{key:?}");
881 }
882 }
883
884 #[test]
885 fn call_origin_schema_pin_is_optional_checked_and_omitted_when_absent() {
886 let plain = CallOrigin::new(Principal::Direct, "k");
887 let encoded = serde_json::to_value(&plain).expect("encode");
888 assert!(encoded.get("schema_pin").is_none(), "{encoded}");
889
890 let pinned = CallOrigin::new(Principal::Direct, "k").with_schema_pin("sha256:0f1e2d/1");
891 let encoded = serde_json::to_value(&pinned).expect("encode");
892 assert_eq!(encoded["schema_pin"], "sha256:0f1e2d/1");
893 let decoded: CallOrigin = serde_json::from_value(encoded).expect("decode");
894 assert_eq!(decoded, pinned);
895 assert_eq!(validate_call_origin(&pinned), Ok(()));
896
897 for bad in [
898 String::new(),
899 "has space".to_string(),
900 "x".repeat(OPAQUE_FIELD_MAX_LEN + 1),
901 ] {
902 let error = validate_call_origin(
903 &CallOrigin::new(Principal::Direct, "k").with_schema_pin(bad.clone()),
904 )
905 .expect_err(&bad);
906 assert_eq!(error.field(), ORIGIN_SCHEMA_PIN_FIELD, "{bad:?}");
907 }
908 }
909
910 #[test]
911 fn call_origin_accepts_every_carrier_kind() {
912 let carriers = [
913 Principal::Reserved {
914 module_id: "prefrontal-core".to_string(),
915 },
916 Principal::Direct,
917 Principal::Unverified,
918 ];
919 for carrier in carriers {
920 assert_eq!(
921 validate_call_origin(&CallOrigin::new(carrier.clone(), "pf:relay/991")),
922 Ok(()),
923 "{carrier:?}"
924 );
925 }
926 }
927}