Skip to content

Automate browser based workflows with AI

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.json
index 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.ts
index 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.tsx
index 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.ts
new file mode 100644
index 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.ts
new file mode 100644
index 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.py
index 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_step
except FailedToNavigateToUrl as e:
diff --git a/skyvern/forge/log_redaction.py b/skyvern/forge/log_redaction.py
new file mode 100644
index 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 obj
diff --git a/skyvern/forge/request_logging.py b/skyvern/forge/request_logging.py
index c85a259e3..d76e7a9ed 100644
--- a/skyvern/forge/request_logging.py
+++ b/skyvern/forge/request_logging.py
@@ -11,6 +11,12 @@ from starlette.requests import ClientDisconnect
from starlette.responses import Response
from 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 hints
from typing import Awaitable, Callable
@@ -19,7 +25,6 @@ if typing.TYPE_CHECKING: # pragma: no cover - import only for type hints
LOG = 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:
continue
sanitized[key] = value
return 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 REDACTED
if 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) -> s
return 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 REDACTED
if body_str is None:
return _BINARY_PLACEHOLDER
if not body_str:
diff --git a/skyvern/forge/sdk/api/llm/api_handler_factory.py b/skyvern/forge/sdk/api/llm/api_handler_factory.py
index 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 app
from skyvern.forge.forge_openai_client import ForgeAsyncHttpxClientWrapper
from skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler, dummy_llm_api_handler
from 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_key
from 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)
+
@staticmethod
def _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_settings
and 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.py
index 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 annotations
import json
+from collections.abc import Mapping
from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
import 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_name
return 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.py
index aff07a88d..28372cc46 100644
--- a/skyvern/forge/sdk/copilot/request_policy.py
+++ b/skyvern/forge/sdk/copilot/request_policy.py
@@ -14,8 +14,8 @@ import structlog
from skyvern.config import settings
from skyvern.forge import app
+from skyvern.forge.log_redaction import redact_sensitive_fields
from skyvern.forge.prompts import prompt_engine
-from skyvern.forge.request_logging import redact_sensitive_fields
from skyvern.forge.sdk.api.llm.api_handler import LLMAPIHandler
from skyvern.forge.sdk.copilot.config import CopilotConfig
from skyvern.forge.sdk.copilot.context import (
diff --git a/skyvern/forge/sdk/copilot/streaming_adapter.py b/skyvern/forge/sdk/copilot/streaming_adapter.py
index 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_fields
from skyvern.forge.sdk.copilot.context import InFlightStreamToolCall
from 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.py
index 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_fields
from skyvern.forge.sdk.core import skyvern_context
if TYPE_CHECKING:
diff --git a/skyvern/forge/sdk/forge_log.py b/skyvern/forge/sdk/forge_log.py
index 610e002a1..07d0c1d90 100644
--- a/skyvern/forge/sdk/forge_log.py
+++ b/skyvern/forge/sdk/forge_log.py
@@ -1,6 +1,5 @@
import logging
import random
-import re
import sys
from pathlib import Path
from types import TracebackType
@@ -11,13 +10,14 @@ from structlog.typing import EventDict
from 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_di
def 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] = REDACTED
return 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.py
index 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.py
index 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 OrganizationAuthTokenType
from skyvern.forge.sdk.db.exceptions import NotFoundError
from skyvern.forge.sdk.routes.routers import base_router
from 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.py
index 87154a9fd..b813d984e 100644
--- a/skyvern/forge/sdk/schemas/custom_llms.py
+++ b/skyvern/forge/sdk/schemas/custom_llms.py
@@ -1,3 +1,4 @@
+import json
from enum import StrEnum
from http import HTTPStatus
from typing import Any
@@ -12,14 +13,42 @@ from skyvern.forge.sdk.settings_manager import SettingsManager
from skyvern.utils.url_validators import validate_url
CUSTOM_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.py
index 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 synced
self.pages[workflow_run_id] = browser_state
if 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.py
index 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.asyncio
async 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.py
index 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 time
from collections.abc import Iterator
+from types import MappingProxyType
import 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_scrub
from 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.py
index 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_state
workflow_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.py
index 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 TestClient
from starlette.requests import ClientDisconnect
from 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"] == REDACTED
def 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"] == REDACTED
assert 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"] == REDACTED
assert 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"] == REDACTED
assert 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 True
def 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 == REDACTED
def 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"] == REDACTED
def 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 == REDACTED
def 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 == REDACTED
class 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 == REDACTED
def 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 == REDACTED
def 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 == 200
log_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"] == REDACTED
assert 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 == 200
log_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"] == REDACTED
def test_successful_get_is_not_logged(self, log_mock: MagicMock) -> None:
client = TestClient(_make_app())