Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
SKY-9976 Add mode-aware turn context assembler (#6064)
Andrew Neilson3353a84c1b50
diff --git a/skyvern/forge/sdk/copilot/agent.py b/skyvern/forge/sdk/copilot/agent.pyindex 8c76e7e66..4a46129aa 100644--- a/skyvern/forge/sdk/copilot/agent.py+++ b/skyvern/forge/sdk/copilot/agent.py@@ -53,6 +53,7 @@ from skyvern.forge.sdk.copilot.output_utils import ()from skyvern.forge.sdk.copilot.request_policy import RequestPolicy, build_request_policy, redact_raw_secrets_for_promptfrom skyvern.forge.sdk.copilot.tracing_setup import _copilot_model_name, ensure_tracing_initialized, is_tracing_enabled+from skyvern.forge.sdk.copilot.turn_context import TurnContextAssembler, TurnContextInputs, TurnContextPacketfrom skyvern.forge.sdk.copilot.turn_intent import TurnIntent, build_turn_intentfrom skyvern.forge.sdk.schemas.persistent_browser_sessions import is_final_statusfrom skyvern.forge.sdk.schemas.workflow_copilot import (@@ -300,6 +301,38 @@ def _turn_intent_trace_fields(intent: TurnIntent | None) -> dict[str, str]:return {key: str(value) for key, value in _turn_intent_log_fields(intent).items()}+def _turn_context_log_fields(packet: TurnContextPacket | None) -> dict[str, Any]:+ if not isinstance(packet, TurnContextPacket):+ return {}+ return {f"turn_context_{key}": value for key, value in packet.to_trace_data().items()}+++def _turn_context_trace_fields(packet: TurnContextPacket | None) -> dict[str, str]:+ return {key: str(value) for key, value in _turn_context_log_fields(packet).items()}+++def _store_turn_context_packet_on_context(+ ctx: CopilotContext,+ *,+ request_policy: RequestPolicy,+ chat_request: WorkflowCopilotChatRequest,+ chat_history: list[WorkflowCopilotChatHistoryMessage],+ debug_run_info_text: str,+) -> None:+ if not isinstance(ctx.turn_intent, TurnIntent):+ return+ ctx.turn_context_packet = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=ctx.turn_intent,+ request_policy=request_policy,+ user_message=chat_request.message,+ workflow_yaml=chat_request.workflow_yaml or "",+ chat_history=chat_history,+ debug_run_info_text=debug_run_info_text,+ )+ )++def _build_system_prompt(tool_usage_guide: str,config: CopilotConfig | None = None,@@ -1434,6 +1467,14 @@ async def _run_copilot_turn_impl(RunContextWrapper(context=ctx),)request_policy = ctx.request_policy if isinstance(ctx.request_policy, RequestPolicy) else None+ if request_policy is not None:+ _store_turn_context_packet_on_context(+ ctx,+ request_policy=request_policy,+ chat_request=chat_request,+ chat_history=chat_history,+ debug_run_info_text=debug_run_info_text,+ )if request_policy is not None and request_policy_guardrail_result.output.tripwire_triggered:return _build_request_policy_clarification_result(request_policy,@@ -1535,6 +1576,7 @@ async def _run_copilot_turn_impl("user_message_len": str(len(user_message)),**{f"request_policy_{key}": str(value) for key, value in request_policy.to_trace_data().items()},**_turn_intent_trace_fields(ctx.turn_intent),+ **_turn_context_trace_fields(ctx.turn_context_packet),},)diff --git a/skyvern/forge/sdk/copilot/context.py b/skyvern/forge/sdk/copilot/context.pyindex 48ba0ea2b..7919d1b49 100644--- a/skyvern/forge/sdk/copilot/context.py+++ b/skyvern/forge/sdk/copilot/context.py@@ -17,6 +17,7 @@ COPILOT_RESPONSE_TYPES: tuple[ResponseType, ...] = get_args(ResponseType)if TYPE_CHECKING:from skyvern.forge.sdk.copilot.narration import NarratorStatefrom skyvern.forge.sdk.copilot.request_policy import RequestPolicy+ from skyvern.forge.sdk.copilot.turn_context import TurnContextPacketfrom skyvern.forge.sdk.copilot.turn_intent import TurnIntent@@ -169,6 +170,7 @@ class CopilotContext(AgentContext):allow_untested_workflow_draft: bool = Falserequest_policy: RequestPolicy | None = Noneturn_intent: TurnIntent | None = None+ turn_context_packet: TurnContextPacket | None = None# Tool trackingconsecutive_tool_tracker: list[str] = field(default_factory=list)diff --git a/skyvern/forge/sdk/copilot/request_policy.py b/skyvern/forge/sdk/copilot/request_policy.pyindex 97abb7835..bc7325485 100644--- a/skyvern/forge/sdk/copilot/request_policy.py+++ b/skyvern/forge/sdk/copilot/request_policy.py@@ -190,7 +190,7 @@ def _safe_slot(text: str | None, cap: int) -> str:return _middle_truncate(escape_code_fences(redact_raw_secrets_for_prompt(bounded)), cap)-def _build_transcript_context(+def build_transcript_context(messages: list[WorkflowCopilotChatHistoryMessage],current_user_message: str,*,@@ -407,7 +407,7 @@ async def _classify_request(if handler is None:return RequestPolicy(credential_input_kind="credential_id" if ids else "none", credential_refs=ids)- transcript = _build_transcript_context(chat_history, user_message)+ transcript = build_transcript_context(chat_history, user_message)prompt = prompt_engine.load_prompt(template=PROMPT_NAME,user_message=escape_code_fences(user_message),diff --git a/skyvern/forge/sdk/copilot/turn_context.py b/skyvern/forge/sdk/copilot/turn_context.pynew file mode 100644index 000000000..d4fadc4ec--- /dev/null+++ b/skyvern/forge/sdk/copilot/turn_context.py@@ -0,0 +1,319 @@+from __future__ import annotations++from typing import Any, Literal++import structlog+from pydantic import BaseModel, ConfigDict, Field++from skyvern.forge.sdk.copilot.request_policy import (+ RequestPolicy,+ build_transcript_context,+ redact_raw_secrets_for_prompt,+)+from skyvern.forge.sdk.copilot.turn_intent import RequiredContextKey, TurnIntent, TurnIntentMode+from skyvern.forge.sdk.schemas.credentials import Credential+from skyvern.forge.sdk.schemas.workflow_copilot import WorkflowCopilotChatHistoryMessage, WorkflowCopilotChatSender++LOG = structlog.get_logger()++_WORKFLOW_MODES = {+ TurnIntentMode.BUILD,+ TurnIntentMode.EDIT,+ TurnIntentMode.DIAGNOSE,+ TurnIntentMode.DRAFT_ONLY,+ TurnIntentMode.CLARIFY,+}+_RUN_MODES = {TurnIntentMode.DIAGNOSE} # Additional run-evidence modes can join here.+++class TurnContextOmission(BaseModel):+ context_key: RequiredContextKey+ reason: Literal["unavailable", "truncated_to_budget", "not_implemented"]+ required: bool = True+ detail: str = ""+++class WorkflowContext(BaseModel):+ yaml: str+ source: Literal["current", "proposed"] = "current"+ original_chars: int+ truncated: bool = False+++class ProposalContext(BaseModel):+ latest_assistant_proposal: str+ original_chars: int+ truncated: bool = False+++class TranscriptContext(BaseModel):+ earliest_user_turn: str+ latest_prior_user_turn: str+ latest_assistant_turn: str+ retained_history: str+ omitted_any: bool+++class RunContext(BaseModel):+ summary: str+ original_chars: int+ truncated: bool = False+++class CredentialMetadata(BaseModel):+ credential_id: str+ name: str+ credential_type: str+ vault_type: str | None = None+ tested_url: str | None = None+ browser_profile_id: str | None = None+++class CredentialContext(BaseModel):+ requested_refs: list[str] = Field(default_factory=list)+ invalid_credential_ids: list[str] = Field(default_factory=list)+ credentials: list[CredentialMetadata] = Field(default_factory=list)+ omitted_credential_count: int = 0+++class DocsContext(BaseModel):+ # v1 placeholder; reserves a typed slot for future docs retrieval output.+ status: Literal["empty_hook"] = "empty_hook"+++class TurnContextPacket(BaseModel):+ turn_intent_summary: dict[str, Any]+ workflow_context: WorkflowContext | None = None+ proposal_context: ProposalContext | None = None+ transcript_context: TranscriptContext+ run_context: RunContext | None = None+ credential_context: CredentialContext | None = None+ docs_context: DocsContext | None = None+ omissions: list[TurnContextOmission] = Field(default_factory=list)++ def to_trace_data(self) -> dict[str, Any]:+ section_fields = ("workflow_context", "proposal_context", "run_context", "credential_context", "docs_context")+ return {+ "mode": self.turn_intent_summary.get("mode"),+ "sections": [field for field in section_fields if getattr(self, field) is not None],+ "omissions": [omission.context_key.value for omission in self.omissions],+ "omission_reasons": [omission.reason for omission in self.omissions],+ "workflow_truncated": bool(self.workflow_context and self.workflow_context.truncated),+ "proposal_truncated": bool(self.proposal_context and self.proposal_context.truncated),+ "run_truncated": bool(self.run_context and self.run_context.truncated),+ }+++class TurnContextInputs(BaseModel):+ model_config = ConfigDict(arbitrary_types_allowed=True, extra="forbid")++ turn_intent: TurnIntent+ request_policy: RequestPolicy+ user_message: str = ""+ workflow_yaml: str = ""+ chat_history: list[WorkflowCopilotChatHistoryMessage] = Field(default_factory=list)+ debug_run_info_text: str = ""+++def _dedupe_nonempty(values: list[str]) -> list[str]:+ return list(dict.fromkeys(value for value in values if value))+++def _bounded_text(value: str, char_budget: int) -> tuple[str, int, bool]:+ redacted = redact_raw_secrets_for_prompt(value or "")+ original_chars = len(redacted)+ if original_chars <= char_budget:+ return redacted, original_chars, False+ suffix = "...<truncated>"+ if char_budget <= len(suffix):+ return redacted[:char_budget], original_chars, True+ return redacted[: char_budget - len(suffix)].rstrip() + suffix, original_chars, True+++def _latest_assistant_turn(chat_history: list[WorkflowCopilotChatHistoryMessage]) -> str:+ for message in reversed(chat_history):+ if message.sender == WorkflowCopilotChatSender.AI and (message.content or "").strip():+ return message.content+ return ""+++def _safe_credential_metadata(credential: Credential) -> CredentialMetadata:+ return CredentialMetadata(+ credential_id=credential.credential_id,+ name=credential.name,+ credential_type=str(credential.credential_type),+ vault_type=str(credential.vault_type) if credential.vault_type else None,+ tested_url=credential.tested_url,+ browser_profile_id=credential.browser_profile_id,+ )+++class TurnContextAssembler:+ def __init__(+ self,+ *,+ workflow_char_budget: int = 12_000,+ proposal_char_budget: int = 2_000,+ run_char_budget: int = 4_000,+ credential_count_budget: int = 20,+ ) -> None:+ self.workflow_char_budget = workflow_char_budget+ self.proposal_char_budget = proposal_char_budget+ self.run_char_budget = run_char_budget+ self.credential_count_budget = credential_count_budget++ def assemble(self, inputs: TurnContextInputs) -> TurnContextPacket:+ required = set(inputs.turn_intent.required_context)+ omissions: list[TurnContextOmission] = []+ transcript = build_transcript_context(inputs.chat_history, inputs.user_message)+ transcript_context = TranscriptContext(+ earliest_user_turn=transcript.earliest_user_turn,+ latest_prior_user_turn=transcript.latest_prior_user_turn,+ latest_assistant_turn=transcript.latest_assistant_turn,+ retained_history=transcript.retained_history,+ omitted_any=transcript.omitted_any,+ )++ workflow_context: WorkflowContext | None = None+ proposal_context: ProposalContext | None = None+ run_context: RunContext | None = None+ credential_context: CredentialContext | None = None+ docs_context: DocsContext | None = None++ if self._should_include_workflow(inputs.turn_intent, required):+ workflow_key = (+ RequiredContextKey.PROPOSED_WORKFLOW+ if RequiredContextKey.PROPOSED_WORKFLOW in required+ else RequiredContextKey.CURRENT_WORKFLOW+ )+ if inputs.workflow_yaml.strip():+ yaml_text, original_chars, truncated = _bounded_text(inputs.workflow_yaml, self.workflow_char_budget)+ # The caller controls whether this is current or proposed workflow YAML.+ workflow_context = WorkflowContext(+ yaml=yaml_text,+ source="proposed" if workflow_key == RequiredContextKey.PROPOSED_WORKFLOW else "current",+ original_chars=original_chars,+ truncated=truncated,+ )+ if truncated:+ omissions.append(+ TurnContextOmission(+ context_key=workflow_key,+ reason="truncated_to_budget",+ detail=f"workflow_yaml exceeded {self.workflow_char_budget} chars",+ )+ )+ elif workflow_key in required:+ omissions.append(TurnContextOmission(context_key=workflow_key, reason="unavailable"))++ if RequiredContextKey.LATEST_ASSISTANT_PROPOSAL in required:+ latest_proposal = _latest_assistant_turn(inputs.chat_history)+ if latest_proposal:+ proposal, original_chars, truncated = _bounded_text(latest_proposal, self.proposal_char_budget)+ proposal_context = ProposalContext(+ latest_assistant_proposal=proposal,+ original_chars=original_chars,+ truncated=truncated,+ )+ if truncated:+ omissions.append(+ TurnContextOmission(+ context_key=RequiredContextKey.LATEST_ASSISTANT_PROPOSAL,+ reason="truncated_to_budget",+ detail=f"latest assistant proposal exceeded {self.proposal_char_budget} chars",+ )+ )+ else:+ omissions.append(+ TurnContextOmission(+ context_key=RequiredContextKey.LATEST_ASSISTANT_PROPOSAL,+ reason="unavailable",+ )+ )++ if self._should_include_run_context(inputs.turn_intent, required):+ if inputs.debug_run_info_text.strip():+ summary, original_chars, truncated = _bounded_text(inputs.debug_run_info_text, self.run_char_budget)+ run_context = RunContext(summary=summary, original_chars=original_chars, truncated=truncated)+ if truncated:+ omissions.append(+ TurnContextOmission(+ context_key=RequiredContextKey.LATEST_RUN_RESULT,+ reason="truncated_to_budget",+ detail=f"run context exceeded {self.run_char_budget} chars",+ )+ )+ elif RequiredContextKey.LATEST_RUN_RESULT in required:+ omissions.append(+ TurnContextOmission(context_key=RequiredContextKey.LATEST_RUN_RESULT, reason="unavailable")+ )++ if RequiredContextKey.CREDENTIAL_METADATA in required:+ credential_context, credential_omissions = self._credential_context(inputs.request_policy)+ omissions.extend(credential_omissions)++ if RequiredContextKey.DOCS_CONTEXT in required:+ docs_context = DocsContext()++ if RequiredContextKey.BROWSER_STATE in required:+ omissions.append(+ TurnContextOmission(+ context_key=RequiredContextKey.BROWSER_STATE,+ reason="not_implemented",+ detail="browser state context packet section is reserved for a future assembler revision",+ )+ )++ packet = TurnContextPacket(+ turn_intent_summary=inputs.turn_intent.to_trace_data(),+ workflow_context=workflow_context,+ proposal_context=proposal_context,+ transcript_context=transcript_context,+ run_context=run_context,+ credential_context=credential_context,+ docs_context=docs_context,+ omissions=omissions,+ )++ LOG.info(+ "assembled copilot turn context packet",+ **{f"turn_context_{key}": value for key, value in packet.to_trace_data().items()},+ )+ return packet++ def _should_include_workflow(self, intent: TurnIntent, required: set[RequiredContextKey]) -> bool:+ if intent.mode == TurnIntentMode.DOCS_ANSWER:+ return False+ # Edit-capable turns still need workflow context even when the shadow classifier+ # did not include a specific workflow key yet.+ return bool(required & {RequiredContextKey.CURRENT_WORKFLOW, RequiredContextKey.PROPOSED_WORKFLOW}) or (+ intent.mode in _WORKFLOW_MODES and intent.authority.may_update_workflow+ )++ def _should_include_run_context(self, intent: TurnIntent, required: set[RequiredContextKey]) -> bool:+ if intent.mode == TurnIntentMode.DOCS_ANSWER:+ return False+ return RequiredContextKey.LATEST_RUN_RESULT in required or intent.mode in _RUN_MODES++ def _credential_context(self, request_policy: RequestPolicy) -> tuple[CredentialContext, list[TurnContextOmission]]:+ omissions: list[TurnContextOmission] = []+ credentials = request_policy.resolved_credentials[: self.credential_count_budget]+ omitted_count = max(len(request_policy.resolved_credentials) - len(credentials), 0)+ if omitted_count:+ omissions.append(+ TurnContextOmission(+ context_key=RequiredContextKey.CREDENTIAL_METADATA,+ reason="truncated_to_budget",+ detail=f"{omitted_count} credential metadata entries omitted",+ )+ )+ if not request_policy.resolved_credentials and not request_policy.credential_refs:+ omissions.append(+ TurnContextOmission(context_key=RequiredContextKey.CREDENTIAL_METADATA, reason="unavailable")+ )+ return CredentialContext(+ requested_refs=_dedupe_nonempty(request_policy.credential_refs),+ invalid_credential_ids=_dedupe_nonempty(request_policy.invalid_credential_ids),+ credentials=[_safe_credential_metadata(credential) for credential in credentials],+ omitted_credential_count=omitted_count,+ ), omissionsdiff --git a/tests/unit/test_copilot_agent_helpers.py b/tests/unit/test_copilot_agent_helpers.pyindex a3a6089b8..6348c9e6f 100644--- a/tests/unit/test_copilot_agent_helpers.py+++ b/tests/unit/test_copilot_agent_helpers.py@@ -13,8 +13,8 @@ from skyvern.forge.sdk.copilot import agent as agent_modulefrom skyvern.forge.sdk.copilot.config import CopilotConfigfrom skyvern.forge.sdk.copilot.request_policy import (TRANSCRIPT_ANCHOR_CHAR_CAP,- _build_transcript_context,_classify_request,+ build_transcript_context,)from skyvern.forge.sdk.schemas.workflow_copilot import (WorkflowCopilotChatHistoryMessage,@@ -2091,7 +2091,7 @@ class TestCopilotConfig:class TestRequestPolicyTranscriptContext:def test_empty_history_produces_sentinel_slots(self) -> None:- transcript = _build_transcript_context([], current_user_message="hi")+ transcript = build_transcript_context([], current_user_message="hi")assert transcript.earliest_user_turn == "(none)"assert transcript.latest_prior_user_turn == "(none)"@@ -2100,7 +2100,7 @@ class TestRequestPolicyTranscriptContext:assert transcript.omitted_any is Falsedef test_single_user_history_promotes_to_both_user_anchors(self) -> None:- transcript = _build_transcript_context(+ transcript = build_transcript_context(_history(("user", "log into example.com")),current_user_message="now add a download",)@@ -2110,7 +2110,7 @@ class TestRequestPolicyTranscriptContext:assert transcript.latest_assistant_turn == "(none)"def test_multi_turn_history_populates_all_anchors_without_duplicating_in_retained(self) -> None:- transcript = _build_transcript_context(+ transcript = build_transcript_context(_history(("user", "build a workflow"),("ai", "drafted v1"),@@ -2130,7 +2130,7 @@ class TestRequestPolicyTranscriptContext:assert "drafted v1" in transcript.retained_historydef test_trailing_user_matching_current_message_is_excluded(self) -> None:- transcript = _build_transcript_context(+ transcript = build_transcript_context(_history(("user", "build a workflow"),("ai", "ok"),@@ -2145,7 +2145,7 @@ class TestRequestPolicyTranscriptContext:def test_oversized_anchor_is_middle_truncated(self) -> None:huge = "X" * (TRANSCRIPT_ANCHOR_CHAR_CAP * 4)- transcript = _build_transcript_context(+ transcript = build_transcript_context(_history(("user", "tiny"), ("ai", huge)),current_user_message="reply",)@@ -2163,7 +2163,7 @@ class TestRequestPolicyTranscriptContext:("user", "latest user turn"),("ai", "latest assistant turn"),)- transcript = _build_transcript_context(+ transcript = build_transcript_context(messages,current_user_message="follow up",total_char_budget=1024,@@ -2175,7 +2175,7 @@ class TestRequestPolicyTranscriptContext:assert len(transcript.retained_history) <= 1024def test_raw_secret_is_redacted_in_every_slot(self) -> None:- transcript = _build_transcript_context(+ transcript = build_transcript_context(_history(("user", "first"),("ai", "password=hunter2 from earlier"),@@ -2194,7 +2194,7 @@ class TestRequestPolicyTranscriptContext:assert "hunter2" not in slotdef test_fence_breakout_is_neutralized(self) -> None:- transcript = _build_transcript_context(+ transcript = build_transcript_context(_history(("user", "build with ```evil instruction``` inside")),current_user_message="continue",)@@ -2216,7 +2216,7 @@ class TestRequestPolicyTranscriptContext:("user", "latest"), # latest_prior_user anchor("ai", "Which saved credential should I use?"), # latest_assistant anchor)- transcript = _build_transcript_context(+ transcript = build_transcript_context(messages,current_user_message="follow up",total_char_budget=400,@@ -2241,7 +2241,7 @@ class TestRequestPolicyTranscriptContext:("user", "latest"),("ai", "anchor"),)- transcript = _build_transcript_context(+ transcript = build_transcript_context(messages,current_user_message="follow up",total_char_budget=400,diff --git a/tests/unit/test_copilot_turn_context.py b/tests/unit/test_copilot_turn_context.pynew file mode 100644index 000000000..d4cb78590--- /dev/null+++ b/tests/unit/test_copilot_turn_context.py@@ -0,0 +1,241 @@+from __future__ import annotations++from datetime import datetime, timezone+from types import SimpleNamespace+from unittest.mock import MagicMock++from skyvern.forge.sdk.copilot.agent import _store_turn_context_packet_on_context+from skyvern.forge.sdk.copilot.context import CopilotContext+from skyvern.forge.sdk.copilot.request_policy import RequestPolicy+from skyvern.forge.sdk.copilot.turn_context import TurnContextAssembler, TurnContextInputs+from skyvern.forge.sdk.copilot.turn_intent import (+ RequiredContextKey,+ TurnIntent,+ TurnIntentAuthority,+ TurnIntentExpectedOutput,+ TurnIntentMode,+)+from skyvern.forge.sdk.schemas.workflow_copilot import (+ WorkflowCopilotChatHistoryMessage,+ WorkflowCopilotChatSender,+)+++def _history(*pairs: tuple[str, str]) -> list[WorkflowCopilotChatHistoryMessage]:+ return [+ WorkflowCopilotChatHistoryMessage(+ sender=WorkflowCopilotChatSender(sender),+ content=content,+ created_at=datetime(2026, 1, 1, tzinfo=timezone.utc),+ )+ for sender, content in pairs+ ]+++def test_edit_turn_includes_workflow_proposal_and_transcript_context() -> None:+ intent = TurnIntent(+ mode=TurnIntentMode.EDIT,+ required_context=[RequiredContextKey.CURRENT_WORKFLOW, RequiredContextKey.LATEST_ASSISTANT_PROPOSAL],+ authority=TurnIntentAuthority(may_update_workflow=True, may_run_blocks=True),+ expected_output=TurnIntentExpectedOutput.WORKFLOW_UPDATE,+ )++ packet = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=intent,+ request_policy=RequestPolicy(),+ user_message="Update the first block",+ workflow_yaml="workflow_definition:\n blocks: []",+ chat_history=_history(("user", "Build a workflow"), ("ai", "Drafted v1")),+ )+ )++ assert packet.workflow_context is not None+ assert packet.workflow_context.yaml == "workflow_definition:\n blocks: []"+ assert packet.proposal_context is not None+ assert packet.proposal_context.latest_assistant_proposal == "Drafted v1"+ assert packet.transcript_context.latest_assistant_turn == "Drafted v1"+ assert packet.omissions == []+++def test_diagnose_turn_includes_run_context_or_reports_missing() -> None:+ available = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.DIAGNOSE,+ required_context=[RequiredContextKey.LATEST_RUN_RESULT],+ expected_output=TurnIntentExpectedOutput.RUN_RESULT,+ ),+ request_policy=RequestPolicy(),+ user_message="Why did the run fail?",+ debug_run_info_text="Block Label: block_1\nFailure Reason: timeout",+ )+ )+ missing = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.DIAGNOSE,+ required_context=[RequiredContextKey.LATEST_RUN_RESULT],+ expected_output=TurnIntentExpectedOutput.RUN_RESULT,+ ),+ request_policy=RequestPolicy(),+ user_message="Diagnose the failure",+ )+ )++ assert available.run_context is not None+ assert "Failure Reason: timeout" in available.run_context.summary+ assert available.omissions == []+ assert missing.run_context is None+ assert missing.omissions[0].context_key == RequiredContextKey.LATEST_RUN_RESULT+ assert missing.omissions[0].reason == "unavailable"+++def test_raw_secrets_are_redacted_across_context_packet() -> None:+ packet = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.EDIT,+ required_context=[+ RequiredContextKey.CURRENT_WORKFLOW,+ RequiredContextKey.LATEST_ASSISTANT_PROPOSAL,+ RequiredContextKey.LATEST_RUN_RESULT,+ ],+ ),+ request_policy=RequestPolicy(),+ user_message="Use password: hunter2",+ workflow_yaml="navigation_goal: use password=hunter2 and token=sk-abcdefghijklmnopqrstuvwxyz1234567890",+ chat_history=_history(("ai", "The password=hunter2 failed")),+ debug_run_info_text="Failure includes password=hunter2",+ )+ )++ dumped = packet.model_dump_json()+ assert "hunter2" not in dumped+ assert "sk-abcdefghijklmnopqrstuvwxyz" not in dumped+ assert "[REDACTED_SECRET]" in dumped+++def test_docs_answer_turn_does_not_pull_workflow_or_run_context() -> None:+ packet = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.DOCS_ANSWER,+ required_context=[RequiredContextKey.DOCS_CONTEXT],+ ),+ request_policy=RequestPolicy(),+ user_message="What is a loop block?",+ workflow_yaml="workflow_definition:\n blocks:\n - label: block_1",+ debug_run_info_text="Failure Reason: hidden",+ )+ )++ assert packet.docs_context is not None+ assert packet.workflow_context is None+ assert packet.run_context is None+++def test_browser_state_required_context_reports_not_implemented_omission() -> None:+ packet = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.EDIT,+ required_context=[RequiredContextKey.CURRENT_WORKFLOW, RequiredContextKey.BROWSER_STATE],+ ),+ request_policy=RequestPolicy(),+ user_message="Continue in the open browser",+ workflow_yaml="workflow_definition:\n blocks: []",+ )+ )++ assert packet.workflow_context is not None+ browser_state_omissions = [+ omission for omission in packet.omissions if omission.context_key == RequiredContextKey.BROWSER_STATE+ ]+ assert len(browser_state_omissions) == 1+ assert browser_state_omissions[0].reason == "not_implemented"+++def test_size_budget_truncates_and_reports_omission() -> None:+ packet = TurnContextAssembler(workflow_char_budget=24).assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.EDIT,+ required_context=[RequiredContextKey.CURRENT_WORKFLOW],+ ),+ request_policy=RequestPolicy(),+ user_message="Update it",+ workflow_yaml="workflow_definition:\n blocks:\n - label: very_long_block_label",+ )+ )++ assert packet.workflow_context is not None+ assert packet.workflow_context.truncated is True+ assert len(packet.workflow_context.yaml) <= 24+ assert packet.omissions[0].context_key == RequiredContextKey.CURRENT_WORKFLOW+ assert packet.omissions[0].reason == "truncated_to_budget"+++def test_credential_context_contains_safe_metadata_only() -> None:+ packet = TurnContextAssembler().assemble(+ TurnContextInputs(+ turn_intent=TurnIntent(+ mode=TurnIntentMode.BUILD,+ required_context=[RequiredContextKey.CREDENTIAL_METADATA],+ ),+ request_policy=RequestPolicy(+ credential_input_kind="credential_id",+ credential_refs=["cred_safe"],+ resolved_credentials=[+ SimpleNamespace(+ credential_id="cred_safe",+ name="Saved Login",+ credential_type="password",+ vault_type="bitwarden",+ tested_url="https://example.test/login",+ browser_profile_id="bp-1",+ username="[email protected]",+ totp_identifier="private-phone",+ user_context="Click SSO",+ )+ ],+ ),+ user_message="Build with cred_safe",+ )+ )++ assert packet.credential_context is not None+ assert packet.credential_context.credentials[0].credential_id == "cred_safe"+ dumped = packet.credential_context.model_dump_json()+ assert "[email protected]" not in dumped+ assert "private-phone" not in dumped+ assert "Click SSO" not in dumped+++def test_shadow_attachment_stores_packet_on_copilot_context() -> None:+ ctx = CopilotContext(+ organization_id="org-1",+ workflow_id="wf-1",+ workflow_permanent_id="wfp-1",+ workflow_yaml="",+ browser_session_id=None,+ stream=MagicMock(),+ turn_intent=TurnIntent(+ mode=TurnIntentMode.EDIT,+ required_context=[RequiredContextKey.CURRENT_WORKFLOW],+ ),+ )++ _store_turn_context_packet_on_context(+ ctx,+ request_policy=RequestPolicy(),+ chat_request=SimpleNamespace(+ message="Update it",+ workflow_yaml="workflow_definition:\n blocks: []",+ ),+ chat_history=[],+ debug_run_info_text="",+ )++ assert ctx.turn_context_packet is not None+ assert ctx.turn_context_packet.workflow_context is not None