alysis-code 0.13.3__tar.gz → 0.13.4__tar.gz

{alysis_code-0.13.3 → alysis_code-0.13.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alysis-code
-Version: 0.13.3
+Version: 0.13.4
 Summary: Local CLI coding agent powered by any API.
 Project-URL: Changelog, https://github.com/AlysisAi/alysis-code/blob/main/docs/CHANGELOG.md
 Project-URL: Documentation, https://github.com/AlysisAi/alysis-code/tree/main/docs

{alysis_code-0.13.3 → alysis_code-0.13.4}/docs/CHANGELOG.md

@@ -408,6 +408,35 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
   Workspace-target extraction also keeps extensionless dotfiles such as `.npmrc` available to
   verification selection.
 
+## [0.13.4] - 2026-09-05
+
+Model-catalog and TUI-access refresh.
+
+### Added
+
+- Added GPT-6 Astra as the default OpenAI model, with aliases, pricing, context-window,
+  reasoning, OpenRouter, and ChatGPT-subscription metadata.
+- Added newly available first-party and gateway routes for Claude Fable 5.1, Gemini 3.8
+  Flash, Qwen 3.8, GLM-5.3, Kimi K3, Doubao Seed 2.1, DeepSeek V4 snapshots, Grok 4.6,
+  and related hosted variants.
+
+### Changed
+
+- Refreshed every hosted preset's model picker, aliases, validation model, retirement
+  mappings, pricing, context limits, and reasoning contracts against provider catalogs.
+- Updated TUI model labels to preserve vendor naming and made profile pickers show each
+  profile's model, host, active state, retired-model state, and duplicates.
+- Migrated the Perplexity preset from the retiring Sonar Chat Completions endpoint to the
+  Agent API, including hosted web search and saved-profile migration.
+- Replaced the OpenAI economy and validation model with GPT-5.6 Luna and kept
+  GPT-5.3 Codex limited to the Responses preset.
+
+### Fixed
+
+- OpenAI Chat Completions now uses `max_completion_tokens` for GPT-5 and newer models.
+- Native Gemini tool and response schemas are projected onto Gemini's supported OpenAPI
+  subset before requests are sent.
+
 ## [0.13.3] - 2026-08-28
 
 ### Fixed

{alysis_code-0.13.3 → alysis_code-0.13.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "alysis-code"
-version = "0.13.3"
+version = "0.13.4"
 description = "Local CLI coding agent powered by any API."
 readme = "README.md"
 requires-python = ">=3.11"

{alysis_code-0.13.3 → alysis_code-0.13.4}/src/alysis_code/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.13.3"
+__version__ = "0.13.4"

{alysis_code-0.13.3 → alysis_code-0.13.4}/src/alysis_code/cli_impl/tui/config_flow.py

@@ -37,6 +37,8 @@ from ...config import (
 from ...llm.protocols import validate_reasoning_trace_adapter_for_protocol
 from ...profile_presets import (
     PROFILE_PRESETS,
+    canonical_model_alias_for_preset,
+    find_preset_for_profile,
     make_profile_from_preset,
     preset_selection_label,
 )
@@ -184,6 +186,75 @@ def _short_preset_description(preset: Any) -> str:
     return host or "any OpenAI-compatible base URL"
 
 
+def _profile_identity(raw: Any) -> tuple[str, str, str]:
+    """(protocol, normalized base URL, casefolded model) for duplicate detection."""
+    profile = raw if isinstance(raw, dict) else {}
+    protocol = str(profile.get("protocol") or "openai_compat").strip()
+    base_url = str(profile.get("base_url") or "").strip().rstrip("/")
+    model = str(profile.get("default_model") or "").strip().casefold()
+    return protocol, base_url, model
+
+
+def _profile_retired_model_replacement(name: str, raw: Any) -> str:
+    """The catalog's replacement id when a saved profile pins a retired model id.
+
+    Empty when the model is current, unknown, or the profile matches no
+    preset (custom endpoints cannot be judged offline).
+    """
+    profile = raw if isinstance(raw, dict) else {}
+    model = str(profile.get("default_model") or "").strip()
+    if not model:
+        return ""
+    try:
+        spec = ProfileSpec(
+            name=name,
+            protocol=str(profile.get("protocol") or "openai_compat").strip(),
+            base_url=str(profile.get("base_url") or "").strip(),
+            default_model=model,
+        )
+        preset = find_preset_for_profile(spec)
+    except Exception:  # noqa: BLE001 - a malformed saved profile must not break the picker
+        return ""
+    if preset is None:
+        return ""
+    canonical = canonical_model_alias_for_preset(preset, model)
+    return canonical if canonical != model else ""
+
+
+def _profile_row_descriptions(profiles: dict[str, Any], *, active: str | None) -> dict[str, str]:
+    """One summary line per saved profile: ``model · host`` plus what needs attention.
+
+    The bare name list hid everything that matters when choosing or pruning a
+    profile — which model it pins, which endpoint it hits, whether that model
+    id has been retired (the catalog will remap it, but the profile should be
+    updated), and whether it duplicates another profile.
+    """
+    identities: dict[tuple[str, str, str], list[str]] = {}
+    for name in sorted(profiles):
+        identities.setdefault(_profile_identity(profiles[name]), []).append(name)
+
+    descriptions: dict[str, str] = {}
+    for name in sorted(profiles):
+        raw = profiles[name]
+        profile = raw if isinstance(raw, dict) else {}
+        model = str(profile.get("default_model") or "").strip()
+        host = urlparse(str(profile.get("base_url") or "").strip()).netloc
+        parts: list[str] = []
+        if name == active:
+            parts.append("active")
+        parts.append(model or "no model")
+        if host:
+            parts.append(host)
+        replacement = _profile_retired_model_replacement(name, raw)
+        if replacement:
+            parts.append(f"retired → {replacement}")
+        twins = [other for other in identities.get(_profile_identity(raw), []) if other != name]
+        if twins and model:
+            parts.append(f"same as {twins[0]}")
+        descriptions[name] = " · ".join(parts)
+    return descriptions
+
+
 # stage → interaction mode, so the overlay's key-binding filters don't have to
 # build a full :class:`Screen` on every repaint.
 _STAGE_MODE: dict[str, Mode] = {
@@ -1479,10 +1550,13 @@ class ConfigFlow:
         )
 
     def _screen_provider_switch(self) -> Screen:
+        descriptions = _profile_row_descriptions(
+            self.state.profiles, active=self.state.active_profile
+        )
         rows = [
             Row(
                 label=name,
-                description="active" if name == self.state.active_profile else "",
+                description=descriptions.get(name, ""),
                 value=name,
                 current=name == self.state.active_profile,
             )
@@ -1609,7 +1683,13 @@ class ConfigFlow:
         )
 
     def _screen_provider_remove(self) -> Screen:
-        rows = [Row(label=name, value=name) for name in sorted(self.state.profiles)]
+        descriptions = _profile_row_descriptions(
+            self.state.profiles, active=self.state.active_profile
+        )
+        rows = [
+            Row(label=name, description=descriptions.get(name, ""), value=name)
+            for name in sorted(self.state.profiles)
+        ]
         return Screen(
             stage="provider_remove",
             mode="list",

{alysis_code-0.13.3 → alysis_code-0.13.4}/src/alysis_code/cli_impl/tui/content.py

@@ -35,11 +35,18 @@ _ACRONYMS = {
 }
 
 
+# Families whose vendors hyphenate the version onto the name ("GPT-6 Astra",
+# "GPT-5.6 Terra", "GLM-5.3"). Everything else keeps a space ("Gemini 3.8
+# Flash", "Claude Opus 5", "Kimi K3"), which matches those vendors' naming.
+_HYPHENATED_VERSION_FAMILIES = frozenset({"GPT", "GLM"})
+
+
 def pretty_model_label(model: str | None) -> str:
     """Turn a raw model id into a friendly footer label.
 
-    ``deepseek-chat`` -> ``DeepSeek Chat``; ``gpt-4o`` -> ``GPT 4o``. Falls back
-    to the raw id when there is nothing sensible to do.
+    ``deepseek-chat`` -> ``DeepSeek Chat``; ``gpt-6-astra`` -> ``GPT-6 Astra``;
+    ``gpt-4o`` -> ``GPT-4o``. Falls back to the raw id when there is nothing
+    sensible to do.
     """
     raw = (model or "").strip()
     if not raw:
@@ -50,11 +57,20 @@ def pretty_model_label(model: str | None) -> str:
     for token in tokens:
         low = token.lower()
         if low in _ACRONYMS:
-            out.append(_ACRONYMS[low])
+            word = _ACRONYMS[low]
         elif token.isupper():
-            out.append(token)
+            word = token
         else:
-            out.append(token[:1].upper() + token[1:])
+            word = token[:1].upper() + token[1:]
+        if out and out[-1] in _HYPHENATED_VERSION_FAMILIES and word[:1].isdigit():
+            out[-1] = f"{out[-1]}-{word}"
+            continue
+        # Ids that cannot carry a dot spell "5.1" as "5-1" (claude-fable-5-1,
+        # doubao-seed-2-1-pro): two adjacent bare numbers are one version.
+        if out and out[-1].isdigit() and word.isdigit():
+            out[-1] = f"{out[-1]}.{word}"
+            continue
+        out.append(word)
     return " ".join(out) or raw
 
 

{alysis_code-0.13.3 → alysis_code-0.13.4}/src/alysis_code/llm/gemini_generate_content.py

@@ -447,6 +447,232 @@ class _GeminiToolMapping:
     include_server_side_tool_invocations: bool
 
 
+# Gemini's ``Schema`` message is an OpenAPI 3.0 subset, not JSON Schema. Any
+# other keyword is a hard 400 ("Unknown name ... Cannot find field"), and the
+# tool registry, MCP servers and custom tools all emit plain JSON Schema
+# (``additionalProperties``, ``uniqueItems``, ``$ref`` ...). Everything not in
+# this set is dropped or rewritten before the declaration leaves the client.
+_GEMINI_SCHEMA_FIELDS: frozenset[str] = frozenset(
+    {
+        "type",
+        "format",
+        "title",
+        "description",
+        "nullable",
+        "enum",
+        "maxItems",
+        "minItems",
+        "properties",
+        "required",
+        "minProperties",
+        "maxProperties",
+        "minLength",
+        "maxLength",
+        "pattern",
+        "example",
+        "anyOf",
+        "propertyOrdering",
+        "default",
+        "items",
+        "minimum",
+        "maximum",
+    }
+)
+# ``format`` is validated per type; unknown values are rejected outright.
+_GEMINI_SCHEMA_FORMATS: dict[str, frozenset[str]] = {
+    "string": frozenset({"date-time", "enum"}),
+    "number": frozenset({"float", "double"}),
+    "integer": frozenset({"int32", "int64"}),
+}
+_GEMINI_SCHEMA_TYPES: frozenset[str] = frozenset(
+    {"string", "number", "integer", "boolean", "array", "object", "null"}
+)
+_GEMINI_SCHEMA_MAX_DEPTH = 32
+
+
+def _resolve_local_schema_ref(ref: str, root: dict[str, Any]) -> dict[str, Any] | None:
+    """Resolve ``#/$defs/x`` / ``#/definitions/x`` style pointers inside ``root``."""
+    if not ref.startswith("#/"):
+        return None
+    node: Any = root
+    for raw_part in ref[2:].split("/"):
+        part = raw_part.replace("~1", "/").replace("~0", "~")
+        if not isinstance(node, dict) or part not in node:
+            return None
+        node = node[part]
+    return node if isinstance(node, dict) else None
+
+
+def _gemini_schema(
+    schema: Any,
+    *,
+    root: dict[str, Any] | None = None,
+    depth: int = 0,
+) -> dict[str, Any]:
+    """Project an arbitrary JSON Schema onto Gemini's ``Schema`` subset.
+
+    Unknown keywords are dropped; ``const`` becomes a one-value ``enum``;
+    ``oneOf`` becomes ``anyOf``; a single-branch ``allOf`` is merged; union
+    ``type`` lists become ``nullable`` + ``anyOf``; local ``$ref`` pointers are
+    inlined; ``required`` is trimmed to declared properties; ``format`` values
+    Gemini does not validate are removed.
+    """
+    if not isinstance(schema, dict):
+        return {}
+    if depth > _GEMINI_SCHEMA_MAX_DEPTH:
+        return {}
+    root_schema = root if root is not None else schema
+
+    ref = schema.get("$ref")
+    if isinstance(ref, str):
+        target = _resolve_local_schema_ref(ref, root_schema)
+        merged: dict[str, Any] = dict(target or {})
+        merged.update({key: value for key, value in schema.items() if key != "$ref"})
+        if target is None and len(merged) == 0:
+            return {}
+        return _gemini_schema(merged, root=root_schema, depth=depth + 1)
+
+    working: dict[str, Any] = dict(schema)
+    all_of = working.pop("allOf", None)
+    if isinstance(all_of, list):
+        branches = [branch for branch in all_of if isinstance(branch, dict)]
+        if len(branches) == 1:
+            merged_all = dict(branches[0])
+            merged_all.update(working)
+            working = merged_all
+    one_of = working.pop("oneOf", None)
+    if isinstance(one_of, list) and "anyOf" not in working:
+        working["anyOf"] = one_of
+    if "const" in working and "enum" not in working:
+        working["enum"] = [working["const"]]
+    working.pop("const", None)
+
+    out: dict[str, Any] = {}
+    raw_type = working.get("type")
+    nullable = bool(working.get("nullable"))
+    resolved_type: str | None = None
+    if isinstance(raw_type, list):
+        candidates = [str(item).strip().lower() for item in raw_type if isinstance(item, str)]
+        if "null" in candidates:
+            nullable = True
+        non_null = [item for item in candidates if item != "null" and item in _GEMINI_SCHEMA_TYPES]
+        if len(non_null) == 1:
+            resolved_type = non_null[0]
+        elif len(non_null) > 1 and "anyOf" not in working:
+            working["anyOf"] = [{"type": item} for item in non_null]
+    elif isinstance(raw_type, str):
+        candidate = raw_type.strip().lower()
+        if candidate == "null":
+            nullable = True
+        elif candidate in _GEMINI_SCHEMA_TYPES:
+            resolved_type = candidate
+    if resolved_type is not None:
+        out["type"] = resolved_type
+    if nullable:
+        out["nullable"] = True
+
+    for key in ("title", "description", "pattern"):
+        value = working.get(key)
+        if isinstance(value, str) and value:
+            out[key] = value
+    for key in (
+        "minItems",
+        "maxItems",
+        "minProperties",
+        "maxProperties",
+        "minLength",
+        "maxLength",
+    ):
+        value = working.get(key)
+        if isinstance(value, int) and not isinstance(value, bool) and value >= 0:
+            out[key] = value
+    for key in ("minimum", "maximum"):
+        value = working.get(key)
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            out[key] = value
+    if "default" in working and working["default"] is not None:
+        out["default"] = copy.deepcopy(working["default"])
+    if "example" in working and working["example"] is not None:
+        out["example"] = copy.deepcopy(working["example"])
+
+    fmt = working.get("format")
+    if isinstance(fmt, str) and resolved_type in _GEMINI_SCHEMA_FORMATS:
+        if fmt in _GEMINI_SCHEMA_FORMATS[resolved_type]:
+            out["format"] = fmt
+
+    enum_values = working.get("enum")
+    if isinstance(enum_values, list) and enum_values:
+        if resolved_type in {None, "string"}:
+            out["enum"] = [str(value) for value in enum_values]
+            out["type"] = "string"
+        else:
+            # Gemini only validates enums on strings; keep the value list
+            # visible to the model through the description instead.
+            rendered = ", ".join(str(value) for value in enum_values)
+            hint = f"Allowed values: {rendered}"
+            out["description"] = (
+                f"{out['description']} ({hint})" if out.get("description") else hint
+            )
+
+    properties = working.get("properties")
+    if isinstance(properties, dict):
+        clean_properties: dict[str, Any] = {}
+        for prop_name, prop_schema in properties.items():
+            if not isinstance(prop_name, str) or not prop_name:
+                continue
+            clean_properties[prop_name] = _gemini_schema(
+                prop_schema if isinstance(prop_schema, dict) else {},
+                root=root_schema,
+                depth=depth + 1,
+            )
+        if clean_properties:
+            out["properties"] = clean_properties
+            required = working.get("required")
+            if isinstance(required, list):
+                kept = [
+                    name for name in required if isinstance(name, str) and name in clean_properties
+                ]
+                if kept:
+                    out["required"] = kept
+            ordering = working.get("propertyOrdering")
+            if isinstance(ordering, list):
+                kept_order = [
+                    name for name in ordering if isinstance(name, str) and name in clean_properties
+                ]
+                if kept_order:
+                    out["propertyOrdering"] = kept_order
+
+    items = working.get("items")
+    if isinstance(items, list):
+        items = items[0] if items and isinstance(items[0], dict) else None
+    if isinstance(items, dict):
+        out["items"] = _gemini_schema(items, root=root_schema, depth=depth + 1)
+    elif out.get("type") == "array":
+        # Gemini requires ``items`` on arrays; an untyped item schema is the
+        # closest expression of JSON Schema's "anything".
+        out["items"] = {}
+
+    any_of = working.get("anyOf")
+    if isinstance(any_of, list):
+        branches = [
+            _gemini_schema(branch, root=root_schema, depth=depth + 1)
+            for branch in any_of
+            if isinstance(branch, dict)
+        ]
+        # A ``{"type": "null"}`` branch is Gemini's ``nullable`` flag.
+        if any(branch == {"nullable": True} for branch in branches):
+            out["nullable"] = True
+        branches = [branch for branch in branches if branch != {"nullable": True}]
+        if len(branches) == 1:
+            single = branches[0]
+            for key, value in single.items():
+                out.setdefault(key, value)
+        elif branches:
+            out["anyOf"] = branches
+
+    return {key: value for key, value in out.items() if key in _GEMINI_SCHEMA_FIELDS}
+
+
 def _gemini_function_declaration_from_chat_tool(tool: dict[str, Any]) -> dict[str, Any] | None:
     if not isinstance(tool, dict):
         return None
@@ -460,9 +686,13 @@ def _gemini_function_declaration_from_chat_tool(tool: dict[str, Any]) -> dict[st
     name = str(source.get("name") or "").strip()
     if not name:
         return None
+    raw_parameters = source.get("parameters")
+    parameters = _gemini_schema(raw_parameters) if isinstance(raw_parameters, dict) else {}
+    if not parameters.get("type"):
+        parameters["type"] = "object"
     declaration: dict[str, Any] = {
         "name": name,
-        "parameters": copy.deepcopy(source.get("parameters") or {"type": "object"}),
+        "parameters": parameters,
     }
     description = str(source.get("description") or "").strip()
     if description:
@@ -2574,7 +2804,9 @@ def _gemini_response_format(response_format: dict[str, Any] | None) -> dict[str,
             )
         return {
             "responseMimeType": "application/json",
-            "responseSchema": copy.deepcopy(schema),
+            # responseSchema is the same OpenAPI-subset ``Schema`` message as
+            # function parameters, so it needs the same projection.
+            "responseSchema": _gemini_schema(schema),
         }
     if response_type == "text":
         return {}

{alysis_code-0.13.3 → alysis_code-0.13.4}/src/alysis_code/llm/openai_compat.py

@@ -421,6 +421,24 @@ def _is_moonshot_provider(provider_key: str | None) -> bool:
     return _normalize_provider_key(provider_key) in {_MOONSHOT_PROVIDER_KEY, "kimi_code"}
 
 
+# Routes whose Chat Completions surface wants ``max_completion_tokens``.
+# OpenAI's gpt-5 / o-series reject the legacy ``max_tokens`` outright
+# ("Unsupported parameter: 'max_tokens' is not supported with this model"),
+# and OpenAI accepts ``max_completion_tokens`` on every chat model, so the
+# first-party host (and Azure, which mirrors it) always uses the new field.
+# The decision is keyed on the endpoint host, not on a provider inferred from
+# a ``gpt-*`` model name: an unknown OpenAI-compatible gateway serving such a
+# model may only implement ``max_tokens``.
+_MAX_COMPLETION_TOKENS_HOST_PROVIDERS = frozenset({"openai", "azure"})
+
+
+def _uses_max_completion_tokens(provider_key: str | None, *, base_url: str | None) -> bool:
+    if _is_moonshot_provider(provider_key):
+        return True
+    host_provider = _normalize_provider_key(_provider_key_from_base_url(base_url))
+    return host_provider in _MAX_COMPLETION_TOKENS_HOST_PROVIDERS
+
+
 def _is_nvidia_provider(provider_key: str | None) -> bool:
     return _normalize_provider_key(provider_key) == _NVIDIA_PROVIDER_KEY
 
@@ -2130,7 +2148,7 @@ class OpenAICompatClient:
         if max_tokens is not None:
             output_limit_field = (
                 "max_completion_tokens"
-                if _is_moonshot_provider(transport_provider_key)
+                if _uses_max_completion_tokens(transport_provider_key, base_url=self.base_url)
                 else "max_tokens"
             )
             payload[output_limit_field] = int(max_tokens)