Skip to content

Automate browser based workflows with AI

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.py
index 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_prompt
from 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, TurnContextPacket
from skyvern.forge.sdk.copilot.turn_intent import TurnIntent, build_turn_intent
from skyvern.forge.sdk.schemas.persistent_browser_sessions import is_final_status
from 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.py
index 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 NarratorState
from skyvern.forge.sdk.copilot.request_policy import RequestPolicy
+ from skyvern.forge.sdk.copilot.turn_context import TurnContextPacket
from skyvern.forge.sdk.copilot.turn_intent import TurnIntent
@@ -169,6 +170,7 @@ class CopilotContext(AgentContext):
allow_untested_workflow_draft: bool = False
request_policy: RequestPolicy | None = None
turn_intent: TurnIntent | None = None
+ turn_context_packet: TurnContextPacket | None = None
# Tool tracking
consecutive_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.py
index 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.py
new file mode 100644
index 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,
+ ), omissions
diff --git a/tests/unit/test_copilot_agent_helpers.py b/tests/unit/test_copilot_agent_helpers.py
index 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_module
from skyvern.forge.sdk.copilot.config import CopilotConfig
from 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 False
def 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_history
def 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) <= 1024
def 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 slot
def 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.py
new file mode 100644
index 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