Automate browser based workflows with AI
Python aiapiautomationbrowserbrowser-automationcomputergptllmplaywrightpowerautomatepuppeteerpythonrpaseleniumvisionworkflow
fix(SKY-13182): recover a live tab-less inherited browser instead of orphaning it (#7960)
Aaron Perezaea531f6a940
diff --git a/docs/api-reference/openapi.json b/docs/api-reference/openapi.jsonindex 52d01760f..582863ad7 100644--- a/docs/api-reference/openapi.json+++ b/docs/api-reference/openapi.json@@ -12148,6 +12148,11 @@}],"title": "Reasoning Effort"+ },+ "extra_parameters": {+ "additionalProperties": true,+ "type": "object",+ "title": "Extra Parameters"}},"type": "object",@@ -12191,7 +12196,8 @@"enum": ["openai_compatible","ollama",- "openrouter"+ "openrouter",+ "gemini"],"title": "CustomLLMProvider"},diff --git a/skyvern-frontend/src/api/types.ts b/skyvern-frontend/src/api/types.tsindex 88bc5e25a..171e25816 100644--- a/skyvern-frontend/src/api/types.ts+++ b/skyvern-frontend/src/api/types.ts@@ -293,7 +293,11 @@ export type ClearOrganizationAuthTokenResponse = {success: boolean;};-export type CustomLLMProvider = "openai_compatible" | "ollama" | "openrouter";+export type CustomLLMProvider =+ | "openai_compatible"+ | "ollama"+ | "openrouter"+ | "gemini";export type CustomLLMConfig = {display_name: string;@@ -307,6 +311,7 @@ export type CustomLLMConfig = {max_completion_tokens?: number | null;temperature?: number | null;reasoning_effort?: string | null;+ extra_parameters?: Record<string, unknown> | null;};export type CustomLLM = {diff --git a/skyvern-frontend/src/components/CustomLLMConfigForm.tsx b/skyvern-frontend/src/components/CustomLLMConfigForm.tsxindex a68dcec50..fc673cf2f 100644--- a/skyvern-frontend/src/components/CustomLLMConfigForm.tsx+++ b/skyvern-frontend/src/components/CustomLLMConfigForm.tsx@@ -32,11 +32,17 @@ import {SelectValue,} from "@/components/ui/select";import { Switch } from "@/components/ui/switch";+import {+ ExtraParamRow,+ buildExtraParameters,+ extraParamsToRows,+} from "@/components/customLLMExtraParams";const providerLabels: Record<CustomLLMProvider, string> = {openai_compatible: "OpenAI compatible",ollama: "Ollama",openrouter: "OpenRouter",+ gemini: "Gemini",};const optionalString = z.preprocess(@@ -55,7 +61,7 @@ const optionalNumber = (schema: z.ZodNumber) =>const configSchema = z.object({display_name: z.string().trim().min(1, "Name is required"),- provider: z.enum(["openai_compatible", "ollama", "openrouter"]),+ provider: z.enum(["openai_compatible", "ollama", "openrouter", "gemini"]),model_name: z.string().trim().min(1, "Model ID is required"),api_base: optionalString,api_key: optionalString,@@ -87,7 +93,8 @@ const configSchema = z}if ((value.provider === "openai_compatible" ||- value.provider === "openrouter") &&+ value.provider === "openrouter" ||+ value.provider === "gemini") &&!value.api_key) {ctx.addIssue({@@ -124,6 +131,13 @@ const providerDefaults: Record<CustomLLMProvider, Partial<CustomLLMConfig>> = {supports_vision: true,add_assistant_prefix: false,},+ gemini: {+ api_base: "",+ api_key: "",+ api_version: "",+ supports_vision: true,+ add_assistant_prefix: false,+ },};function emptyFormValues(provider: CustomLLMProvider = "openai_compatible") {@@ -159,7 +173,10 @@ function valuesForCustomLLM(customLLM: CustomLLM): FormData {};}-function requestFromValues(values: FormData): { config: CustomLLMConfig } {+function requestFromValues(+ values: FormData,+ extraParameters: Record<string, unknown>,+): { config: CustomLLMConfig } {return {config: {...values.config,@@ -172,6 +189,7 @@ function requestFromValues(values: FormData): { config: CustomLLMConfig } {? null: values.config.temperature,reasoning_effort: values.config.reasoning_effort || null,+ extra_parameters: extraParameters,},};}@@ -179,6 +197,8 @@ function requestFromValues(values: FormData): { config: CustomLLMConfig } {export function CustomLLMConfigForm() {const [editing, setEditing] = useState<CustomLLM | null>(null);const [showApiKey, setShowApiKey] = useState(false);+ const [extraParams, setExtraParams] = useState<ExtraParamRow[]>([]);+ const [extraParamsError, setExtraParamsError] = useState<string | null>(null);const {customLLMs,isLoading,@@ -202,16 +222,41 @@ export function CustomLLMConfigForm() {return;}form.reset(valuesForCustomLLM(editing));+ setExtraParams(extraParamsToRows(editing.config.extra_parameters));+ setExtraParamsError(null);}, [editing, form]);const resetForm = () => {setEditing(null);setShowApiKey(false);+ setExtraParams([]);+ setExtraParamsError(null);form.reset(emptyFormValues());};+ const addExtraParam = () =>+ setExtraParams((rows) => [...rows, { key: "", value: "" }]);++ const updateExtraParam = (+ index: number,+ field: keyof ExtraParamRow,+ value: string,+ ) =>+ setExtraParams((rows) =>+ rows.map((row, i) => (i === index ? { ...row, [field]: value } : row)),+ );++ const removeExtraParam = (index: number) =>+ setExtraParams((rows) => rows.filter((_, i) => i !== index));+const onSubmit = (values: FormData) => {- const request = requestFromValues(values);+ const { params, error } = buildExtraParameters(extraParams);+ if (error) {+ setExtraParamsError(error);+ return;+ }+ setExtraParamsError(null);+ const request = requestFromValues(values, params);if (editing) {updateCustomLLM({ id: editing.id, request }, { onSuccess: resetForm });return;@@ -359,7 +404,9 @@ export function CustomLLMConfigForm() {? "anthropic/claude-3.5-sonnet": provider === "ollama"? "llama3.1"- : "mistral"+ : provider === "gemini"+ ? "gemini-2.5-flash"+ : "mistral"}disabled={isLoading || isMutating}/>@@ -562,6 +609,70 @@ export function CustomLLMConfigForm() {/></div>+ <div className="space-y-3 rounded-md border p-3">+ <div className="space-y-1">+ <div className="text-sm font-medium">Advanced parameters</div>+ <p className="text-xs text-muted-foreground">+ Provider-specific parameters passed through to the model (e.g.{" "}+ <code>service_tier</code>, <code>thinking</code>,{" "}+ <code>extra_headers</code>). Values are parsed as JSON when+ possible, otherwise sent as text.+ </p>+ </div>+ {extraParams.length > 0 && (+ <div className="space-y-2">+ {extraParams.map((row, index) => (+ <div+ key={index}+ className="flex flex-col gap-2 md:flex-row md:items-start"+ >+ <Input+ value={row.key}+ placeholder="Parameter name"+ className="md:w-1/3"+ disabled={isLoading || isMutating}+ onChange={(event) =>+ updateExtraParam(index, "key", event.target.value)+ }+ />+ <Input+ value={row.value}+ placeholder='Value (e.g. flex or {"type":"enabled"})'+ className="md:flex-1"+ disabled={isLoading || isMutating}+ onChange={(event) =>+ updateExtraParam(index, "value", event.target.value)+ }+ />+ <Button+ type="button"+ variant="outline"+ size="icon"+ aria-label="Remove parameter"+ disabled={isLoading || isMutating}+ onClick={() => removeExtraParam(index)}+ >+ <TrashIcon className="h-4 w-4" />+ </Button>+ </div>+ ))}+ </div>+ )}+ {extraParamsError && (+ <p className="text-sm text-destructive">{extraParamsError}</p>+ )}+ <Button+ type="button"+ variant="outline"+ size="sm"+ disabled={isLoading || isMutating}+ onClick={addExtraParam}+ >+ <PlusIcon className="mr-2 h-4 w-4" />+ Add parameter+ </Button>+ </div>+<div className="flex flex-wrap items-center gap-3"><Button type="submit" disabled={isLoading || isMutating}>{editing ? (diff --git a/skyvern-frontend/src/components/customLLMExtraParams.test.ts b/skyvern-frontend/src/components/customLLMExtraParams.test.tsnew file mode 100644index 000000000..d4736b584--- /dev/null+++ b/skyvern-frontend/src/components/customLLMExtraParams.test.ts@@ -0,0 +1,58 @@+import { describe, expect, it } from "vitest";++import {+ buildExtraParameters,+ extraParamRowValue,+ extraParamsToRows,+ parseExtraParamValue,+} from "./customLLMExtraParams";++describe("extra parameter row round-tripping", () => {+ // A no-op edit takes the stored value through extraParamRowValue (display) and back through+ // parseExtraParamValue (save). The stored value must come back unchanged.+ const roundTrip = (value: unknown) =>+ parseExtraParamValue(extraParamRowValue(value));++ it.each([+ ["plain string", "flex"],+ ["JSON scalar string", "123"],+ ["boolean-like string", "true"],+ ["null-like string", "null"],+ ["JSON string literal", '"foo"'],+ ["string with padding", " spaced "],+ ["empty string", ""],+ ["number", 42],+ ["boolean", true],+ ["object", { type: "enabled", budget_tokens: 1024 }],+ ["nested headers", { Authorization: "Bearer x", "X-API-Key": "k" }],+ ])("preserves a %s on a no-op save", (_label, value) => {+ expect(roundTrip(value)).toStrictEqual(value);+ });++ it("does not silently retype a stored JSON string literal", () => {+ // Regression for the '"foo"' case: shown quoted so it re-parses back to the same string.+ expect(extraParamRowValue('"foo"')).toBe('"\\"foo\\""');+ expect(parseExtraParamValue('"\\"foo\\""')).toBe('"foo"');+ });+});++describe("extraParamsToRows / buildExtraParameters", () => {+ it("survives a full config round-trip", () => {+ const extraParameters = {+ service_tier: "flex",+ literal: '"foo"',+ count: "123",+ thinking: { type: "enabled", budget_tokens: 1024 },+ };+ const { params, error } = buildExtraParameters(+ extraParamsToRows(extraParameters),+ );+ expect(error).toBeNull();+ expect(params).toStrictEqual(extraParameters);+ });++ it("rejects reserved keys advertised for passthrough", () => {+ const { error } = buildExtraParameters([{ key: "tools", value: "[]" }]);+ expect(error).toContain("reserved");+ });+});diff --git a/skyvern-frontend/src/components/customLLMExtraParams.ts b/skyvern-frontend/src/components/customLLMExtraParams.tsnew file mode 100644index 000000000..1b42ec8cd--- /dev/null+++ b/skyvern-frontend/src/components/customLLMExtraParams.ts@@ -0,0 +1,86 @@+export type ExtraParamRow = { key: string; value: string };++// Mirrors RESERVED_EXTRA_PARAMETER_KEYS in skyvern/forge/sdk/schemas/custom_llms.py — these are+// derived from the config or passed explicitly at the invocation boundary, so the backend rejects+// them. Flag them client-side too so the user gets an inline error instead of a 400.+export const RESERVED_EXTRA_PARAM_KEYS = new Set([+ "model",+ "messages",+ "api_key",+ "api_base",+ "api_version",+ "model_info",+ "custom_llm_provider",+ "drop_params",+ "stream",+ "tools",+]);++export const MAX_EXTRA_PARAM_COUNT = 30;++export function parseExtraParamValue(value: string): unknown {+ const trimmed = value.trim();+ if (trimmed === "") {+ return "";+ }+ try {+ return JSON.parse(trimmed);+ } catch {+ return value;+ }+}++export function extraParamRowValue(value: unknown): string {+ if (typeof value === "string") {+ // Show the raw string only when it survives a no-op save unchanged. Any string that+ // parseExtraParamValue would re-type (JSON scalars like "123"/"true", JSON string literals+ // like "\"foo\"", or values with trimmed whitespace) is quoted so it round-trips back verbatim.+ if (parseExtraParamValue(value) === value) {+ return value;+ }+ return JSON.stringify(value);+ }+ return JSON.stringify(value);+}++export function extraParamsToRows(+ extraParameters: Record<string, unknown> | null | undefined,+): ExtraParamRow[] {+ if (!extraParameters) {+ return [];+ }+ return Object.entries(extraParameters).map(([key, value]) => ({+ key,+ value: extraParamRowValue(value),+ }));+}++export function buildExtraParameters(rows: ExtraParamRow[]): {+ params: Record<string, unknown>;+ error: string | null;+} {+ const params: Record<string, unknown> = {};+ for (const row of rows) {+ const key = row.key.trim();+ if (!key) {+ if (row.value.trim()) {+ return { params, error: "Advanced parameter rows must have a name." };+ }+ continue;+ }+ if (RESERVED_EXTRA_PARAM_KEYS.has(key.toLowerCase())) {+ return { params, error: `"${key}" is a reserved parameter name.` };+ }+ if (key in params) {+ return { params, error: `Duplicate parameter name "${key}".` };+ }+ params[key] = parseExtraParamValue(row.value);+ }+ if (Object.keys(params).length > MAX_EXTRA_PARAM_COUNT) {+ return {+ params,+ error: `Add at most ${MAX_EXTRA_PARAM_COUNT} advanced parameters.`,+ };+ }+ return { params, error: null };+}diff --git a/skyvern/forge/agent.py b/skyvern/forge/agent.pyindex f78d74eed..f09374fed 100644--- a/skyvern/forge/agent.py+++ b/skyvern/forge/agent.py@@ -1294,8 +1294,8 @@ class ForgeAgent:except FailedToSendWebhook:LOG.exception("Failed to send webhook",- task=task,- step=step,+ task_id=task.task_id,+ step_id=step.step_id,)return step, detailed_output, next_stepexcept FailedToNavigateToUrl as e:diff --git a/skyvern/forge/log_redaction.py b/skyvern/forge/log_redaction.pynew file mode 100644index 000000000..a6c42b92b--- /dev/null+++ b/skyvern/forge/log_redaction.py@@ -0,0 +1,213 @@+"""Field-name redaction shared by the request-logging middleware and the log processors.++Deliberately free of web-framework imports: ``forge_log`` runs this on every log+record, and starlette ships only in the ``local``/``server`` extras, so importing+it from here would break logging on a core ``pip install skyvern``.++Public surface (imported by ``forge_log``, ``request_logging`` and the copilot+tracing modules): ``REDACTED``, ``SENSITIVE_HEADERS``, ``SENSITIVE_FIELDS``,+``is_sensitive_key``, ``strip_artifact_url_query``, ``redact_bearer_tokens_in_text``+and ``redact_sensitive_fields``.+"""++from __future__ import annotations++import json+import re+import typing+from collections.abc import Mapping++from pydantic import BaseModel++from skyvern.utils.action_redaction import redact_action_payload_for_log++REDACTED = "****"++# Request headers dropped wholesale from request logs. proxy-authorization and+# set-cookie carry credentials too and are classified as such by other modules.+SENSITIVE_HEADERS = {"authorization", "proxy-authorization", "cookie", "set-cookie", "x-api-key"}++# Exact field names that are always redacted. Use a set for O(1) lookup+# instead of regex substring matching to avoid false positives like+# credential_id, author, page_token, etc. SENSITIVE_HEADERS is folded in so a+# name classified as a credential header cannot be missed when the same header+# dict arrives as a log kwarg instead of through the middleware.+SENSITIVE_FIELDS: set[str] = {+ "password",+ "secret",+ "token",+ "api_key",+ "apikey",+ "api-key",+ "credential",+ "access_key",+ "private_key",+ "auth",+ "authorization",+ "extra_http_headers",+ "cdp_connect_headers",+ "secret_key",+ "totp",+ "cached_totp",+ "otp",+ "one_time_code",+ "one_time_password",+ "mfa_code",+ "verification_code",+ "totp_identifier",+ "totp_url",+ "totp_secret",+} | SENSITIVE_HEADERS++# Matches a signed artifact-content URL (absolute or path-relative) anywhere in a+# string and captures everything up to — but excluding — its query, so re.sub can+# drop the capability params (expiry/kid/sig) while leaving surrounding text and+# non-artifact URLs untouched. Query runs to the next whitespace/quote/angle bracket.+# Anchored on the literal path segment: an optional leading `scheme://host` group+# re-scanned and backtracked the alphanumeric run at every start position, which is+# quadratic in run length on strings that never match, and `re.sub` re-emitted that+# prefix verbatim anyway.+_ARTIFACT_CONTENT_URL_QUERY_RE = re.compile(r"(/v1/artifacts/[^/\s\"'<>]+/content/?)\?[^\s\"'<>]*")++# Bearer JWTs occasionally leak into log messages via WebSocket connection URLs that+# pass `?token=Bearer%20<jwt>` as a query string. The token class spans base64url,+# standard base64 (`+ / =`) and opaque values (`~`), so a credential is consumed whole.+_BEARER_TOKEN_RE = re.compile(r"(?i)(token=)(?:Bearer(?:%20|\s+))?[A-Za-z0-9._%~+/=-]+")+# `Authorization: Bearer <token>` / `Proxy-Authorization: Bearer <token>` header+# values (including dict-repr forms like `'authorization': 'Bearer ...'`). The whole+# credential after the scheme is dropped regardless of its shape: in a credential+# header there is no prose to protect, so all-alpha and short tokens are redacted too.+_AUTH_HEADER_BEARER_RE = re.compile(+ r"(?i)((?:proxy-)?authorization[\"']?\s*[:=]\s*[\"']?)Bearer(?:%20|\s+)[A-Za-z0-9._~+/=%-]+"+)+# Bare `Bearer <token>` inside exception strings / free text with no header context.+# Requires at least one non-alpha char and an 8-char minimum so prose like+# "Bearer authentication required" is preserved; header shapes are handled above.+_BEARER_CREDENTIAL_RE = re.compile(+ r"(?i)\bBearer(?:%20|\s+)(?=[A-Za-z0-9._~+/=%-]*[0-9._~+/=%-])[A-Za-z0-9._~+/=%-]{8,}"+)++# Placeholder emitted when a container is revisited during the walk. Breaks cycles+# and de-duplicates shared sub-graphs so the walk stays O(nodes) rather than+# fanning out exponentially under the depth cap.+_CIRCULAR = "<circular>"+++def is_sensitive_key(key: typing.Any, *, redact_metadata: bool = False) -> bool:+ # Reached with arbitrary structlog kwargs and parsed JSON, so a key is not+ # guaranteed to be a string; a non-str key can never match an exact name.+ if not isinstance(key, str):+ return False+ normalized = key.lower()+ return normalized in SENSITIVE_FIELDS or (redact_metadata and normalized == "metadata")+++def strip_artifact_url_query(value: str) -> str:+ return _ARTIFACT_CONTENT_URL_QUERY_RE.sub(r"\1", value)+++def redact_bearer_tokens_in_text(value: str) -> str:+ """Redact Bearer credentials from a single string.++ Covers `?token=Bearer%20<jwt>` query strings, `Authorization: Bearer <token>`+ (and `Proxy-Authorization`) header values of any token shape, and bare+ `Bearer <token>` runs in exception / free text (guarded against prose).+ """+ lowered = value.lower()+ if "token=" in lowered:+ value = _BEARER_TOKEN_RE.sub(r"\1<redacted>", value)+ if "authorization" in lowered:+ value = _AUTH_HEADER_BEARER_RE.sub(r"\1Bearer <redacted>", value)+ if "bearer" in lowered:+ value = _BEARER_CREDENTIAL_RE.sub("Bearer <redacted>", value)+ return value+++def _redact_string(value: str) -> str:+ return redact_bearer_tokens_in_text(strip_artifact_url_query(value))+++def redact_sensitive_fields(+ obj: typing.Any,+ _depth: int = 0,+ *,+ redact_metadata: bool = False,+ _seen: set[int] | None = None,+) -> typing.Any:+ """Redact sensitive fields, bearer credentials, and artifact-URL capability queries.++ Field names use exact-match (case-insensitive) rather than substring/regex+ to avoid false positives on fields like ``credential_id``, ``author``, or+ ``page_token`` which contain sensitive substrings but are not secrets. Bearer+ credentials embedded in nested string values are stripped too, so a header dict+ like ``{"Proxy-Authorization": "Bearer sk-..."}`` cannot slip through under a+ key name the middleware does not classify.+ """+ if isinstance(obj, str):+ sanitized_value = _redact_string(obj)+ if _depth > 20:+ return sanitized_value+ try:+ parsed_value = json.loads(sanitized_value)+ except (json.JSONDecodeError, TypeError):+ return sanitized_value+ if isinstance(parsed_value, (dict, list)):+ redacted_value = redact_sensitive_fields(+ parsed_value, _depth + 1, redact_metadata=redact_metadata, _seen=_seen+ )+ return json.dumps(redacted_value) if redacted_value != parsed_value else sanitized_value+ return sanitized_value++ # Bound total node count, not just depth: a shared or cyclic container fans out+ # exponentially under the depth cap on this synchronous per-record walk.+ if isinstance(obj, (BaseModel, Mapping, list, tuple, set, frozenset)):+ if _seen is None:+ _seen = set()+ marker = id(obj)+ if marker in _seen:+ return _CIRCULAR+ _seen.add(marker)++ if _depth > 20:+ # Stop recursing but still redact sensitive keys at this level. Any Mapping+ # (not just dict) so header containers such as httpx / starlette Headers,+ # MappingProxyType and CIMultiDict are covered.+ if isinstance(obj, Mapping):+ return {k: REDACTED if is_sensitive_key(k, redact_metadata=redact_metadata) else v for k, v in obj.items()}+ return obj+ if isinstance(obj, BaseModel):+ # A model kwarg is otherwise rendered in full by the log formatter, carrying+ # whatever sensitive fields it declares. model_dump bypasses the model's own+ # __repr__ OTP masking, so re-apply the action-payload redaction (masks+ # input_text `text`/`totp_*` in OTP context) before the generic field pass.+ try:+ dumped = obj.model_dump()+ except Exception:+ return obj+ dumped = redact_action_payload_for_log(dumped)+ return redact_sensitive_fields(dumped, _depth + 1, redact_metadata=redact_metadata, _seen=_seen)+ if isinstance(obj, Mapping):+ return {+ k: (+ REDACTED+ if is_sensitive_key(k, redact_metadata=redact_metadata)+ else redact_sensitive_fields(v, _depth + 1, redact_metadata=redact_metadata, _seen=_seen)+ )+ for k, v in obj.items()+ }+ if isinstance(obj, list):+ return [redact_sensitive_fields(item, _depth + 1, redact_metadata=redact_metadata, _seen=_seen) for item in obj]+ if isinstance(obj, tuple):+ return tuple(+ redact_sensitive_fields(item, _depth + 1, redact_metadata=redact_metadata, _seen=_seen) for item in obj+ )+ if isinstance(obj, (set, frozenset)):+ try:+ return type(obj)(+ redact_sensitive_fields(item, _depth + 1, redact_metadata=redact_metadata, _seen=_seen) for item in obj+ )+ except TypeError:+ # Redaction maps hashables to hashables except a frozen model, which+ # dumps to an unhashable dict.+ return obj+ return objdiff --git a/skyvern/forge/request_logging.py b/skyvern/forge/request_logging.pyindex c85a259e3..d76e7a9ed 100644--- a/skyvern/forge/request_logging.py+++ b/skyvern/forge/request_logging.py@@ -11,6 +11,12 @@ from starlette.requests import ClientDisconnectfrom starlette.responses import Responsefrom skyvern.config import settings+from skyvern.forge.log_redaction import (+ REDACTED,+ SENSITIVE_HEADERS,+ redact_sensitive_fields,+ strip_artifact_url_query,+)if typing.TYPE_CHECKING: # pragma: no cover - import only for type hintsfrom typing import Awaitable, Callable@@ -19,7 +25,6 @@ if typing.TYPE_CHECKING: # pragma: no cover - import only for type hintsLOG = structlog.get_logger()-_SENSITIVE_HEADERS = {"authorization", "cookie", "x-api-key"}_SENSITIVE_ENDPOINTS = {"POST /api/v1/credentials","POST /v1/credentials",@@ -38,46 +43,15 @@ _MAX_BODY_LENGTH = 1000_READ_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})_MAX_RESPONSE_READ_BYTES = 1024 * 1024 # 1 MB — skip logging bodies larger than this_BINARY_PLACEHOLDER = "<binary>"-_REDACTED = "****"_LOGGABLE_CONTENT_TYPES = {"text/", "application/json"}_STREAMING_CONTENT_TYPE = "text/event-stream"-# Matches a signed artifact-content URL (absolute or path-relative) anywhere in a-# string and captures everything up to — but excluding — its query, so re.sub can-# drop the capability params (expiry/kid/sig) while leaving surrounding text and-# non-artifact URLs untouched. Query runs to the next whitespace/quote/angle bracket.-_ARTIFACT_CONTENT_URL_QUERY_RE = re.compile(- r"((?:[a-zA-Z][a-zA-Z0-9+.\-]*://[^/\s\"'<>]+)?/v1/artifacts/[^/\s\"'<>]+/content/?)\?[^\s\"'<>]*"-)_ACTION_LOG_ENDPOINT_RE = re.compile(r"^/v1/browser_sessions/[^/]+/action_logs/?$")-# Exact field names that are always redacted. Use a set for O(1) lookup-# instead of regex substring matching to avoid false positives like-# credential_id, author, page_token, etc.-_SENSITIVE_FIELDS: set[str] = {- "password",- "secret",- "token",- "api_key",- "apikey",- "api-key",- "credential",- "access_key",- "private_key",- "auth",- "authorization",- "secret_key",- "totp",- "otp",- "one_time_code",- "one_time_password",- "mfa_code",-}-def _sanitize_headers(headers: typing.Mapping[str, str]) -> dict[str, str]:sanitized: dict[str, str] = {}for key, value in headers.items():- if key.lower() in _SENSITIVE_HEADERS:+ if key.lower() in SENSITIVE_HEADERS:continuesanitized[key] = valuereturn sanitized@@ -103,7 +77,7 @@ def _is_sensitive_endpoint(request: Request) -> bool:def _sanitize_body(request: Request, body: bytes, content_type: str | None) -> str:if _is_sensitive_endpoint(request):- return _REDACTED+ return REDACTEDif not body:return ""if content_type and not (content_type.startswith("text/") or content_type.startswith("application/json")):@@ -118,60 +92,11 @@ def _sanitize_body(request: Request, body: bytes, content_type: str | None) -> sreturn text-def _is_sensitive_key(key: str, *, redact_metadata: bool = False) -> bool:- normalized = key.lower()- return normalized in _SENSITIVE_FIELDS or (redact_metadata and normalized == "metadata")---def _strip_artifact_url_query(value: str) -> str:- return _ARTIFACT_CONTENT_URL_QUERY_RE.sub(r"\1", value)---def redact_sensitive_fields(obj: typing.Any, _depth: int = 0, *, redact_metadata: bool = False) -> typing.Any:- """Redact sensitive fields and strip capability queries from artifact URLs.-- Field names use exact-match (case-insensitive) rather than substring/regex- to avoid false positives on fields like ``credential_id``, ``author``, or- ``page_token`` which contain sensitive substrings but are not secrets.- """- if isinstance(obj, str):- sanitized_value = _strip_artifact_url_query(obj)- if _depth > 20:- return sanitized_value- try:- parsed_value = json.loads(sanitized_value)- except (json.JSONDecodeError, TypeError):- return sanitized_value- if isinstance(parsed_value, (dict, list)):- redacted_value = redact_sensitive_fields(parsed_value, _depth + 1, redact_metadata=redact_metadata)- return json.dumps(redacted_value) if redacted_value != parsed_value else sanitized_value- return sanitized_value- if _depth > 20:- # Stop recursing but still redact sensitive keys at this level- if isinstance(obj, dict):- return {- k: _REDACTED if _is_sensitive_key(k, redact_metadata=redact_metadata) else v for k, v in obj.items()- }- return obj- if isinstance(obj, dict):- return {- k: (- _REDACTED- if _is_sensitive_key(k, redact_metadata=redact_metadata)- else redact_sensitive_fields(v, _depth + 1, redact_metadata=redact_metadata)- )- for k, v in obj.items()- }- if isinstance(obj, list):- return [redact_sensitive_fields(item, _depth + 1, redact_metadata=redact_metadata) for item in obj]- return obj--def _redact_loggable_body(text: str) -> str:try:parsed = json.loads(text)except (json.JSONDecodeError, TypeError):- return _strip_artifact_url_query(text)+ return strip_artifact_url_query(text)redacted = redact_sensitive_fields(parsed)return json.dumps(redacted) if redacted != parsed else text@@ -184,7 +109,7 @@ def _is_loggable_content_type(content_type: str | None) -> bool:def _sanitize_response_body(request: Request, body_str: str | None, content_type: str | None) -> str:if _is_sensitive_endpoint(request):- return _REDACTED+ return REDACTEDif body_str is None:return _BINARY_PLACEHOLDERif not body_str:diff --git a/skyvern/forge/sdk/api/llm/api_handler_factory.py b/skyvern/forge/sdk/api/llm/api_handler_factory.pyindex 898e5365e..77f44f2b5 100644--- a/skyvern/forge/sdk/api/llm/api_handler_factory.py+++ b/skyvern/forge/sdk/api/llm/api_handler_factory.py@@ -26,7 +26,7 @@ from skyvern.forge import appfrom skyvern.forge.forge_openai_client import ForgeAsyncHttpxClientWrapperfrom skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler, dummy_llm_api_handlerfrom skyvern.forge.sdk.api.llm.config_registry import LLMConfigRegistry-from skyvern.forge.sdk.api.llm.custom_llm_registry import is_custom_llm_key+from skyvern.forge.sdk.api.llm.custom_llm_registry import custom_llm_passthrough_parameters, is_custom_llm_keyfrom skyvern.forge.sdk.api.llm.exceptions import (DuplicateCustomLLMProviderError,InvalidLLMConfigError,@@ -1065,6 +1065,15 @@ class LLMAPIHandlerFactory:model=model_label,)+ @staticmethod+ def _custom_llm_owns_thinking(llm_key: str, parameters: dict[str, Any]) -> bool:+ """Whether a custom LLM supplied its own thinking payload via extra_parameters.++ When it did, the platform's default thinking-budget optimization must be skipped so it+ neither overwrites the customer budget nor in-place mutates the shared config dict. SKY-13345.+ """+ return is_custom_llm_key(llm_key) and ("thinking" in parameters or "thinking_level" in parameters)+@staticmethoddef _is_gemini_3_model(llm_config: LLMConfig | LLMRouterConfig) -> bool:"""Detect whether the underlying provider is Gemini 3.x.@@ -2197,8 +2206,14 @@ class LLMAPIHandlerFactory:if "timeout" not in active_parameters:active_parameters["timeout"] = settings.LLM_CONFIG_TIMEOUT+ # A custom LLM may declare its own thinking budget via extra_parameters; the platform's+ # default thinking-budget optimization must not overwrite it (nor in-place mutate the+ # nested dict retained in llm_config.litellm_params via the shallow merge above). SKY-13345.+ customer_owns_thinking = LLMAPIHandlerFactory._custom_llm_owns_thinking(llm_key, active_parameters)# Apply thinking budget optimization if settings are available- if (+ if customer_owns_thinking:+ pass+ elif (LLMAPIHandlerFactory._thinking_budget_settingsand prompt_name in LLMAPIHandlerFactory._thinking_budget_settings):@@ -3319,6 +3334,30 @@ class LLMCaller:if request_extra_body:openai_params["extra_body"] = request_extra_body+ # Custom OpenRouter models declare provider-specific passthrough (e.g. top_p,+ # extra_headers) via extra_parameters. The openai client only accepts known top-level+ # kwargs, so forward the rest through extra_body / extra_headers rather than dropping+ # them. SKY-13345.+ if self._custom_openrouter and isinstance(self.llm_config, LLMConfig):+ passthrough = custom_llm_passthrough_parameters(self.llm_config.litellm_params)+ for already_mapped in (+ "max_completion_tokens",+ "max_tokens",+ "temperature",+ "service_tier",+ "reasoning_effort",+ "extra_body",+ ):+ passthrough.pop(already_mapped, None)+ passthrough_headers = passthrough.pop("extra_headers", None)+ if isinstance(passthrough_headers, dict):+ extra_headers.update({str(key): str(value) for key, value in passthrough_headers.items()})+ if passthrough:+ request_extra_body = dict(openai_params.get("extra_body") or {})+ for key, value in passthrough.items():+ request_extra_body.setdefault(key, value)+ openai_params["extra_body"] = request_extra_body+try:completion = await openai_client.chat.completions.create(model=self.llm_key,diff --git a/skyvern/forge/sdk/api/llm/custom_llm_registry.py b/skyvern/forge/sdk/api/llm/custom_llm_registry.pyindex 01c59c6aa..758018116 100644--- a/skyvern/forge/sdk/api/llm/custom_llm_registry.py+++ b/skyvern/forge/sdk/api/llm/custom_llm_registry.py@@ -1,8 +1,9 @@from __future__ import annotationsimport json+from collections.abc import Mappingfrom dataclasses import dataclass-from typing import TYPE_CHECKING+from typing import TYPE_CHECKING, Anyimport structlog@@ -69,19 +70,42 @@ def _litellm_model_name(config: CustomLLMConfig) -> str:return f"openai/{_strip_provider_prefix(config.model_name, ('openai/',))}"if config.provider is CustomLLMProvider.OPENROUTER:return f"openrouter/{_strip_provider_prefix(config.model_name, ('openrouter/',))}"+ if config.provider is CustomLLMProvider.GEMINI:+ return f"gemini/{_strip_provider_prefix(config.model_name, ('gemini/',))}"if config.model_name.startswith(("ollama/", "ollama_chat/")):return config.model_namereturn f"ollama_chat/{config.model_name}"+# Keys _build_litellm_params derives from the config; everything else in litellm_params is+# customer-supplied passthrough. Kept here so dispatch paths can recover the passthrough set.+_CONNECTION_PARAM_KEYS = frozenset({"api_key", "api_base", "api_version", "model_info"})++def _build_litellm_params(config: CustomLLMConfig, litellm_model_name: str) -> LiteLLMParams:- params: LiteLLMParams = {+ params: dict[str, Any] = {"api_key": config.api_key,"api_base": config.api_base,"api_version": config.api_version,"model_info": {"model_name": litellm_model_name},}- return {key: value for key, value in params.items() if value is not None} # type: ignore[return-value]+ merged = {key: value for key, value in params.items() if value is not None}+ # Provider-specific passthrough (e.g. service_tier, thinking, extra_headers). Applied last so it+ # rides through the same litellm_params merge that reaches the completion call; reserved keys are+ # rejected at config validation, so nothing here can clobber api_key/api_base/model.+ merged.update(config.extra_parameters)+ return merged # type: ignore[return-value]+++def custom_llm_passthrough_parameters(litellm_params: Mapping[str, Any] | None) -> dict[str, Any]:+ """Return the customer-supplied passthrough params from a registered config's litellm_params.++ Dispatch paths that rebuild the request kwargs from a fixed allowlist (e.g. the custom+ OpenRouter branch) use this to forward provider-specific params they would otherwise drop.+ """+ if not litellm_params:+ return {}+ return {key: value for key, value in litellm_params.items() if key not in _CONNECTION_PARAM_KEYS}def _build_llm_config(config: CustomLLMConfig) -> LLMConfig:diff --git a/skyvern/forge/sdk/copilot/request_policy.py b/skyvern/forge/sdk/copilot/request_policy.pyindex aff07a88d..28372cc46 100644--- a/skyvern/forge/sdk/copilot/request_policy.py+++ b/skyvern/forge/sdk/copilot/request_policy.py@@ -14,8 +14,8 @@ import structlogfrom skyvern.config import settingsfrom skyvern.forge import app+from skyvern.forge.log_redaction import redact_sensitive_fieldsfrom skyvern.forge.prompts import prompt_engine-from skyvern.forge.request_logging import redact_sensitive_fieldsfrom skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandlerfrom skyvern.forge.sdk.copilot.config import CopilotConfigfrom skyvern.forge.sdk.copilot.context import (diff --git a/skyvern/forge/sdk/copilot/streaming_adapter.py b/skyvern/forge/sdk/copilot/streaming_adapter.pyindex 7ca121c73..509f5f76f 100644--- a/skyvern/forge/sdk/copilot/streaming_adapter.py+++ b/skyvern/forge/sdk/copilot/streaming_adapter.py@@ -16,7 +16,7 @@ from skyvern.config import settings# Reuse the HTTP-logging redactor so SSE tool inputs and request-body logs# share one exact-match sensitive-key policy.-from skyvern.forge.request_logging import redact_sensitive_fields+from skyvern.forge.log_redaction import redact_sensitive_fieldsfrom skyvern.forge.sdk.copilot.context import InFlightStreamToolCallfrom skyvern.forge.sdk.copilot.narration import (CODE_REPAIR_PROGRESS_SURFACE_KIND,diff --git a/skyvern/forge/sdk/copilot/tracing_setup.py b/skyvern/forge/sdk/copilot/tracing_setup.pyindex d0754c335..b0254f627 100644--- a/skyvern/forge/sdk/copilot/tracing_setup.py+++ b/skyvern/forge/sdk/copilot/tracing_setup.py@@ -19,7 +19,7 @@ from skyvern.config import settings# Reuse the HTTP-logging redactor so trace-side and SSE-side redaction share# one exact-match sensitive-key policy.-from skyvern.forge.request_logging import redact_sensitive_fields+from skyvern.forge.log_redaction import redact_sensitive_fieldsfrom skyvern.forge.sdk.core import skyvern_contextif TYPE_CHECKING:diff --git a/skyvern/forge/sdk/forge_log.py b/skyvern/forge/sdk/forge_log.pyindex 610e002a1..07d0c1d90 100644--- a/skyvern/forge/sdk/forge_log.py+++ b/skyvern/forge/sdk/forge_log.py@@ -1,6 +1,5 @@import loggingimport random-import reimport sysfrom pathlib import Pathfrom types import TracebackType@@ -11,13 +10,14 @@ from structlog.typing import EventDictfrom skyvern._version import __version__from skyvern.config import settings+from skyvern.forge.log_redaction import (+ REDACTED,+ is_sensitive_key,+ redact_bearer_tokens_in_text,+ redact_sensitive_fields,+)from skyvern.forge.sdk.core import skyvern_context-# Bearer JWTs occasionally leak into log messages via WebSocket connection-# URLs that pass `?token=Bearer%20<jwt>` as a query string. Redact before-# anything ships to Datadog. Matches both raw and URL-encoded forms.-_BEARER_TOKEN_RE = re.compile(r"(?i)(token=)(?:Bearer(?:%20|\s+))?[A-Za-z0-9._%-]+")-LOGGING_LEVEL_MAP: dict[str, int] = {"DEBUG": logging.DEBUG,"INFO": logging.INFO,@@ -202,14 +202,41 @@ def redact_registered_secrets(logger: logging.Logger, method_name: str, event_didef redact_bearer_tokens(logger: logging.Logger, method_name: str, event_dict: EventDict) -> EventDict:- """Redact Bearer JWTs from any string value in the event dict.+ """Redact Bearer credentials from every top-level string value in the event dict.++ Covers `?token=Bearer%20<jwt>` query strings (e.g. WebSocket connection URLs),+ `Authorization: Bearer <token>` header values, and bare `Bearer <token>` runs in+ exception strings. Bearer credentials nested inside structured kwargs are handled+ by ``redact_sensitive_event_fields`` below, which recurses into their strings.+ """+ for key, value in list(event_dict.items()):+ if isinstance(value, str):+ event_dict[key] = redact_bearer_tokens_in_text(value)+ return event_dict- Defense-in-depth for log lines that interpolate URLs containing- `?token=Bearer%20<jwt>` (e.g. WebSocket connection URLs).++def redact_sensitive_event_fields(logger: logging.Logger, method_name: str, event_dict: EventDict) -> EventDict:+ """Mask sensitive-named kwargs (auth headers, tokens, credentials) before rendering.++ Reuses the shared field redactor so structured kwargs such as+ ``headers={"Authorization": ...}``, ``payload={...}``, or ``response_body={...}``+ are masked before ``add_kv_pairs_to_msg`` folds them into the rendered line.+ Top-level keys whose name is sensitive are masked outright; every other+ non-string value is redacted recursively — models, tuples and sets included,+ since the formatter renders those in full too. Plain string values are left to+ the bearer / registered-secret redactors above.++ Each kwarg is guarded independently: a caller-supplied container whose iteration+ raises must not take down the whole log call, so it fails closed to ``REDACTED``."""for key, value in list(event_dict.items()):- if isinstance(value, str) and "token=" in value:- event_dict[key] = _BEARER_TOKEN_RE.sub(r"\1<redacted>", value)+ try:+ if is_sensitive_key(key):+ event_dict[key] = REDACTED+ elif not isinstance(value, str):+ event_dict[key] = redact_sensitive_fields(value)+ except Exception:+ event_dict[key] = REDACTEDreturn event_dict@@ -511,7 +538,11 @@ def setup_logger() -> None:[redact_bearer_tokens,redact_registered_secrets,+ # After compaction: that pass is a log-volume control that trims Action+ # models down to a few fields, and redaction would otherwise expand them+ # into full dicts before it ran.compact_action_objects,+ redact_sensitive_event_fields,structlog.processors.EventRenamer("msg"),add_kv_pairs_to_msg,structlog.processors.CallsiteParameterAdder(@@ -529,6 +560,7 @@ def setup_logger() -> None:redact_bearer_tokens,redact_registered_secrets,compact_action_objects,+ redact_sensitive_event_fields,structlog.processors.CallsiteParameterAdder({structlog.processors.CallsiteParameter.FILENAME,@@ -575,6 +607,9 @@ def setup_logger() -> None:# exc_info to a string by now, so a secret in the exception text is reachable.# These stay duplicated in the structlog chain above on purpose: that pass also# guards `context.log`, which is persisted to the per-run S3 log artifact.+ # `redact_sensitive_event_fields` is deliberately NOT duplicated here: foreign+ # records carry only string values, and native records arrive already redacted,+ # so it could only re-walk every structured kwarg a second time.redact_bearer_tokens,redact_registered_secrets,renderer,diff --git a/skyvern/forge/sdk/routes/agent_protocol.py b/skyvern/forge/sdk/routes/agent_protocol.pyindex a4355854e..6f885e997 100644--- a/skyvern/forge/sdk/routes/agent_protocol.py+++ b/skyvern/forge/sdk/routes/agent_protocol.py@@ -3385,7 +3385,7 @@ async def webhook("Webhook signature or timestamp missing",x_skyvern_signature=x_skyvern_signature,x_skyvern_timestamp=x_skyvern_timestamp,- payload=payload,+ payload_length=len(payload),)raise HTTPException(status_code=http_status.HTTP_400_BAD_REQUEST,@@ -3401,7 +3401,7 @@ async def webhook("Webhook received",x_skyvern_signature=x_skyvern_signature,x_skyvern_timestamp=x_skyvern_timestamp,- payload=payload,+ payload_length=len(payload),generated_signature=generated_signature,valid_signature=x_skyvern_signature == generated_signature,)diff --git a/skyvern/forge/sdk/routes/custom_llms.py b/skyvern/forge/sdk/routes/custom_llms.pyindex 3c9cae191..8d5788dcf 100644--- a/skyvern/forge/sdk/routes/custom_llms.py+++ b/skyvern/forge/sdk/routes/custom_llms.py@@ -13,7 +13,6 @@ from skyvern.forge.sdk.db.enums import OrganizationAuthTokenTypefrom skyvern.forge.sdk.db.exceptions import NotFoundErrorfrom skyvern.forge.sdk.routes.routers import base_routerfrom skyvern.forge.sdk.schemas.custom_llms import (- CUSTOM_LLM_API_KEY_MASK,CustomLLM,CustomLLMConfig,CustomLLMCreateRequest,@@ -21,6 +20,7 @@ from skyvern.forge.sdk.schemas.custom_llms import (CustomLLMProvider,CustomLLMResponse,CustomLLMUpdateRequest,+ config_with_preserved_secrets,custom_llm_from_org_auth_token,custom_llm_response_from_org_auth_token,)@@ -57,18 +57,6 @@ async def _get_custom_llm(raise NotFoundError("Custom LLM not found")-def _config_with_preserved_api_key(config: CustomLLMConfig, existing_custom_llm: CustomLLM) -> CustomLLMConfig:- if config.api_key != CUSTOM_LLM_API_KEY_MASK:- return config-- return CustomLLMConfig.model_validate(- {- **config.model_dump(),- "api_key": existing_custom_llm.config.api_key,- }- )--@base_router.get("/custom-llms",response_model=CustomLLMListResponse,@@ -153,7 +141,7 @@ async def update_custom_llm() -> CustomLLMResponse:try:existing_custom_llm = await _get_custom_llm(current_org.organization_id, custom_llm_id)- config = _config_with_preserved_api_key(request.config, existing_custom_llm)+ config = config_with_preserved_secrets(request.config, existing_custom_llm.config)await _validate_custom_llm_api_base(config)token = await app.DATABASE.organizations.update_org_auth_token(organization_id=current_org.organization_id,diff --git a/skyvern/forge/sdk/schemas/custom_llms.py b/skyvern/forge/sdk/schemas/custom_llms.pyindex 87154a9fd..b813d984e 100644--- a/skyvern/forge/sdk/schemas/custom_llms.py+++ b/skyvern/forge/sdk/schemas/custom_llms.py@@ -1,3 +1,4 @@+import jsonfrom enum import StrEnumfrom http import HTTPStatusfrom typing import Any@@ -12,14 +13,42 @@ from skyvern.forge.sdk.settings_manager import SettingsManagerfrom skyvern.utils.url_validators import validate_urlCUSTOM_LLM_API_KEY_MASK = "********"+# extra_parameters keys whose nested values are credentials (e.g. Authorization / X-API-Key+# headers). Their values are masked in API responses and restored from the stored config when+# a masked value is saved back unchanged, mirroring how the top-level api_key is handled.+SECRET_EXTRA_PARAMETER_KEYS = frozenset({"extra_headers"})OLLAMA_DEFAULT_API_BASE = "http://localhost:11434"OPENROUTER_DEFAULT_API_BASE = "https://openrouter.ai/api/v1"+MAX_EXTRA_PARAMETER_COUNT = 30+MAX_EXTRA_PARAMETER_KEY_LENGTH = 128+MAX_EXTRA_PARAMETERS_SERIALIZED_BYTES = 10_000+# Keys litellm derives from the config itself or that carry the prompt; letting a+# customer override them would break the completion call or leak the wrong credentials.+# `drop_params`/`stream`/`tools` are passed explicitly at the invocation boundary, so a+# config value would arrive as a duplicate keyword and raise TypeError before dispatch+# (`stream` would also swap the response for a stream the handler cannot parse).+RESERVED_EXTRA_PARAMETER_KEYS = frozenset(+ {+ "model",+ "messages",+ "api_key",+ "api_base",+ "api_version",+ "model_info",+ "custom_llm_provider",+ "drop_params",+ "stream",+ "tools",+ }+)+class CustomLLMProvider(StrEnum):OPENAI_COMPATIBLE = "openai_compatible"OLLAMA = "ollama"OPENROUTER = "openrouter"+ GEMINI = "gemini"class CustomLLMConfig(BaseModel):@@ -34,6 +63,39 @@ class CustomLLMConfig(BaseModel):max_completion_tokens: int | None = Field(default=None, ge=1, le=1_000_000)temperature: float | None = Field(default=None, ge=0, le=2)reasoning_effort: str | None = Field(default=None, max_length=50)+ extra_parameters: dict[str, Any] = Field(default_factory=dict)++ @field_validator("extra_parameters", mode="before")+ @classmethod+ def validate_extra_parameters(cls, value: Any) -> dict[str, Any]:+ if value is None:+ return {}+ if not isinstance(value, dict):+ raise ValueError("extra_parameters must be a JSON object")+ if len(value) > MAX_EXTRA_PARAMETER_COUNT:+ raise ValueError(f"extra_parameters supports at most {MAX_EXTRA_PARAMETER_COUNT} keys")++ cleaned: dict[str, Any] = {}+ for raw_key, param_value in value.items():+ if not isinstance(raw_key, str):+ raise ValueError("extra_parameters keys must be strings")+ key = raw_key.strip()+ if not key:+ raise ValueError("extra_parameters keys must not be empty")+ if len(key) > MAX_EXTRA_PARAMETER_KEY_LENGTH:+ raise ValueError(f"extra_parameters keys must be at most {MAX_EXTRA_PARAMETER_KEY_LENGTH} characters")+ if key.lower() in RESERVED_EXTRA_PARAMETER_KEYS:+ raise ValueError(f"extra_parameters key '{key}' is reserved and cannot be overridden")+ cleaned[key] = param_value++ try:+ serialized = json.dumps(cleaned)+ except (TypeError, ValueError) as exc:+ raise ValueError("extra_parameters must be JSON-serializable") from exc+ if len(serialized.encode("utf-8")) > MAX_EXTRA_PARAMETERS_SERIALIZED_BYTES:+ raise ValueError(f"extra_parameters must be at most {MAX_EXTRA_PARAMETERS_SERIALIZED_BYTES} bytes")++ return cleaned@field_validator("display_name",@@ -71,6 +133,10 @@ class CustomLLMConfig(BaseModel):if not self.api_base:# Provider defaults are applied before URL validation.self.api_base = OPENROUTER_DEFAULT_API_BASE+ elif self.provider is CustomLLMProvider.GEMINI:+ # Gemini talks to Google's fixed endpoint via the API key, so no api_base.+ if not self.api_key:+ raise ValueError("api_key is required for Gemini models")elif self.provider is CustomLLMProvider.OLLAMA and not self.api_base:# Self-hosted users commonly run Ollama locally; Cloud disables local/private# API bases via ALLOW_CUSTOM_LLM_LOCAL_API_BASES=False below.@@ -135,8 +201,51 @@ def custom_llm_from_org_auth_token(token: OrganizationAuthToken) -> CustomLLM:)+def _mask_secret_extra_parameters(extra_parameters: dict[str, Any]) -> dict[str, Any]:+ masked = dict(extra_parameters)+ for key in SECRET_EXTRA_PARAMETER_KEYS:+ value = masked.get(key)+ if isinstance(value, dict) and value:+ masked[key] = {name: CUSTOM_LLM_API_KEY_MASK for name in value}+ return masked+++def _restore_secret_extra_parameters(+ new_parameters: dict[str, Any], existing_parameters: dict[str, Any]+) -> dict[str, Any]:+ restored = dict(new_parameters)+ for key in SECRET_EXTRA_PARAMETER_KEYS:+ new_value = restored.get(key)+ existing_value = existing_parameters.get(key)+ if isinstance(new_value, dict) and isinstance(existing_value, dict):+ restored[key] = {+ name: (existing_value[name] if value == CUSTOM_LLM_API_KEY_MASK and name in existing_value else value)+ for name, value in new_value.items()+ }+ return restored++def custom_llm_response_from_org_auth_token(token: OrganizationAuthToken) -> CustomLLM:custom_llm = custom_llm_from_org_auth_token(token)+ config_updates: dict[str, Any] = {}if custom_llm.config.api_key:- custom_llm.config = custom_llm.config.model_copy(update={"api_key": CUSTOM_LLM_API_KEY_MASK})+ config_updates["api_key"] = CUSTOM_LLM_API_KEY_MASK+ masked_extra = _mask_secret_extra_parameters(custom_llm.config.extra_parameters)+ if masked_extra != custom_llm.config.extra_parameters:+ config_updates["extra_parameters"] = masked_extra+ if config_updates:+ custom_llm.config = custom_llm.config.model_copy(update=config_updates)return custom_llm+++def config_with_preserved_secrets(new_config: CustomLLMConfig, existing_config: CustomLLMConfig) -> CustomLLMConfig:+ """Restore masked secrets a client saved back unchanged (top-level api_key and secret headers)."""+ config_updates: dict[str, Any] = {}+ if new_config.api_key == CUSTOM_LLM_API_KEY_MASK:+ config_updates["api_key"] = existing_config.api_key+ restored_extra = _restore_secret_extra_parameters(new_config.extra_parameters, existing_config.extra_parameters)+ if restored_extra != new_config.extra_parameters:+ config_updates["extra_parameters"] = restored_extra+ if not config_updates:+ return new_config+ return CustomLLMConfig.model_validate({**new_config.model_dump(), **config_updates})diff --git a/skyvern/webeye/real_browser_manager.py b/skyvern/webeye/real_browser_manager.pyindex 03c123f19..425acd6f0 100644--- a/skyvern/webeye/real_browser_manager.py+++ b/skyvern/webeye/real_browser_manager.py@@ -572,9 +572,29 @@ class RealBrowserManager(BrowserManager):# fan-out) can therefore find an earlier, already-completed sibling's torn-down# browser here. This early-return path skips get_or_create_page, so returning a# page-less state would fail the run's first browser block with a missing page.- # Only adopt the inherited browser when it still has a working page; otherwise- # drop the stale entry and fall through to create a fresh browser for this run.- if await browser_state.get_working_page() is not None:+ working_page = await browser_state.get_working_page()+ if working_page is None and browser_state.is_connected():+ # The inherited browser is still live but its last valid tab was closed+ # (e.g. a use_parent_browser_session child whose prior run closed the last+ # page). Recreate a page in the SAME context so the child keeps the parent's+ # cookies/session, instead of orphaning the live browser and starting fresh.+ LOG.info(+ "Inherited parent browser is live but has no working page; recreating a page in the same context",+ workflow_run_id=workflow_run_id,+ parent_workflow_run_id=parent_workflow_run_id,+ )+ await browser_state.get_or_create_page(+ proxy_location=workflow_run.proxy_location,+ workflow_run_id=workflow_run_id,+ workflow_permanent_id=workflow_run.workflow_permanent_id,+ organization_id=workflow_run.organization_id,+ extra_http_headers=workflow_run.extra_http_headers,+ cdp_connect_headers=workflow_run.cdp_connect_headers,+ browser_address=workflow_run.browser_address,+ browser_profile_id=browser_profile_id,+ )+ working_page = await browser_state.get_working_page()+ if working_page is not None:# always keep the browser state for the workflow run and the parent workflow run syncedself.pages[workflow_run_id] = browser_stateif parent_workflow_run_id:@@ -588,8 +608,10 @@ class RealBrowserManager(BrowserManager):organization_id=workflow_run.organization_id,)return await _on_browser_state_acquired(browser_state, workflow_run_id)+ # The inherited state is genuinely torn down (disconnected and page-less).+ # Drop the stale entry and fall through to create a fresh browser for this run.LOG.warning(- "Inherited parent browser state has no working page; creating a fresh browser",+ "Inherited parent browser state is torn down; creating a fresh browser",workflow_run_id=workflow_run_id,parent_workflow_run_id=parent_workflow_run_id,)diff --git a/tests/unit/test_custom_llms.py b/tests/unit/test_custom_llms.pyindex f1a4feed0..7303c185a 100644--- a/tests/unit/test_custom_llms.py+++ b/tests/unit/test_custom_llms.py@@ -244,6 +244,68 @@ async def test_update_custom_llm_preserves_masked_api_key(deregister_custom_llm_config(custom_llm_id)+async def test_custom_llm_masks_and_preserves_secret_extra_headers(+ fake_organizations: FakeOrganizationsRepository,+) -> None:+ org = _org()+ secret_headers = {"Authorization": "Bearer super-secret", "X-API-Key": "sk-nested"}+ masked_headers = {name: CUSTOM_LLM_API_KEY_MASK for name in secret_headers}++ create_response = await routes.create_custom_llm(+ CustomLLMCreateRequest(+ config=CustomLLMConfig(+ display_name="Gemini Flex",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key="test-key",+ extra_parameters={"service_tier": "flex", "extra_headers": dict(secret_headers)},+ )+ ),+ org,+ )+ custom_llm_id = create_response.custom_llm.id++ try:+ # Nested header credentials are masked on output, non-secret passthrough stays visible.+ assert create_response.custom_llm.config.extra_parameters["extra_headers"] == masked_headers+ assert create_response.custom_llm.config.extra_parameters["service_tier"] == "flex"+ assert create_response.custom_llm.config.api_key == CUSTOM_LLM_API_KEY_MASK++ list_response = await routes.list_custom_llms(org)+ assert list_response.custom_llms[0].config.extra_parameters["extra_headers"] == masked_headers++ # The registry keeps the real credentials so requests actually authenticate.+ registered = LLMConfigRegistry.get_config(custom_llm_key(custom_llm_id))+ assert registered.litellm_params+ assert registered.litellm_params["extra_headers"] == secret_headers++ # A no-op save that echoes the masked headers back restores the stored credentials.+ update_response = await routes.update_custom_llm(+ CustomLLMUpdateRequest(+ config=CustomLLMConfig(+ display_name="Gemini Flex",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key=CUSTOM_LLM_API_KEY_MASK,+ extra_parameters={"service_tier": "flex", "extra_headers": dict(masked_headers)},+ )+ ),+ custom_llm_id,+ org,+ )+ assert update_response.custom_llm.config.extra_parameters["extra_headers"] == masked_headers++ stored_config = CustomLLMConfig.model_validate_json(fake_organizations.tokens[0].token)+ assert stored_config.extra_parameters["extra_headers"] == secret_headers+ assert stored_config.api_key == "test-key"+ registered_after = LLMConfigRegistry.get_config(custom_llm_key(custom_llm_id))+ assert registered_after.litellm_params+ assert registered_after.litellm_params["extra_headers"] == secret_headers+ finally:+ deregister_custom_llm_config(custom_llm_id)++@pytest.mark.asyncioasync def test_models_route_lists_only_current_org_custom_llms_with_unique_labels(fake_organizations: FakeOrganizationsRepository,@@ -692,6 +754,142 @@ def test_task_v2_selected_non_custom_model_override_is_intentional(monkeypatch:assert task_v2_service._get_task_v2_llm_api_handler(task_v2) is selected_handler+def test_custom_llm_extra_parameters_flow_into_litellm_params() -> None:+ custom_llm_id = "oat_custom_extra_params"+ register_custom_llm_config(+ custom_llm_id,+ "o_test",+ CustomLLMConfig(+ display_name="Gemini Flex",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key="test-key",+ extra_parameters={+ "service_tier": "flex",+ "thinking": {"type": "enabled", "budget_tokens": 1024},+ "extra_headers": {"X-Trace": "on"},+ },+ ),+ )++ try:+ llm_config = LLMConfigRegistry.get_config(custom_llm_key(custom_llm_id))+ finally:+ deregister_custom_llm_config(custom_llm_id)++ assert llm_config.model_name == "gemini/gemini-2.5-flash"+ assert llm_config.litellm_params+ assert llm_config.litellm_params["service_tier"] == "flex"+ assert llm_config.litellm_params["thinking"] == {"type": "enabled", "budget_tokens": 1024}+ assert llm_config.litellm_params["extra_headers"] == {"X-Trace": "on"}+ # Provider-managed connection params survive the passthrough merge.+ assert llm_config.litellm_params["api_key"] == "test-key"+++def test_gemini_provider_requires_api_key() -> None:+ with pytest.raises(ValueError, match="api_key is required for Gemini"):+ CustomLLMConfig(+ display_name="Gemini",+ provider="gemini",+ model_name="gemini-2.5-flash",+ )+++ "reserved_key",+ ["model", "api_key", "api_base", "messages", "MODEL_INFO", " api_key ", "drop_params", "stream", "tools"],+)+def test_custom_llm_extra_parameters_reject_reserved_keys(reserved_key: str) -> None:+ with pytest.raises(ValueError, match="reserved"):+ CustomLLMConfig(+ display_name="Reserved",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key="test-key",+ extra_parameters={reserved_key: "value"},+ )+++def test_custom_llm_extra_parameters_reject_too_many() -> None:+ with pytest.raises(ValueError, match="at most 30 keys"):+ CustomLLMConfig(+ display_name="Too Many",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key="test-key",+ extra_parameters={f"param_{index}": index for index in range(31)},+ )+++def test_custom_llm_extra_parameters_reject_oversized() -> None:+ with pytest.raises(ValueError, match="bytes"):+ CustomLLMConfig(+ display_name="Too Big",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key="test-key",+ extra_parameters={"blob": "x" * 11_000},+ )+++def test_custom_llm_passthrough_parameters_excludes_connection_keys() -> None:+ from skyvern.forge.sdk.api.llm.custom_llm_registry import custom_llm_passthrough_parameters++ params = {+ "api_key": "k",+ "api_base": "https://openrouter.ai/api/v1",+ "api_version": "v",+ "model_info": {"model_name": "m"},+ "top_p": 0.2,+ "extra_headers": {"X-Trace": "on"},+ }+ assert custom_llm_passthrough_parameters(params) == {"top_p": 0.2, "extra_headers": {"X-Trace": "on"}}+ assert custom_llm_passthrough_parameters(None) == {}+++def test_custom_gemini_thinking_budget_is_owned_and_not_overwritten() -> None:+ custom_llm_id = "oat_custom_gemini_thinking"+ register_custom_llm_config(+ custom_llm_id,+ "o_test",+ CustomLLMConfig(+ display_name="Gemini Thinking",+ provider="gemini",+ model_name="gemini-2.5-flash",+ api_key="test-key",+ extra_parameters={"thinking": {"type": "enabled", "budget_tokens": 4096}},+ ),+ )++ try:+ llm_key = custom_llm_key(custom_llm_id)+ llm_config = LLMConfigRegistry.get_config(llm_key)+ # Replicate the single-handler merge: get_api_parameters + the shallow litellm_params update+ # that shares the nested thinking dict retained on the frozen config.+ active_parameters: dict = {}+ active_parameters.update(LLMAPIHandlerFactory.get_api_parameters(llm_config))+ active_parameters.update(llm_config.litellm_params)++ # The guard recognizes the customer-owned budget, so the handler skips the default+ # optimization and the customer's 4096 budget reaches the provider unchanged.+ assert LLMAPIHandlerFactory._custom_llm_owns_thinking(llm_key, active_parameters) is True+ assert active_parameters["thinking"]["budget_tokens"] == 4096++ # Sanity: had the optimization run, it would both clobber the budget and mutate the shared+ # dict retained on llm_config.litellm_params — which is exactly what the guard prevents.+ LLMAPIHandlerFactory._apply_gemini_thinking_optimization(active_parameters, 128, llm_config, "extract-action")+ assert active_parameters["thinking"]["budget_tokens"] == 128+ assert llm_config.litellm_params["thinking"]["budget_tokens"] == 128+ finally:+ deregister_custom_llm_config(custom_llm_id)+++def test_non_custom_key_never_owns_thinking() -> None:+ assert (+ LLMAPIHandlerFactory._custom_llm_owns_thinking("GEMINI_2_5_FLASH", {"thinking": {"budget_tokens": 1}}) is False+ )++def test_custom_ollama_chat_models_skip_max_token_parameters() -> None:custom_llm_id = "oat_custom_ollama_params"register_custom_llm_config(diff --git a/tests/unit/test_forge_log_redaction.py b/tests/unit/test_forge_log_redaction.pyindex 2cab6ab97..fc23a9298 100644--- a/tests/unit/test_forge_log_redaction.py+++ b/tests/unit/test_forge_log_redaction.py@@ -1,13 +1,33 @@import json+import logging+import subprocess+import sys+import textwrap+import timefrom collections.abc import Iterator+from types import MappingProxyTypeimport pytest-+import structlog+from pydantic import BaseModel++from skyvern.forge.log_redaction import (+ redact_bearer_tokens_in_text,+ redact_sensitive_fields,+ strip_artifact_url_query,+)from skyvern.forge.sdk.copilot import secret_scrubfrom skyvern.forge.sdk.copilot.secret_scrub import REDACTED_SECRET_PLACEHOLDER-from skyvern.forge.sdk.forge_log import redact_bearer_tokens, redact_registered_secrets+from skyvern.forge.sdk.forge_log import (+ compact_action_objects,+ redact_bearer_tokens,+ redact_registered_secrets,+ redact_sensitive_event_fields,+ setup_logger,+)_FAKE_CREDENTIAL = "fake-pa55w0rd-7x9"+_REDACTED = "****"@pytest.fixture(autouse=True)@@ -114,3 +134,367 @@ def test_redacts_a_credential_inside_a_tuple_value() -> None:out = redact_registered_secrets(None, "info", event) # type: ignore[arg-type]assert out["pair"] == ("user", REDACTED_SECRET_PLACEHOLDER)+++def test_redacts_authorization_bearer_header_value() -> None:+ event = {"headers_line": "Authorization: Bearer eyJhbGciOi.JIUzI1NiJ9.sig123"}+ out = redact_bearer_tokens(None, "error", event) # type: ignore[arg-type]+ assert "eyJhbGciOi" not in out["headers_line"]+ assert out["headers_line"] == "Authorization: Bearer <redacted>"+++def test_redacts_bare_bearer_credential_in_exception_string() -> None:+ event = {"event": "HTTPError 401 while calling api with Bearer sk-abc123DEF456ghi"}+ out = redact_bearer_tokens(None, "exception", event) # type: ignore[arg-type]+ assert "sk-abc123DEF456ghi" not in out["event"]+ assert "Bearer <redacted>" in out["event"]+++def test_bearer_prose_is_not_redacted() -> None:+ event = {"event": "Bearer authentication required"}+ out = redact_bearer_tokens(None, "warning", event) # type: ignore[arg-type]+ assert out["event"] == "Bearer authentication required"+++def test_masks_top_level_sensitive_kwarg() -> None:+ event = {"event": "auth failed", "authorization": "Bearer eyJabc.def.ghi"}+ out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]+ assert out["authorization"] == _REDACTED+ assert out["event"] == "auth failed"+++def test_masks_authorization_header_inside_headers_kwarg() -> None:+ event = {+ "event": "webhook failed",+ "headers": {"Authorization": "Bearer secrettoken", "Content-Type": "application/json"},+ }+ out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]+ assert out["headers"]["Authorization"] == _REDACTED+ assert out["headers"]["Content-Type"] == "application/json"+++def test_masks_extra_http_headers_in_task_payload() -> None:+ event = {+ "event": "Failed to send webhook",+ "task": {+ "task_id": "tsk_1",+ "url": "https://example.com",+ "extra_http_headers": {"X-Custom-Auth": "Bearer customsecret"},+ },+ }+ out = redact_sensitive_event_fields(None, "exception", event) # type: ignore[arg-type]+ # Whole customer header dict is masked regardless of its inner (custom) key names.+ assert out["task"]["extra_http_headers"] == _REDACTED+ assert out["task"]["task_id"] == "tsk_1"+ assert out["task"]["url"] == "https://example.com"+++def test_masks_deeply_nested_credentials() -> None:+ event = {"event": "x", "payload": {"user": {"name": "bob", "credentials": [{"token": "abc123"}]}}}+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert out["payload"]["user"]["credentials"][0]["token"] == _REDACTED+ assert out["payload"]["user"]["name"] == "bob"+++def test_passes_through_non_sensitive_kwargs() -> None:+ event = {"event": "ok", "count": 3, "task_id": "tsk_1", "status": "failed"}+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert out == event+++def test_leaves_plain_string_values_untouched() -> None:+ # Plain string kwargs are handled by the bearer / registered-secret redactors,+ # not this one; it must not rewrite them (e.g. strip artifact-URL queries).+ event = {"event": "GET /v1/artifacts/a1/content?sig=xyz", "note": "Bearer abc123DEF"}+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert out == event+++def test_webhook_failure_event_is_fully_redacted_through_processors() -> None:+ # Composed in the exact order setup_logger installs them: redact_bearer_tokens+ # first (top-level strings only), then redact_sensitive_event_fields (recurses+ # into nested containers). ``x_trace`` holds a bearer under a NON-sensitive key+ # name, so nothing but the field redactor's nested-string handling can catch it —+ # the case a reverse-order / sensitive-key-only test would have missed.+ event = {+ "event": "Failed to send webhook",+ "headers": {+ "Authorization": "Bearer eyJhbGci.payload.sig",+ "x_trace": "retried with Bearer benignkey1234tok",+ },+ "payload": {+ "navigation_goal": "log in",+ "extra_http_headers": {"Authorization": "Bearer topsecrettoken123"},+ },+ "raw": "POST failed, sent header Authorization: Bearer leakedtoken12345",+ }+ out = redact_bearer_tokens(None, "exception", event) # type: ignore[arg-type]+ out = redact_sensitive_event_fields(None, "exception", out) # type: ignore[arg-type]+ dumped = json.dumps(out)+ assert "eyJhbGci" not in dumped+ assert "topsecrettoken123" not in dumped+ assert "leakedtoken12345" not in dumped+ assert "benignkey1234tok" not in dumped+ assert out["headers"]["Authorization"] == _REDACTED+ assert out["headers"]["x_trace"] == "retried with Bearer <redacted>"+ assert out["payload"]["extra_http_headers"] == _REDACTED+ assert "Bearer <redacted>" in out["raw"]+++def test_logging_works_when_starlette_is_absent() -> None:+ """Core `pip install skyvern` has no starlette — the field redactor must not need it."""+ script = textwrap.dedent(+ """+ import sys++ class _BlockStarlette:+ def find_spec(self, name, path=None, target=None):+ if name == "starlette" or name.startswith("starlette."):+ raise ModuleNotFoundError(f"No module named '{name}'")+ return None++ sys.meta_path.insert(0, _BlockStarlette())++ import structlog+ from skyvern.forge.sdk.forge_log import setup_logger++ setup_logger()+ structlog.get_logger().error("boom", headers={"Authorization": "Bearer test-token-123"})+ """+ )+ result = subprocess.run([sys.executable, "-c", script], capture_output=True, text=True)+ output = result.stdout + result.stderr++ assert result.returncode == 0, output+ assert "boom" in output, f"log line was never emitted: {output}"+ assert "test-token-123" not in output+++def test_tolerates_non_string_dict_keys() -> None:+ event = {"event": "x", "status_counts": {200: 5}, "nested": {"by_code": {404: 1}}}+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert out["status_counts"] == {200: 5}+ assert out["nested"]["by_code"] == {404: 1}+++def test_masks_cookie_and_x_api_key_alongside_authorization() -> None:+ event = {+ "event": "api.raw_request",+ "headers": {"Authorization": "Bearer t", "Cookie": "session=abc123", "X-Api-Key": "key-abc123"},+ }+ out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]+ assert out["headers"] == {"Authorization": _REDACTED, "Cookie": _REDACTED, "X-Api-Key": _REDACTED}+++def test_masks_cdp_connect_headers_and_cached_totp() -> None:+ event = {+ "event": "Cached TOTP has expired during multi-field sequence",+ "cached_totp": "123456",+ "cdp_connect_headers": {"X-Provider-Auth": "test-token-123"},+ }+ out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]+ assert out["cached_totp"] == _REDACTED+ assert out["cdp_connect_headers"] == _REDACTED+++ ("url", "expected"),+ [+ # Standard-base64 (`+ / =`) and opaque (`~`) tokens used to truncate the match at+ # the first such character, leaving the token TAIL in the line — and because the+ # match consumed the literal `Bearer`, the credential regex found nothing to clean.+ ("wss://h/v1/stream?token=Bearer%20abcd+efgh/ijkl==", "wss://h/v1/stream?token=<redacted>"),+ ("connect failed ?token=Bearer sk~opaque+tail/here==", "connect failed ?token=<redacted>"),+ ("?token=Bearer%20eyJhbGciOi.JIUzI1NiJ9.sig-_123&client_id=abc", "?token=<redacted>&client_id=abc"),+ ],+)+def test_redacts_whole_bearer_token_in_query_string(url: str, expected: str) -> None:+ out = redact_bearer_tokens(None, "error", {"event": url}) # type: ignore[arg-type]+ assert out["event"] == expected+++class _FakeTaskModel(BaseModel):+ task_id: str+ extra_http_headers: dict[str, str] | None = None+++def test_masks_sensitive_fields_inside_a_model_kwarg() -> None:+ """A model kwarg is rendered in full by the formatter, so it has to be redacted too."""+ event = {"event": "x", "task": _FakeTaskModel(task_id="tsk_1", extra_http_headers={"X-Auth": "test-token-123"})}+ out = redact_sensitive_event_fields(None, "exception", event) # type: ignore[arg-type]+ assert "test-token-123" not in json.dumps(out, default=str)+ assert out["task"]["extra_http_headers"] == _REDACTED+ assert out["task"]["task_id"] == "tsk_1"+++def test_masks_sensitive_fields_inside_tuple_and_set_kwargs() -> None:+ event = {"event": "x", "pair": ({"token": "test-token-123"},), "names": {"alpha", "beta"}}+ out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]+ assert out["pair"] == ({"token": _REDACTED},)+ assert out["names"] == {"alpha", "beta"}+++def test_artifact_url_query_stripping_stays_linear_on_long_runs() -> None:+ """The old optional `scheme://` prefix backtracked at every start position (~5 s here)."""+ payload = "A" * 100_000+ start = time.perf_counter()+ assert strip_artifact_url_query(payload) == payload+ assert time.perf_counter() - start < 1.0+++ ("value", "expected"),+ [+ ("https://cdn.test/v1/artifacts/a1/content?exp=1&sig=z tail", "https://cdn.test/v1/artifacts/a1/content tail"),+ ("/v1/artifacts/a1/content/?kid=k", "/v1/artifacts/a1/content/"),+ ("see <https://h/v1/artifacts/a1/content?sig=x>", "see <https://h/v1/artifacts/a1/content>"),+ ("no artifact url here ?sig=x", "no artifact url here ?sig=x"),+ ],+)+def test_artifact_url_query_stripping_behavior_is_unchanged(value: str, expected: str) -> None:+ assert strip_artifact_url_query(value) == expected+++class _FakeAction(BaseModel):+ action_id: str+ action_type: str+ element_id: str+ reasoning: str+++def test_action_compaction_runs_before_field_redaction() -> None:+ """Redaction expands models into full dicts, so compaction (a volume control) must run first."""+ action = _FakeAction(action_id="act_1", action_type="click", element_id="el_1", reasoning="x" * 500)+ event: dict = {"event": "executing action", "action": action}++ out = redact_sensitive_event_fields(None, "info", compact_action_objects(None, "info", event)) # type: ignore[arg-type]++ assert out["action"] == {"id": "act_1", "type": "click", "element_id": "el_1"}+++def test_setup_logger_pins_redactor_processor_order() -> None:+ """The console/JSON chains repeat the same redactors with no comment. Pin their+ relative order so a reorder — e.g. running the field redactor before compaction,+ or dropping bearer redaction — fails loudly rather than silently leaking."""+ root = logging.getLogger()+ saved_config = structlog.get_config()+ saved_handlers = root.handlers[:]+ saved_level = root.level+ try:+ setup_logger()+ names = [getattr(p, "__name__", type(p).__name__) for p in structlog.get_config()["processors"]]+ assert "redact_bearer_tokens" in names+ assert "compact_action_objects" in names+ assert "redact_sensitive_event_fields" in names+ # Bearer redaction runs on top-level strings; the field redactor recurses into+ # nested containers. Both must precede the field redactor for the chain to be total.+ assert names.index("redact_bearer_tokens") < names.index("redact_sensitive_event_fields")+ assert names.index("compact_action_objects") < names.index("redact_sensitive_event_fields")+ finally:+ structlog.configure(**saved_config)+ root.handlers[:] = saved_handlers+ root.setLevel(saved_level)+++def test_input_text_action_otp_value_is_masked_through_field_redactor() -> None:+ """model_dump bypasses InputTextAction.__repr__ OTP masking, so previous_action=+ kwargs would render the live code / identifier in the clear without re-applying it."""+ from skyvern.webeye.actions.actions import InputTextAction++ action = InputTextAction(+ element_id="el_1",+ text="483920",+ totp_code_required=True,+ totp_identifier="[email protected]",+ totp_url="https://otp.example.com/code",+ )+ out = redact_sensitive_fields(action)+ dumped = json.dumps(out, default=str)+ assert "483920" not in dumped+ assert "[email protected]" not in dumped+ assert "otp.example.com" not in dumped+ assert out["text"] == "<redacted otp value>"+ assert out["totp_identifier"] == _REDACTED+ assert out["totp_url"] == _REDACTED+++def test_verification_code_field_is_masked() -> None:+ """handler.py logs verification_code=action.verification_code at INFO."""+ event = {"event": "Setting verification code in skyvern context", "verification_code": "998877"}+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert out["verification_code"] == _REDACTED+++def test_nested_bearer_under_non_sensitive_key_is_redacted() -> None:+ """A bearer inside a string under a benign key name is caught only by the field+ redactor's nested-string handling — the middleware would not classify the key."""+ event = {"event": "http request", "headers": {"X-Trace-Note": "sent Bearer sk-abc123DEF456ghiJKL"}}+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert "sk-abc123DEF456ghiJKL" not in json.dumps(out)+ assert out["headers"]["X-Trace-Note"] == "sent Bearer <redacted>"+++def test_proxy_authorization_and_set_cookie_header_keys_are_masked() -> None:+ event = {+ "event": "Executing HTTP request",+ "headers": {"Proxy-Authorization": "Bearer sk-proxytoken", "Set-Cookie": "session=secret; HttpOnly"},+ }+ out = redact_sensitive_event_fields(None, "info", event) # type: ignore[arg-type]+ assert out["headers"]["Proxy-Authorization"] == _REDACTED+ assert out["headers"]["Set-Cookie"] == _REDACTED+++ ("text", "expected"),+ [+ # all-alpha token in an Authorization header context — no non-alpha char, so the+ # bare-Bearer prose heuristic skips it, but the header context redacts it anyway.+ ("Authorization: Bearer abcdefghijklmnopqrst", "Authorization: Bearer <redacted>"),+ # below the 8-char minimum the bare heuristic also skips it; header context does not.+ ("authorization: Bearer short12", "authorization: Bearer <redacted>"),+ # dict-repr header shape.+ ("'proxy-authorization': 'Bearer plaintokenvalue'", "'proxy-authorization': 'Bearer <redacted>'"),+ ],+)+def test_authorization_header_bearer_redacted_regardless_of_token_shape(text: str, expected: str) -> None:+ assert redact_bearer_tokens_in_text(text) == expected+++def test_bare_all_alpha_bearer_prose_is_preserved() -> None:+ """With no header context the prose heuristic must still leave 'Bearer <word>' alone."""+ assert redact_bearer_tokens_in_text("please use Bearer authentication") == "please use Bearer authentication"+++def test_non_dict_mapping_is_redacted() -> None:+ """isinstance(obj, dict) missed httpx/starlette Headers, MappingProxyType, CIMultiDict."""+ mapping = MappingProxyType({"Authorization": "Bearer secrettok", "trace_id": "t1"})+ out = redact_sensitive_fields(mapping)+ assert out["Authorization"] == _REDACTED+ assert out["trace_id"] == "t1"+++def test_cyclic_container_redaction_is_bounded() -> None:+ """Two self-references used to fan out to O(breadth^21) rebuilds (~6.5 s); the id()+ memo keeps the walk linear."""+ node: dict = {"token": "leaked-secret", "name": "outer"}+ node["self"] = node+ node["also_self"] = node+ start = time.perf_counter()+ out = redact_sensitive_fields(node)+ assert time.perf_counter() - start < 1.0+ assert out["token"] == _REDACTED+ assert out["name"] == "outer"+++def test_field_redactor_fails_closed_when_a_container_raises() -> None:+ """A caller-supplied container whose iteration raises must not take down the log+ call; the kwarg fails closed to the redaction placeholder instead."""++ class _ExplodingMapping(dict):+ def items(self): # type: ignore[override]+ raise RuntimeError("boom")++ event = {"event": "x", "payload": _ExplodingMapping({"token": "secret"}), "keep": "ok"}+ out = redact_sensitive_event_fields(None, "error", event) # type: ignore[arg-type]+ assert out["payload"] == _REDACTED+ assert out["keep"] == "ok"diff --git a/tests/unit/test_real_browser_manager.py b/tests/unit/test_real_browser_manager.pyindex 23d4868ca..1e6d5f59d 100644--- a/tests/unit/test_real_browser_manager.py+++ b/tests/unit/test_real_browser_manager.py@@ -193,6 +193,7 @@ async def test_child_run_does_not_adopt_stale_sibling_browser_without_page() -># Sibling C1 completed and left a torn-down browser under the shared parent key.stale_state = MagicMock()stale_state.get_working_page = AsyncMock(return_value=None)+ stale_state.is_connected = MagicMock(return_value=False)manager.pages["wfr_parent"] = stale_stateworkflow_run = make_workflow_run("wfr_child_2", parent_workflow_run_id="wfr_parent")@@ -218,6 +219,42 @@ async def test_child_run_does_not_adopt_stale_sibling_browser_without_page() ->assert manager.pages["wfr_parent"] is fresh_state+async def test_child_run_recovers_live_inherited_browser_without_page() -> None:+ """A ``use_parent_browser_session`` child inherits the parent's in-memory browser via the+ shared parent key. When that browser is still live but its last valid tab was closed,+ ``get_working_page()`` returns ``None`` even though the context is connected. The manager+ must recreate a page in the SAME context (preserving the parent's cookies/session) instead+ of evicting the live browser and starting a fresh one — which would orphan the parent's+ browser and lose its session.+ """+ manager = RealBrowserManager()+ # Parent's live in-memory browser, currently tab-less (last page was closed).+ live_state = MagicMock()+ live_state.get_working_page = AsyncMock(side_effect=[None, MagicMock()])+ live_state.is_connected = MagicMock(return_value=True)+ live_state.get_or_create_page = AsyncMock()+ manager.pages["wfr_parent"] = live_state++ workflow_run = make_workflow_run("wfr_child", parent_workflow_run_id="wfr_parent")++ with patch.object(manager, "_create_browser_state", new=AsyncMock()) as mock_create:+ result = await manager.get_or_create_for_workflow_run(+ workflow_run=workflow_run,+ url="https://example.com",+ browser_session_id=None,+ )++ # The live inherited browser is adopted, not evicted.+ assert result is live_state+ mock_create.assert_not_awaited()+ # A page is recreated in the existing context so the parent's session is preserved.+ live_state.get_or_create_page.assert_awaited_once()+ # Both entries still point at the live browser so it stays tracked for cleanup.+ assert manager.pages["wfr_child"] is live_state+ assert manager.pages["wfr_parent"] is live_state++def make_task(task_id: str,organization_id: str = "org_test",diff --git a/tests/unit/test_request_logging.py b/tests/unit/test_request_logging.pyindex 52775adcd..280bd33a1 100644--- a/tests/unit/test_request_logging.py+++ b/tests/unit/test_request_logging.py@@ -9,17 +9,21 @@ from fastapi.testclient import TestClientfrom starlette.requests import ClientDisconnectfrom skyvern.forge import request_logging+from skyvern.forge.log_redaction import (+ REDACTED,+ SENSITIVE_FIELDS,+ SENSITIVE_HEADERS,+ is_sensitive_key,+ redact_sensitive_fields,+)from skyvern.forge.request_logging import (_BINARY_PLACEHOLDER,_MAX_BODY_LENGTH,- _REDACTED,_client_ip_from_headers,_is_loggable_content_type,- _is_sensitive_key,_sanitize_body,_sanitize_response_body,log_raw_request_middleware,- redact_sensitive_fields,)# ---------------------------------------------------------------------------@@ -44,15 +48,15 @@ class TestClientIpFromHeaders:# ----------------------------------------------------------------------------# _is_sensitive_key — documents exactly which field names are redacted+# is_sensitive_key — documents exactly which field names are redacted# ---------------------------------------------------------------------------class TestIsSensitiveKey:"""These tests serve as living documentation of the redaction rules.- If you need to add or remove a field, update ``_SENSITIVE_FIELDS`` in- ``request_logging.py`` and add a corresponding test case here.+ If you need to add or remove a field, update ``SENSITIVE_FIELDS`` in+ ``log_redaction.py`` and add a corresponding test case here."""@pytest.mark.parametrize(@@ -78,10 +82,30 @@ class TestIsSensitiveKey:"one_time_code","one_time_password","mfa_code",+ # Credential headers — also classified by SENSITIVE_HEADERS, so they must+ # be masked when the same dict arrives as a log kwarg instead.+ "cookie",+ "Cookie",+ "x-api-key",+ "X-Api-Key",+ # Whole header dicts, masked wholesale because their inner key names are+ # caller-chosen and therefore unmatchable.+ "extra_http_headers",+ "cdp_connect_headers",+ # One-time codes+ "cached_totp",],)def test_sensitive_keys_are_redacted(self, key: str) -> None:- assert _is_sensitive_key(key) is True, f"Expected '{key}' to be sensitive"+ assert is_sensitive_key(key) is True, f"Expected '{key}' to be sensitive"++ @pytest.mark.parametrize("key", [200, None, 3.5, ("a",)])+ def test_non_string_keys_are_not_sensitive(self, key: object) -> None:+ # Reached with arbitrary structlog kwargs; raising here kills the log call.+ assert is_sensitive_key(key) is False++ def test_every_credential_header_is_also_a_sensitive_field(self) -> None:+ assert SENSITIVE_HEADERS <= SENSITIVE_FIELDS@pytest.mark.parametrize("key",@@ -109,7 +133,7 @@ class TestIsSensitiveKey:],)def test_non_sensitive_keys_are_preserved(self, key: str) -> None:- assert _is_sensitive_key(key) is False, f"Expected '{key}' to NOT be sensitive"+ assert is_sensitive_key(key) is False, f"Expected '{key}' to NOT be sensitive"# ---------------------------------------------------------------------------@@ -122,18 +146,18 @@ class TestRedactSensitiveFields:data = {"username": "alice", "password": "secret123"}result = redact_sensitive_fields(data)assert result["username"] == "alice"- assert result["password"] == _REDACTED+ assert result["password"] == REDACTEDdef test_redacts_nested_keys(self) -> None:data = {"user": {"api_key": "key123", "name": "bob"}}result = redact_sensitive_fields(data)- assert result["user"]["api_key"] == _REDACTED+ assert result["user"]["api_key"] == REDACTEDassert result["user"]["name"] == "bob"def test_redacts_in_lists(self) -> None:data = [{"token": "abc"}, {"name": "ok"}]result = redact_sensitive_fields(data)- assert result[0]["token"] == _REDACTED+ assert result[0]["token"] == REDACTEDassert result[1]["name"] == "ok"def test_redacts_various_sensitive_keys(self) -> None:@@ -149,7 +173,7 @@ class TestRedactSensitiveFields:}result = redact_sensitive_fields(data)for key in data:- assert result[key] == _REDACTED, f"Expected {key} to be redacted"+ assert result[key] == REDACTED, f"Expected {key} to be redacted"def test_redacts_totp_and_otp_fields(self) -> None:data = {@@ -161,7 +185,7 @@ class TestRedactSensitiveFields:}result = redact_sensitive_fields(data)for key in data:- assert result[key] == _REDACTED, f"Expected {key} to be redacted"+ assert result[key] == REDACTED, f"Expected {key} to be redacted"def test_preserves_non_sensitive_suffixed_keys(self) -> None:"""Fields like credential_id and page_token must NOT be redacted."""@@ -201,7 +225,7 @@ class TestRedactSensitiveFields:node = result["level"]for _ in range(19):node = node["next"]- assert node["password"] == _REDACTED+ assert node["password"] == REDACTEDassert node["safe"] == "visible"def test_preserves_non_sensitive_values(self) -> None:@@ -225,30 +249,30 @@ class TestRedactSensitiveFields:assert private_value not in result["payload"]assert decoded == {- "private_key": _REDACTED,- "items": [{"status": "ok"}, {"api_key": _REDACTED}],+ "private_key": REDACTED,+ "items": [{"status": "ok"}, {"api_key": REDACTED}],}def test_metadata_preserved_by_default_and_redacted_only_when_requested(self) -> None:payload = {"metadata": {"region": "north", "note": "opaque"}}assert redact_sensitive_fields(payload) == payload- assert redact_sensitive_fields(payload, redact_metadata=True) == {"metadata": _REDACTED}+ assert redact_sensitive_fields(payload, redact_metadata=True) == {"metadata": REDACTED}def test_is_sensitive_key_gates_metadata_behind_flag(self) -> None:- assert _is_sensitive_key("metadata") is False- assert _is_sensitive_key("Metadata", redact_metadata=True) is True- assert _is_sensitive_key("password") is True+ assert is_sensitive_key("metadata") is False+ assert is_sensitive_key("Metadata", redact_metadata=True) is True+ assert is_sensitive_key("password") is Truedef test_redact_metadata_flag_threads_into_nested_and_serialized_values(self) -> None:nested = {"outer": {"metadata": {"k": "v"}, "keep": "me"}}assert redact_sensitive_fields(nested, redact_metadata=True) == {- "outer": {"metadata": _REDACTED, "keep": "me"},+ "outer": {"metadata": REDACTED, "keep": "me"},}serialized = {"payload": json.dumps({"metadata": {"k": "v"}, "ok": 1})}result = redact_sensitive_fields(serialized, redact_metadata=True)- assert json.loads(result["payload"]) == {"metadata": _REDACTED, "ok": 1}+ assert json.loads(result["payload"]) == {"metadata": REDACTED, "ok": 1}def test_preserves_serialized_json_byte_for_byte_when_nothing_redacted(self) -> None:# A non-secret JSON payload must round-trip unchanged: re-serializing would escape non-ASCII and@@ -351,7 +375,7 @@ class TestSanitizeResponseBody:def test_sensitive_endpoint_fully_redacted(self) -> None:request = _make_request("POST", "/api/v1/credentials")result = _sanitize_response_body(request, '{"token": "abc"}', "application/json")- assert result == _REDACTED+ assert result == REDACTEDdef test_empty_body(self) -> None:request = _make_request()@@ -372,8 +396,8 @@ class TestSanitizeResponseBody:result = _sanitize_response_body(request, body, "application/json")parsed = json.loads(result)assert parsed["user"] == "alice"- assert parsed["password"] == _REDACTED- assert parsed["api_key"] == _REDACTED+ assert parsed["password"] == REDACTED+ assert parsed["api_key"] == REDACTEDdef test_json_preserves_non_sensitive_suffixed_keys(self) -> None:"""credential_id and page_token in responses must remain visible for debugging."""@@ -410,12 +434,12 @@ class TestSanitizeResponseBody:def test_sensitive_endpoint_trailing_slash(self) -> None:request = _make_request("POST", "/api/v1/credentials/")result = _sanitize_response_body(request, '{"data": "value"}', "application/json")- assert result == _REDACTED+ assert result == REDACTEDdef test_malformed_json_credential_mutation_response_is_redacted(self) -> None:request = _make_request("PUT", "/api/v1/credentials/cred_123/rotate")result = _sanitize_response_body(request, '{"private_key":"secret"', "application/json")- assert result == _REDACTED+ assert result == REDACTED@pytest.mark.parametrize(("method", "path"),@@ -432,14 +456,14 @@ class TestSanitizeResponseBody:request = _make_request(method, path)body = json.dumps({"code": "123456", "content": "Your code is 123456"})result = _sanitize_response_body(request, body, "application/json")- assert result == _REDACTED+ assert result == REDACTEDclass TestSanitizeBody:def test_sensitive_endpoint_request_fully_redacted(self) -> None:request = _make_request("POST", "/v1/credentials")result = _sanitize_body(request, b'{"password": "hunter2"}', "application/json")- assert result == _REDACTED+ assert result == REDACTED@pytest.mark.parametrize("path",@@ -451,7 +475,7 @@ class TestSanitizeBody:def test_google_oauth_config_request_redacted(self, path: str) -> None:request = _make_request("PUT", path)result = _sanitize_body(request, b'{"client_id": "cid", "client_secret": "secret"}', "application/json")- assert result == _REDACTED+ assert result == REDACTED@pytest.mark.parametrize("path",@@ -463,7 +487,7 @@ class TestSanitizeBody:def test_google_oauth_callback_request_redacted(self, path: str) -> None:request = _make_request("POST", path)result = _sanitize_body(request, b'{"code": "4/0Adeu...", "state": "nonce"}', "application/json")- assert result == _REDACTED+ assert result == REDACTEDdef test_non_sensitive_endpoint_request_preserved(self) -> None:request = _make_request("GET", "/v1/tasks")@@ -480,7 +504,7 @@ class TestSanitizeBody:def test_malformed_json_credential_mutation_request_is_redacted(self, method: str, path: str) -> None:request = _make_request(method, path)result = _sanitize_body(request, b'{"private_key":"secret"', "application/json")- assert result == _REDACTED+ assert result == REDACTEDdef test_malformed_json_unrelated_request_keeps_current_behavior(self) -> None:request = _make_request("POST", "/v1/tasks")@@ -507,7 +531,7 @@ class TestSanitizeBody:request = _make_request(method, path)body = b'{"totp_identifier": "[email protected]", "content": "Your code is 123456"}'result = _sanitize_body(request, body, "application/json")- assert result == _REDACTED+ assert result == REDACTED# ---------------------------------------------------------------------------@@ -576,8 +600,8 @@ class TestMiddlewareLogVolume:assert response.status_code == 200log_mock.info.assert_called_once()- assert log_mock.info.call_args.kwargs["body"] == _REDACTED- assert log_mock.info.call_args.kwargs["response_body"] == _REDACTED+ assert log_mock.info.call_args.kwargs["body"] == REDACTED+ assert log_mock.info.call_args.kwargs["response_body"] == REDACTEDassert secret not in str(log_mock.info.call_args)def test_successful_sensitive_get_keeps_redacted_audit_line(self, log_mock: MagicMock) -> None:@@ -587,7 +611,7 @@ class TestMiddlewareLogVolume:assert response.status_code == 200log_mock.info.assert_called_once()assert log_mock.info.call_args.args[0] == "api.raw_request"- assert log_mock.info.call_args.kwargs["response_body"] == _REDACTED+ assert log_mock.info.call_args.kwargs["response_body"] == REDACTEDdef test_successful_get_is_not_logged(self, log_mock: MagicMock) -> None:client = TestClient(_make_app())