codexLB-up 1.25.0b10__py3-none-any.whl

app/core/openai/strict_schema.py

@@ -0,0 +1,199 @@
+"""Validation for OpenAI strict JSON schema mode.
+
+When ``strict: true`` is set on a ``response_format`` (or ``text.format``)
+of type ``json_schema``, the upstream Codex/Responses API enforces several
+constraints on the schema (mirroring the public OpenAI Structured Outputs
+policy). The most common violations are:
+
+* every ``object`` schema must have ``additionalProperties: false``;
+* every property defined under ``properties`` must be listed in
+  ``required``;
+* schema nodes must have a ``type`` key (no empty ``{}``).
+
+When these violations reach the Codex backend over a websocket, the
+session is terminated with ``close_code=1000`` and the proxy currently
+surfaces a generic ``stream_incomplete`` 502 instead of the upstream
+``invalid_json_schema`` detail. We detect these violations locally so the
+client receives a 400 with the OpenAI-style error message before any
+upstream request is opened.
+
+Only the strict-mode constraints are enforced here. Schemas with
+``strict`` unset or ``strict: false`` pass through unchanged.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass
+
+from app.core.types import JsonValue
+from app.core.utils.json_guards import is_json_list, is_json_mapping
+
+
+@dataclass(frozen=True)
+class StrictSchemaError:
+    """A single strict-mode schema violation, formatted for the API."""
+
+    code: str
+    message: str
+    param: str
+
+
+def validate_strict_json_schema(
+    schema: JsonValue,
+    *,
+    name: str | None,
+    param: str,
+) -> StrictSchemaError | None:
+    """Return the first strict-mode violation in ``schema`` or ``None``.
+
+    The returned message mirrors the upstream OpenAI Responses API format:
+
+        Invalid schema for response_format '<name>':
+        In context=(<path>), <reason>.
+    """
+
+    label = name or "response_format"
+    violation = _find_violation(schema, ())
+    if violation is None:
+        return None
+    context_path, reason = violation
+    rendered_context = _render_context(context_path)
+    message = f"Invalid schema for response_format '{label}': In context={rendered_context}, {reason}."
+    return StrictSchemaError(
+        code="invalid_json_schema",
+        message=message,
+        param=param,
+    )
+
+
+def validate_strict_function_tool_schema(
+    schema: JsonValue,
+    *,
+    name: str | None,
+    param: str,
+) -> StrictSchemaError | None:
+    """Return the first strict-mode violation in a function tool's parameters.
+
+    The returned envelope mirrors what real OpenAI emits for the same
+    payload — see the ``invalid_function_parameters`` error in their
+    Structured Outputs guide. Specifically:
+
+    * ``code = "invalid_function_parameters"`` (distinct from the
+      ``invalid_json_schema`` envelope used by ``response_format`` /
+      ``text.format``);
+    * ``message`` is rendered as
+      ``Invalid schema for function '<name>': In context=<path>, <reason>.``;
+    * ``param`` is supplied by the caller so chat-completions can point
+      at ``tools[i].function.parameters`` while native Responses-API
+      callers point at ``tools[i].parameters``.
+
+    Re-uses the shared ``_find_violation`` walker so the strict-mode
+    rules stay in lockstep with ``response_format`` / ``text.format``
+    validation.
+    """
+
+    label = name or "function"
+    violation = _find_violation(schema, ())
+    if violation is None:
+        return None
+    context_path, reason = violation
+    rendered_context = _render_context(context_path)
+    message = f"Invalid schema for function '{label}': In context={rendered_context}, {reason}."
+    return StrictSchemaError(
+        code="invalid_function_parameters",
+        message=message,
+        param=param,
+    )
+
+
+def _render_context(path: tuple[str, ...]) -> str:
+    if not path:
+        return "()"
+    parts = ", ".join(f"'{part}'" for part in path)
+    return f"({parts})"
+
+
+def _find_violation(
+    node: JsonValue,
+    path: tuple[str, ...],
+) -> tuple[tuple[str, ...], str] | None:
+    if not is_json_mapping(node):
+        # Non-object nodes (booleans, etc.) are not subject to strict-mode
+        # property checks here.
+        return None
+
+    # Require a ``type`` key on every node we visit. The upstream API
+    # rejects empty ``{}`` schemas in strict mode.
+    if "type" not in node and not _has_combinator(node) and not _is_ref(node):
+        return path, "schema must have a 'type' key"
+
+    schema_type = node.get("type")
+
+    if schema_type == "object" or "properties" in node:
+        additional = node.get("additionalProperties")
+        if additional is not False:
+            return (
+                path,
+                "'additionalProperties' is required to be supplied and to be false",
+            )
+
+        properties = node.get("properties")
+        if is_json_mapping(properties):
+            required_raw = node.get("required")
+            required_set: set[str] = set()
+            if is_json_list(required_raw):
+                required_set = {item for item in required_raw if isinstance(item, str)}
+            missing_required = [str(prop_name) for prop_name in properties.keys() if str(prop_name) not in required_set]
+            if missing_required:
+                missing_list = ", ".join(f"'{name}'" for name in missing_required)
+                return (
+                    path,
+                    "'required' is required to be supplied and to be an array including every key in properties. "
+                    f"Missing {missing_list}",
+                )
+            for prop_name, prop_schema in properties.items():
+                violation = _find_violation(
+                    prop_schema,
+                    path + ("properties", str(prop_name)),
+                )
+                if violation is not None:
+                    return violation
+
+    if schema_type == "array" or "items" in node:
+        items = node.get("items")
+        if items is not None:
+            violation = _find_violation(items, path + ("items",))
+            if violation is not None:
+                return violation
+
+    for combinator in ("anyOf", "oneOf", "allOf"):
+        candidates = node.get(combinator)
+        if is_json_list(candidates):
+            for index, candidate in enumerate(candidates):
+                violation = _find_violation(
+                    candidate,
+                    path + (combinator, str(index)),
+                )
+                if violation is not None:
+                    return violation
+
+    defs = node.get("$defs") or node.get("definitions")
+    if is_json_mapping(defs):
+        for def_name, def_schema in defs.items():
+            violation = _find_violation(
+                def_schema,
+                path + ("$defs", str(def_name)),
+            )
+            if violation is not None:
+                return violation
+
+    return None
+
+
+def _has_combinator(node: Mapping[str, JsonValue]) -> bool:
+    return any(is_json_list(node.get(name)) for name in ("anyOf", "oneOf", "allOf"))
+
+
+def _is_ref(node: Mapping[str, JsonValue]) -> bool:
+    return isinstance(node.get("$ref"), str)

app/core/openai/tool_call_safety.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Mapping
+from typing import cast
+
+from app.core.types import JsonValue
+
+PARALLEL_TOOL_CALL_NAME = "multi_tool_use.parallel"
+HISTORY_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES = frozenset(
+    {
+        "apply_patch",
+        "close_agent",
+        "create_goal",
+        "exec_command",
+        "request_user_input",
+        "resume_agent",
+        "send_input",
+        "spawn_agent",
+        "update_goal",
+        "update_plan",
+        "wait_agent",
+        "write_stdin",
+    }
+)
+CODE_MODE_DOWNSTREAM_SIDE_EFFECT_TOOL_CALL_NAMES = frozenset({"collaboration", "exec"})
+DOWNSTREAM_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES = frozenset(
+    {*HISTORY_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES, *CODE_MODE_DOWNSTREAM_SIDE_EFFECT_TOOL_CALL_NAMES}
+)
+HISTORY_SIDE_EFFECT_TOOL_CALL_NAMES = frozenset(
+    {
+        PARALLEL_TOOL_CALL_NAME,
+        *HISTORY_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES,
+        *(f"functions.{name}" for name in HISTORY_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES),
+    }
+)
+DOWNSTREAM_SIDE_EFFECT_TOOL_CALL_NAMES = frozenset(
+    {
+        PARALLEL_TOOL_CALL_NAME,
+        *DOWNSTREAM_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES,
+        *(f"functions.{name}" for name in DOWNSTREAM_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES),
+    }
+)
+SIDE_EFFECT_TOOL_CALL_ITEM_TYPES = frozenset({"apply_patch_call"})
+PARALLEL_TOOL_USE_DEDUPE_RECIPIENT_NAMES = frozenset(
+    {
+        *(f"functions.{name}" for name in HISTORY_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES),
+        PARALLEL_TOOL_CALL_NAME,
+    }
+)
+PARALLEL_TOOL_USE_SIDE_EFFECT_RECIPIENT_NAMES = frozenset(
+    {
+        *(f"functions.{name}" for name in DOWNSTREAM_DIRECT_SIDE_EFFECT_TOOL_CALL_NAMES),
+        PARALLEL_TOOL_CALL_NAME,
+    }
+)
+
+
+def is_downstream_side_effect_tool_call(name: str | None, argument_value: str) -> bool:
+    """Return whether a named tool call may perform a side effect downstream."""
+
+    if name != PARALLEL_TOOL_CALL_NAME:
+        return name in DOWNSTREAM_SIDE_EFFECT_TOOL_CALL_NAMES
+    try:
+        decoded_arguments = json.loads(argument_value)
+    except json.JSONDecodeError:
+        return False
+    if not isinstance(decoded_arguments, dict):
+        return False
+    tool_uses = decoded_arguments.get("tool_uses")
+    if not isinstance(tool_uses, list):
+        return False
+    for tool_use in cast(list[JsonValue], tool_uses):
+        if not isinstance(tool_use, dict):
+            continue
+        recipient_name = tool_use.get("recipient_name")
+        if isinstance(recipient_name, str) and recipient_name in PARALLEL_TOOL_USE_SIDE_EFFECT_RECIPIENT_NAMES:
+            return True
+    return False
+
+
+def is_downstream_side_effect_tool_call_item(item: Mapping[str, JsonValue]) -> bool:
+    """Classify a Responses history item without depending on proxy modules."""
+
+    item_type = item.get("type")
+    if item_type in SIDE_EFFECT_TOOL_CALL_ITEM_TYPES:
+        return True
+    if item_type == "function_call":
+        argument_value = item.get("arguments")
+    elif item_type == "custom_tool_call":
+        argument_value = item.get("input")
+    else:
+        return False
+    item_name = item.get("name")
+    return (
+        isinstance(item_name, str)
+        and isinstance(argument_value, str)
+        and is_downstream_side_effect_tool_call(item_name, argument_value)
+    )

app/core/openai/v1_requests.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
+
+from app.core.openai.exceptions import ClientPayloadError
+from app.core.openai.message_coercion import coerce_messages
+from app.core.openai.requests import (
+    PassthroughJsonList,
+    PassthroughJsonValue,
+    ResponsesCompactRequest,
+    ResponsesReasoning,
+    ResponsesRequest,
+    ResponsesTextControls,
+    validate_passthrough_depth,
+    validate_tool_types,
+)
+from app.core.types import JsonValue
+
+
+def _validate_optional_messages_array(value: list[JsonValue] | None) -> list[JsonValue] | None:
+    # ``messages`` skips pydantic's ``list`` validation; keep the array check
+    # at field level so the error still names ``param="messages"``.
+    if value is None:
+        return value
+    if not isinstance(value, list):
+        raise ValueError("messages must be an array")
+    validate_passthrough_depth(value)
+    return value
+
+
+class V1ResponsesRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    model: str = Field(min_length=1)
+    messages: PassthroughJsonList | None = None
+    input: PassthroughJsonValue = None
+    instructions: str | None = None
+    tools: PassthroughJsonList = Field(default_factory=list)
+    tool_choice: str | dict[str, JsonValue] | None = None
+    parallel_tool_calls: bool | None = None
+    reasoning: ResponsesReasoning | None = None
+    store: bool | None = None
+    stream: bool | None = None
+    include: list[str] = Field(default_factory=list)
+    service_tier: str | None = None
+    conversation: str | None = None
+    previous_response_id: str | None = None
+    truncation: str | None = None
+    prompt_cache_key: str | None = None
+    text: ResponsesTextControls | None = None
+
+    @field_validator("input")
+    @classmethod
+    def _validate_input_type(cls, value: JsonValue | None) -> JsonValue | None:
+        if value is None:
+            return value
+        if isinstance(value, str):
+            return value
+        if isinstance(value, list):
+            validate_passthrough_depth(value)
+            return value
+        raise ValueError("input must be a string or array")
+
+    @field_validator("messages")
+    @classmethod
+    def _validate_messages_type(cls, value: list[JsonValue] | None) -> list[JsonValue] | None:
+        return _validate_optional_messages_array(value)
+
+    @field_validator("store")
+    @classmethod
+    def _ensure_store_false(cls, value: bool | None) -> bool | None:
+        return False
+
+    @field_validator("tools")
+    @classmethod
+    def _validate_tools(cls, value: list[JsonValue]) -> list[JsonValue]:
+        validated = validate_tool_types(value, allow_builtin_tools=True)
+        validate_passthrough_depth(validated)
+        return validated
+
+    @model_validator(mode="after")
+    def _validate_input(self) -> "V1ResponsesRequest":
+        if self.messages is None and self.input is None:
+            raise ValueError("Provide either 'input' or 'messages'.")
+        if self.messages is not None and self.input not in (None, []):
+            raise ValueError("Provide either 'input' or 'messages', not both.")
+        if self.conversation and self.previous_response_id:
+            raise ValueError("Provide either 'conversation' or 'previous_response_id', not both.")
+        return self
+
+    def to_responses_request(self) -> ResponsesRequest:
+        # The passthrough fields are already plain JSON (validated for shape
+        # by the field validators above), so attach them directly instead of
+        # deep-copying them through ``model_dump``.
+        data = self.model_dump(mode="json", exclude_none=True, exclude={"input", "messages", "tools"})
+        if "tools" in self.model_fields_set:
+            # ``tools`` defaults to ``[]`` via ``default_factory``; handing
+            # ``ResponsesRequest`` an explicit ``"tools": []`` the client
+            # never sent would mark the field as set and forward a
+            # synthesized empty array upstream. Only attach it when the
+            # client sent it (issue #1184); an explicit ``[]`` stays intact.
+            data["tools"] = self.tools
+        messages = self.messages
+        instructions = self.instructions
+        instruction_text = instructions if isinstance(instructions, str) else ""
+        input_value = self.input
+        input_items: list[JsonValue] = input_value if isinstance(input_value, list) else []
+        input_text: str | None = input_value if isinstance(input_value, str) else None
+
+        if messages is not None:
+            try:
+                instruction_text, input_items = coerce_messages(instruction_text, messages)
+            except ClientPayloadError:
+                raise
+            except ValueError as exc:
+                raise ClientPayloadError(str(exc), param="messages") from exc
+
+        data["instructions"] = instruction_text
+        if messages is None and input_text is not None:
+            data["input"] = input_text
+        else:
+            data["input"] = input_items
+        return ResponsesRequest.model_validate(data)
+
+
+class V1ResponsesCompactRequest(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    model: str = Field(min_length=1)
+    messages: PassthroughJsonList | None = None
+    input: PassthroughJsonValue = None
+    instructions: str | None = None
+    reasoning: ResponsesReasoning | None = None
+
+    @model_validator(mode="after")
+    def _validate_input(self) -> "V1ResponsesCompactRequest":
+        if self.messages is None and self.input is None:
+            raise ValueError("Provide either 'input' or 'messages'.")
+        if self.messages is not None and self.input not in (None, []):
+            raise ValueError("Provide either 'input' or 'messages', not both.")
+        return self
+
+    @field_validator("input")
+    @classmethod
+    def _validate_input_type(cls, value: JsonValue | None) -> JsonValue | None:
+        if value is None:
+            return value
+        if isinstance(value, str):
+            return value
+        if isinstance(value, list):
+            validate_passthrough_depth(value)
+            return value
+        raise ValueError("input must be a string or array")
+
+    @field_validator("messages")
+    @classmethod
+    def _validate_messages_type(cls, value: list[JsonValue] | None) -> list[JsonValue] | None:
+        return _validate_optional_messages_array(value)
+
+    def to_compact_request(self) -> ResponsesCompactRequest:
+        data = self.model_dump(mode="json", exclude_none=True, exclude={"input", "messages"})
+        messages = self.messages
+        instructions = self.instructions
+        instruction_text = instructions if isinstance(instructions, str) else ""
+        input_value = self.input
+        input_items: list[JsonValue] = input_value if isinstance(input_value, list) else []
+        input_text: str | None = input_value if isinstance(input_value, str) else None
+
+        if messages is not None:
+            try:
+                instruction_text, input_items = coerce_messages(instruction_text, messages)
+            except ClientPayloadError:
+                raise
+            except ValueError as exc:
+                raise ClientPayloadError(str(exc), param="messages") from exc
+
+        data["instructions"] = instruction_text
+        if messages is None and input_text is not None:
+            data["input"] = input_text
+        else:
+            data["input"] = input_items
+        return ResponsesCompactRequest.model_validate(data)

app/core/plan_types.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import AbstractSet, Final
+
+ACCOUNT_PLAN_TYPES: Final[set[str]] = {
+    "free",
+    "plus",
+    "pro",
+    "prolite",
+    "promax",
+    "team",
+    "business",
+    "enterprise",
+    "edu",
+}
+
+RATE_LIMIT_PLAN_TYPES: Final[set[str]] = {
+    *ACCOUNT_PLAN_TYPES,
+    "guest",
+    "go",
+    "free_workspace",
+    "education",
+    "quorum",
+    "k12",
+}
+
+ACCOUNT_PLAN_EQUIVALENTS: Final[dict[str, frozenset[str]]] = {
+    "prolite": frozenset({"pro"}),
+    "promax": frozenset({"pro"}),
+}
+
+ACCOUNT_PLAN_ALIASES: Final[dict[str, str]] = {
+    "self_serve_business_prolite": "prolite",
+}
+
+
+def _clean_plan_type(value: str | None) -> str | None:
+    if value is None:
+        return None
+    cleaned = value.strip()
+    return cleaned or None
+
+
+def normalize_account_plan_type(value: str | None) -> str | None:
+    cleaned = _clean_plan_type(value)
+    if not cleaned:
+        return None
+    normalized = cleaned.lower()
+    normalized = ACCOUNT_PLAN_ALIASES.get(normalized, normalized)
+    return normalized if normalized in ACCOUNT_PLAN_TYPES else None
+
+
+def canonicalize_account_plan_type(value: str | None) -> str | None:
+    cleaned = _clean_plan_type(value)
+    if not cleaned:
+        return None
+    normalized = normalize_account_plan_type(cleaned)
+    if normalized is not None:
+        return normalized
+    return cleaned
+
+
+def coerce_account_plan_type(value: str | None, default: str) -> str:
+    cleaned = _clean_plan_type(value)
+    if cleaned is None:
+        return default
+    canonical = canonicalize_account_plan_type(cleaned)
+    return canonical if canonical is not None else default
+
+
+def normalize_rate_limit_plan_type(value: str | None) -> str | None:
+    cleaned = _clean_plan_type(value)
+    if not cleaned:
+        return None
+    normalized = normalize_account_plan_type(cleaned) or cleaned.lower()
+    return normalized if normalized in RATE_LIMIT_PLAN_TYPES else None
+
+
+def account_plan_matches_allowed(value: str | None, allowed_plans: AbstractSet[str]) -> bool:
+    cleaned = _clean_plan_type(value)
+    if cleaned is None:
+        return False
+    normalized_allowed = {normalize_account_plan_type(plan) or plan.lower() for plan in allowed_plans}
+    normalized = normalize_account_plan_type(cleaned)
+    candidate = normalized or cleaned.lower()
+    if candidate in normalized_allowed:
+        return True
+    if normalized is None:
+        return False
+    return bool(ACCOUNT_PLAN_EQUIVALENTS.get(normalized, frozenset()) & normalized_allowed)