Prompt and context facade modules, fragments, and embedded instruction templates

fn new() -> Self

Purpose: Creates a registration proxy for a particular fragment type. The proxy carries no real data; it exists so code can ask whether some text matches that fragment type without constructing an actual fragment.

Data flow: Nothing meaningful goes in. The function returns a tiny marker object that remembers the fragment type at compile time, but stores no runtime payload.

Call relations: This is the basic constructor for the proxy. When code needs a default proxy, FragmentRegistrationProxy::default simply delegates to this function instead of building the object another way.

fn default() -> Self

Purpose: Provides the standard default value for a fragment registration proxy. This lets other code create the proxy using Rust’s normal default-value pattern.

Data flow: Nothing goes in. It calls the proxy constructor and returns the same empty, type-tagged registration object.

Call relations: This is a convenience wrapper around FragmentRegistrationProxy::new. It matters when generic setup code expects a type to know how to make its own default instance.

Call graph: 1 external calls (new).

fn matches_text(&self, text: &str) -> bool

Purpose: Checks whether a piece of text looks like the fragment type represented by this proxy. It lets context filtering code identify injected fragments without building the full fragment object.

Data flow: It receives a text string. It passes that text to the fragment type’s own matching rule, then returns true or false depending on whether the text has that fragment’s markers.

Call relations: This is the bridge from the type-erased FragmentRegistration interface back to a concrete ContextualUserFragment type. Filtering code can hold registrations uniformly, and this method forwards the real decision to the fragment type.

Call graph: 1 external calls (matches_text).

fn matches_text(text: &str) -> bool

Purpose: Provides the default way for a fragment type to recognize text that it previously injected. It uses the type’s start and end markers as the identifying label.

Data flow: It receives text to inspect. It asks the fragment type for its markers, then sends those markers and the text to matches_marked_text. The result is a true-or-false answer.

Call relations: This is the default matching rule used by FragmentRegistrationProxy::matches_text. It hands off the low-level string checking to matches_marked_text, so each fragment type only needs to define its markers.

Call graph: calls 1 internal fn (matches_marked_text); 1 external calls (type_markers).

fn render(&self) -> String

Purpose: Builds the exact text that will be placed into the conversation for this fragment. It wraps the body with markers when markers are present.

Data flow: It reads the fragment’s markers and body. If both markers are empty, it returns just the body. Otherwise, it returns one combined string: start marker, body, then end marker, with no extra spaces added.

Call relations: The conversion methods call this when they package a fragment into protocol message objects. Fragment implementations must include any needed whitespace in their body because this method intentionally does not insert separators.

Call graph: 1 external calls (format!).

fn into(self) -> ResponseItem

Purpose: Turns a fragment into a full ResponseItem message, which is one of the protocol objects used to represent conversation history or model-facing messages. This is the common path for recording injected context as a message item.

Data flow: It takes ownership of the fragment. It reads the fragment’s role, renders its text, wraps that text as input text content, and returns a ResponseItem::Message with empty optional fields such as id, phase, and metadata.

Call relations: Many higher-level flows use this when they need to add a concrete context fragment to the conversation, such as environment updates, policy amendment records, image-related history messages, token budget reminders, and rollout sampling. This function is the packaging step that turns domain-specific context into the shared protocol shape.

Call graph: called by 11 (build_environment_update_item, append_guardian_followup_reminder, record_execpolicy_amendment_message, record_network_policy_amendment_message, handle_output_item_done_records_image_save_history_message, sample_rollout, maybe_record_token_budget_remaining_context, record_image_generation_instructions, interrupted_turn_history_marker, user_shell_command_record_item (+1 more)); 1 external calls (vec!).

fn into_boxed_response_item(self: Box<Self>) -> ResponseItem

Purpose: Turns a boxed fragment into a full ResponseItem message. A boxed fragment is one stored behind a pointer-like wrapper, often used when code wants to work with different fragment types through the same interface.

Data flow: It takes ownership of the boxed fragment. It reads the role, renders the text, wraps the rendered text as input text content, and returns a ResponseItem::Message with the standard empty optional fields.

Call relations: This mirrors ContextualUserFragment::into, but works when the fragment is held as a boxed trait object rather than as a known concrete type. It lets more flexible orchestration code still produce the same protocol message format.

Call graph: 1 external calls (vec!).

fn into_response_input_item(self) -> ResponseInputItem

Purpose: Turns a fragment into a ResponseInputItem, another protocol message shape used when preparing input for a response. It is for sending the fragment forward as input rather than storing it as a response-history item.

Data flow: It takes ownership of the fragment. It reads the role, renders the fragment text, wraps that text as input text content, and returns a ResponseInputItem::Message with no phase set.

Call relations: This is the sibling of the ResponseItem conversion methods. When a caller needs the input-message version of a contextual fragment, this method performs the same rendering and wrapping in the protocol type expected by that path.

Call graph: 1 external calls (vec!).

fn matches_marked_text(start_marker: &str, end_marker: &str, text: &str) -> bool

Purpose: Checks whether a text string is wrapped in a given start marker and end marker. This is the shared safety check that prevents ordinary text from being mistaken for injected context.

Data flow: It receives a start marker, an end marker, and the text to inspect. If either marker is empty, it immediately returns false. Otherwise, it ignores extra whitespace at the outside, checks whether the text begins with the start marker and ends with the end marker, compares marker letters without caring about case, and returns true only if both checks pass.

Call relations: This is called by ContextualUserFragment::matches_text, which supplies the markers for a particular fragment type. Keeping the marker logic here means all fragment types follow the same recognition rules.

Call graph: called by 1 (matches_text).

fn new(slot: PromptSlot, text: impl Into<String>) -> Self

Purpose: Creates a new prompt fragment from a destination slot and some text. This is the basic constructor used when the caller already knows exactly where the text should be placed.

Data flow: It takes a PromptSlot and text that can be turned into a String. It converts the text into owned stored text, pairs it with the slot, and returns a new PromptFragment. Nothing outside the new object is changed.

Call relations: This is the central builder for the type. The more specific helper functions, such as PromptFragment::developer_policy, PromptFragment::developer_capability, and PromptFragment::separate_developer, call it so they all create fragments in the same consistent way.

Call graph: 1 external calls (into).

fn developer_policy(text: impl Into<String>) -> Self

Purpose: Creates a prompt fragment meant for developer policy text. This gives callers a clear, readable way to mark text as policy-level developer guidance.

Data flow: It takes text from the caller, chooses the DeveloperPolicy slot for it, and passes both pieces to PromptFragment::new. The result is a PromptFragment whose text is stored and whose slot says it belongs in the developer policy area.

Call relations: This is a convenience wrapper around PromptFragment::new. Code that wants to contribute developer policy text can call this instead of manually selecting the PromptSlot::DeveloperPolicy value.

Call graph: 1 external calls (new).

fn developer_capability(text: impl Into<String>) -> Self

Purpose: Creates a prompt fragment that describes developer capabilities. This is useful when an extension needs to tell the model what tools, behaviors, or abilities are available in the developer context.

Data flow: It receives text, attaches the DeveloperCapabilities slot to it, and delegates the actual object creation to PromptFragment::new. It returns the completed PromptFragment.

Call relations: This function sits above PromptFragment::new as a named shortcut. It helps calling code express intent directly: the text is not just any prompt text, it belongs in the developer capabilities section.

Call graph: 1 external calls (new).

fn separate_developer(text: impl Into<String>) -> Self

Purpose: Creates a prompt fragment meant to become a separate top-level developer prompt. This is for developer text that should stay separate rather than being merged into another developer section.

Data flow: It takes caller-provided text, assigns it the SeparateDeveloper slot, and sends both to PromptFragment::new. The returned fragment carries both the chosen slot and the stored text.

Call relations: Like the other named constructors, it relies on PromptFragment::new for the actual creation work. It gives prompt-building callers a clear way to request a separate developer message.

Call graph: 1 external calls (new).

fn slot(&self) -> PromptSlot

Purpose: Returns the slot label for this prompt fragment. Code uses this to find out where the fragment should be placed when building the final prompt.

Data flow: It reads the fragment's stored PromptSlot and returns a copy of it. The fragment itself is not changed.

Call relations: Later prompt assembly code can call this after receiving a PromptFragment to decide which part of the final prompt should receive the fragment's text.

fn text(&self) -> &str

Purpose: Returns the text stored inside this prompt fragment. This lets prompt assembly code read the model-visible content without taking ownership of it or modifying it.

Data flow: It reads the fragment's stored String and returns it as a string slice, which is a borrowed view of the text. The original PromptFragment keeps owning the text.

Call relations: After code has used PromptFragment::slot to decide where the fragment belongs, it can call PromptFragment::text to copy or insert the actual text into the final prompt.