code-puppy 0.0.855__tar.gz → 0.0.856__tar.gz

{code_puppy-0.0.855 → code_puppy-0.0.856}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: code-puppy
-Version: 0.0.855
+Version: 0.0.856
 Summary: Code generation agent
 Project-URL: repository, https://github.com/mpfaffenberger/code_puppy
 Project-URL: HomePage, https://github.com/mpfaffenberger/code_puppy

{code_puppy-0.0.855 → code_puppy-0.0.856}/code_puppy/gemini_code_assist.py

@@ -30,10 +30,13 @@ from pydantic_ai.messages import (
 )
 from pydantic_ai.models import Model, ModelRequestParameters
 from pydantic_ai.settings import ModelSettings
-from pydantic_ai.tools import ToolDefinition
 from pydantic_ai.usage import RequestUsage
 
-from code_puppy.gemini_common import _parse_candidate_parts, _build_generation_config
+from code_puppy.gemini_common import (
+    _build_tools,
+    _parse_candidate_parts,
+    _build_generation_config,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -227,9 +230,9 @@ class GeminiCodeAssistModel(Model):
 
         # Add tools if available.
         if model_request_parameters.function_tools:
-            inner_request["tools"] = [
-                self._build_tools(model_request_parameters.function_tools)
-            ]
+            inner_request["tools"] = _build_tools(
+                model_request_parameters.function_tools
+            )
 
         # Add generation config.
         generation_config = _build_generation_config(model_settings)
@@ -244,23 +247,6 @@ class GeminiCodeAssistModel(Model):
             "request": inner_request,
         }
 
-    def _build_tools(self, tools: list[ToolDefinition]) -> Dict[str, Any]:
-        """Build tool definitions for the API."""
-        function_declarations = []
-
-        for tool in tools:
-            func_decl: Dict[str, Any] = {
-                "name": tool.name,
-                "description": tool.description or "",
-            }
-
-            if tool.parameters_json_schema:
-                func_decl["parametersJsonSchema"] = tool.parameters_json_schema
-
-            function_declarations.append(func_decl)
-
-        return {"functionDeclarations": function_declarations}
-
     def _parse_response(self, data: Dict[str, Any]) -> ModelResponse:
         """Parse the Code Assist API response."""
         # Unwrap the Code Assist response format.

code_puppy-0.0.856/code_puppy/gemini_common.py

@@ -0,0 +1,328 @@
+"""Shared Gemini wire-format helpers.
+
+Consolidates logic that was previously duplicated and drifted across
+`gemini_model.py::GeminiModel` and `gemini_code_assist.py::GeminiCodeAssistModel`.
+
+Wire-format knowledge for the Gemini API should live in exactly one place.
+"""
+
+import uuid
+from typing import Any
+
+from pydantic_ai import (
+    ModelResponsePart,
+    ThinkingPart,
+    TextPart,
+    ToolCallPart,
+    RequestUsage,
+)
+from pydantic_ai.tools import ToolDefinition
+from pydantic_ai.settings import ModelSettings
+
+
+def generate_tool_call_id() -> str:
+    """Generate a unique tool call ID."""
+    return str(uuid.uuid4())
+
+
+def _flatten_union_to_object_gemini(union_items: list, defs: dict, resolve_fn) -> dict:
+    """Flatten a union of object types into a single object with all properties.
+
+    For discriminated unions like EditFilePayload, we merge all object types
+    into one with all properties (Gemini doesn't support anyOf/oneOf).
+    """
+    import copy as copy_module
+
+    merged_properties = {}
+    has_string_type = False
+
+    for item in union_items:
+        if not isinstance(item, dict):
+            continue
+
+        # Resolve $ref first.
+        if "$ref" in item:
+            ref_path = item["$ref"]
+            ref_name = None
+
+            if ref_path.startswith("#/$defs/"):
+                ref_name = ref_path[8:]
+
+            elif ref_path.startswith("#/definitions/"):
+                ref_name = ref_path[14:]
+
+            if ref_name and ref_name in defs:
+                item = copy_module.deepcopy(defs[ref_name])
+
+            else:
+                continue
+
+        if item.get("type") == "string":
+            has_string_type = True
+            continue
+
+        if item.get("type") == "null":
+            continue
+
+        if item.get("type") == "object" or "properties" in item:
+            props = item.get("properties", {})
+            for prop_name, prop_schema in props.items():
+                if prop_name not in merged_properties:
+                    merged_properties[prop_name] = resolve_fn(
+                        copy_module.deepcopy(prop_schema)
+                    )
+
+    if not merged_properties:
+        return {"type": "string"} if has_string_type else {"type": "object"}
+
+    return {
+        "type": "object",
+        "properties": merged_properties,
+    }
+
+
+def _sanitize_schema_for_gemini(schema: dict) -> dict:
+    """Sanitize JSON schema for Gemini API compatibility.
+
+    Removes/transforms fields that Gemini doesn't support:
+    - $defs, definitions, $schema, $id
+    - additionalProperties
+    - $ref (inlined)
+    - anyOf/oneOf/allOf (flattened - Gemini doesn't support unions!)
+      - For unions of objects: merges into single object with all properties
+      - For simple unions (string | null): picks first non-null type
+    """
+    import copy
+
+    if not isinstance(schema, dict):
+        return schema
+
+    # Make a deep copy to avoid modifying original.
+    schema = copy.deepcopy(schema)
+
+    # Extract $defs for reference resolution.
+    defs = schema.pop("$defs", schema.pop("definitions", {}))
+
+    def resolve_refs(obj):
+        """Recursively resolve $ref references and clean schema."""
+        if isinstance(obj, dict):
+            # Handle anyOf/oneOf unions.
+            for union_key in ["anyOf", "oneOf"]:
+                if union_key in obj:
+                    union = obj[union_key]
+
+                    if isinstance(union, list):
+                        # Check if this is a complex union of objects.
+                        object_count = 0
+                        has_refs = False
+
+                        for item in union:
+                            if isinstance(item, dict):
+                                if "$ref" in item:
+                                    has_refs = True
+                                    object_count += 1
+
+                                elif (
+                                    item.get("type") == "object" or "properties" in item
+                                ):
+                                    object_count += 1
+
+                        # If multiple objects or has refs, flatten to single object.
+                        if object_count > 1 or has_refs:
+                            flattened = _flatten_union_to_object_gemini(
+                                union, defs, resolve_refs
+                            )
+
+                            if "description" in obj:
+                                flattened["description"] = obj["description"]
+                            return flattened
+
+                        # Simple union — pick first non-null type.
+                        for item in union:
+                            if isinstance(item, dict) and item.get("type") != "null":
+                                result = dict(item)
+
+                                if "description" in obj:
+                                    result["description"] = obj["description"]
+                                return resolve_refs(result)
+
+            # Handle allOf by merging all schemas.
+            if "allOf" in obj:
+                all_of = obj["allOf"]
+
+                if isinstance(all_of, list):
+                    merged = {}
+                    merged_properties = {}
+
+                    for item in all_of:
+                        if isinstance(item, dict):
+                            resolved_item = resolve_refs(item)
+
+                            if "properties" in resolved_item:
+                                merged_properties.update(
+                                    resolved_item.pop("properties")
+                                )
+                            merged.update(resolved_item)
+
+                    if merged_properties:
+                        merged["properties"] = merged_properties
+
+                    for key, value in obj.items():
+                        if key != "allOf":
+                            merged[key] = value
+
+                    return resolve_refs(merged)
+
+            # Check for $ref.
+            if "$ref" in obj:
+                ref_path = obj["$ref"]
+                ref_name = None
+
+                # Parse ref like "#/$defs/SomeType" or "#/definitions/SomeType".
+                if ref_path.startswith("#/$defs/"):
+                    ref_name = ref_path[8:]
+
+                elif ref_path.startswith("#/definitions/"):
+                    ref_name = ref_path[14:]
+
+                if ref_name and ref_name in defs:
+                    resolved = resolve_refs(copy.deepcopy(defs[ref_name]))
+                    other_props = {k: v for k, v in obj.items() if k != "$ref"}
+
+                    if other_props:
+                        resolved.update(resolve_refs(other_props))
+                    return resolved
+
+                else:
+                    return {"type": "object"}
+
+            # Recursively process and transform.
+            result = {}
+
+            for key, value in obj.items():
+                # Skip unsupported fields.
+                if key in (
+                    "$defs",
+                    "definitions",
+                    "$schema",
+                    "$id",
+                    "additionalProperties",
+                    "default",
+                    "examples",
+                    "const",
+                    "anyOf",  # Skip any remaining union types.
+                    "oneOf",
+                    "allOf",
+                ):
+                    continue
+
+                result[key] = resolve_refs(value)
+            return result
+
+        elif isinstance(obj, list):
+            return [resolve_refs(item) for item in obj]
+
+        else:
+            return obj
+
+    return resolve_refs(schema)
+
+
+def _build_tools(tools: list[ToolDefinition]) -> list[dict[str, Any]]:
+    """Build tool definitions for the API."""
+    function_declarations = []
+
+    for tool in tools:
+        func_decl: dict[str, Any] = {
+            "name": tool.name,
+            "description": tool.description or "",
+        }
+
+        if tool.parameters_json_schema:
+            # Sanitize schema for Gemini compatibility.
+            func_decl["parameters"] = _sanitize_schema_for_gemini(
+                tool.parameters_json_schema
+            )
+
+        function_declarations.append(func_decl)
+
+    return [{"functionDeclarations": function_declarations}]
+
+
+def _parse_candidate_parts(
+    data: dict[str, Any], candidates: list[dict[str, Any]]
+) -> tuple[RequestUsage, list[ModelResponsePart]]:
+    """Parse candidate parts from Gemini API response."""
+    # Extract usage.
+    usage_meta = data.get("usageMetadata", {})
+    usage = RequestUsage(
+        input_tokens=usage_meta.get("promptTokenCount", 0),
+        output_tokens=usage_meta.get("candidatesTokenCount", 0),
+    )
+
+    response_parts: list[ModelResponsePart] = []
+
+    if not candidates:
+        return usage, response_parts
+
+    candidate = candidates[0]
+    content = candidate.get("content", {})
+    parts = content.get("parts", [])
+
+    for part in parts:
+        if part.get("thought") and part.get("text") is not None:
+            # Thinking part.
+            signature = part.get("thoughtSignature")
+            response_parts.append(
+                ThinkingPart(content=part["text"], signature=signature)
+            )
+
+        elif "text" in part:
+            response_parts.append(TextPart(content=part["text"]))
+
+        elif "functionCall" in part:
+            fc = part["functionCall"]
+
+            response_parts.append(
+                ToolCallPart(
+                    tool_name=fc["name"],
+                    args=fc.get("args", {}),
+                    tool_call_id=fc.get("id") or generate_tool_call_id(),
+                )
+            )
+
+    return usage, response_parts
+
+
+def _build_generation_config(model_settings: ModelSettings | None) -> dict[str, Any]:
+    """Build generation config from model settings."""
+    config: dict[str, Any] = {}
+
+    if model_settings:
+        # ModelSettings is a TypedDict, so use .get() for all access.
+        temperature = model_settings.get("temperature")
+        if temperature is not None:
+            config["temperature"] = temperature
+
+        top_p = model_settings.get("top_p")
+        if top_p is not None:
+            config["topP"] = top_p
+
+        max_tokens = model_settings.get("max_tokens")
+        if max_tokens is not None:
+            config["maxOutputTokens"] = max_tokens
+
+        # Handle Gemini 3 Pro thinking settings.
+        thinking_enabled = model_settings.get("thinking_enabled")
+        thinking_level = model_settings.get("thinking_level")
+
+        # Build `thinkingConfig` if thinking settings are present.
+        if thinking_enabled is not False and thinking_level is not None:
+            # Gemini 3 Pro uses thinkingLevel with values "low" or "high".
+            # `includeThoughts=True` is required to surface the thinking in response.
+            config["thinkingConfig"] = {
+                "thinkingLevel": thinking_level,
+                "includeThoughts": True,
+            }
+
+    return config

{code_puppy-0.0.855 → code_puppy-0.0.856}/code_puppy/gemini_model.py

@@ -34,10 +34,10 @@ from pydantic_ai.messages import (
 )
 from pydantic_ai.models import Model, ModelRequestParameters, StreamedResponse
 from pydantic_ai.settings import ModelSettings
-from pydantic_ai.tools import ToolDefinition
 from pydantic_ai.usage import RequestUsage
 
 from code_puppy.gemini_common import (
+    _build_tools,
     _parse_candidate_parts,
     generate_tool_call_id,
     _build_generation_config,
@@ -57,188 +57,6 @@ STEER_PREAMBLE = (
 )
 
 
-def _flatten_union_to_object_gemini(union_items: list, defs: dict, resolve_fn) -> dict:
-    """Flatten a union of object types into a single object with all properties.
-
-    For discriminated unions like EditFilePayload, we merge all object types
-    into one with all properties (Gemini doesn't support anyOf/oneOf).
-    """
-    import copy as copy_module
-
-    merged_properties = {}
-    has_string_type = False
-
-    for item in union_items:
-        if not isinstance(item, dict):
-            continue
-
-        # Resolve $ref first
-        if "$ref" in item:
-            ref_path = item["$ref"]
-            ref_name = None
-            if ref_path.startswith("#/$defs/"):
-                ref_name = ref_path[8:]
-            elif ref_path.startswith("#/definitions/"):
-                ref_name = ref_path[14:]
-            if ref_name and ref_name in defs:
-                item = copy_module.deepcopy(defs[ref_name])
-            else:
-                continue
-
-        if item.get("type") == "string":
-            has_string_type = True
-            continue
-
-        if item.get("type") == "null":
-            continue
-
-        if item.get("type") == "object" or "properties" in item:
-            props = item.get("properties", {})
-            for prop_name, prop_schema in props.items():
-                if prop_name not in merged_properties:
-                    merged_properties[prop_name] = resolve_fn(
-                        copy_module.deepcopy(prop_schema)
-                    )
-
-    if not merged_properties:
-        return {"type": "string"} if has_string_type else {"type": "object"}
-
-    return {
-        "type": "object",
-        "properties": merged_properties,
-    }
-
-
-def _sanitize_schema_for_gemini(schema: dict) -> dict:
-    """Sanitize JSON schema for Gemini API compatibility.
-
-    Removes/transforms fields that Gemini doesn't support:
-    - $defs, definitions, $schema, $id
-    - additionalProperties
-    - $ref (inlined)
-    - anyOf/oneOf/allOf (flattened - Gemini doesn't support unions!)
-      - For unions of objects: merges into single object with all properties
-      - For simple unions (string | null): picks first non-null type
-    """
-    import copy
-
-    if not isinstance(schema, dict):
-        return schema
-
-    # Make a deep copy to avoid modifying original
-    schema = copy.deepcopy(schema)
-
-    # Extract $defs for reference resolution
-    defs = schema.pop("$defs", schema.pop("definitions", {}))
-
-    def resolve_refs(obj):
-        """Recursively resolve $ref references and clean schema."""
-        if isinstance(obj, dict):
-            # Handle anyOf/oneOf unions
-            for union_key in ["anyOf", "oneOf"]:
-                if union_key in obj:
-                    union = obj[union_key]
-                    if isinstance(union, list):
-                        # Check if this is a complex union of objects
-                        object_count = 0
-                        has_refs = False
-                        for item in union:
-                            if isinstance(item, dict):
-                                if "$ref" in item:
-                                    has_refs = True
-                                    object_count += 1
-                                elif (
-                                    item.get("type") == "object" or "properties" in item
-                                ):
-                                    object_count += 1
-
-                        # If multiple objects or has refs, flatten to single object
-                        if object_count > 1 or has_refs:
-                            flattened = _flatten_union_to_object_gemini(
-                                union, defs, resolve_refs
-                            )
-                            if "description" in obj:
-                                flattened["description"] = obj["description"]
-                            return flattened
-
-                        # Simple union - pick first non-null type
-                        for item in union:
-                            if isinstance(item, dict) and item.get("type") != "null":
-                                result = dict(item)
-                                if "description" in obj:
-                                    result["description"] = obj["description"]
-                                return resolve_refs(result)
-
-            # Handle allOf by merging all schemas
-            if "allOf" in obj:
-                all_of = obj["allOf"]
-                if isinstance(all_of, list):
-                    merged = {}
-                    merged_properties = {}
-                    for item in all_of:
-                        if isinstance(item, dict):
-                            resolved_item = resolve_refs(item)
-                            if "properties" in resolved_item:
-                                merged_properties.update(
-                                    resolved_item.pop("properties")
-                                )
-                            merged.update(resolved_item)
-                    if merged_properties:
-                        merged["properties"] = merged_properties
-                    for k, v in obj.items():
-                        if k != "allOf":
-                            merged[k] = v
-                    return resolve_refs(merged)
-
-            # Check for $ref
-            if "$ref" in obj:
-                ref_path = obj["$ref"]
-                ref_name = None
-
-                # Parse ref like "#/$defs/SomeType" or "#/definitions/SomeType"
-                if ref_path.startswith("#/$defs/"):
-                    ref_name = ref_path[8:]
-                elif ref_path.startswith("#/definitions/"):
-                    ref_name = ref_path[14:]
-
-                if ref_name and ref_name in defs:
-                    resolved = resolve_refs(copy.deepcopy(defs[ref_name]))
-                    other_props = {k: v for k, v in obj.items() if k != "$ref"}
-                    if other_props:
-                        resolved.update(resolve_refs(other_props))
-                    return resolved
-                else:
-                    return {"type": "object"}
-
-            # Recursively process and transform
-            result = {}
-            for key, value in obj.items():
-                # Skip unsupported fields
-                if key in (
-                    "$defs",
-                    "definitions",
-                    "$schema",
-                    "$id",
-                    "additionalProperties",
-                    "default",
-                    "examples",
-                    "const",
-                    "anyOf",  # Skip any remaining union types
-                    "oneOf",
-                    "allOf",
-                ):
-                    continue
-
-                result[key] = resolve_refs(value)
-            return result
-        elif isinstance(obj, list):
-            return [resolve_refs(item) for item in obj]
-        else:
-            return obj
-
-    return resolve_refs(schema)
-
-
 def _split_mixed_user_contents(contents: list[dict[str, Any]]) -> None:
     """Split user turns carrying both function responses and other parts.
 
@@ -580,24 +398,6 @@ class GeminiModel(Model):
             return None
         return {"role": "model", "parts": parts}
 
-    def _build_tools(self, tools: list[ToolDefinition]) -> list[dict[str, Any]]:
-        """Build tool definitions for the API."""
-        function_declarations = []
-
-        for tool in tools:
-            func_decl: dict[str, Any] = {
-                "name": tool.name,
-                "description": tool.description or "",
-            }
-            if tool.parameters_json_schema:
-                # Sanitize schema for Gemini compatibility
-                func_decl["parameters"] = _sanitize_schema_for_gemini(
-                    tool.parameters_json_schema
-                )
-            function_declarations.append(func_decl)
-
-        return [{"functionDeclarations": function_declarations}]
-
     def _build_request_body(
         self,
         system_instruction,
@@ -618,7 +418,7 @@ class GeminiModel(Model):
 
         # Add tools.
         if model_request_parameters.function_tools:
-            body["tools"] = self._build_tools(model_request_parameters.function_tools)
+            body["tools"] = _build_tools(model_request_parameters.function_tools)
 
             if streaming:
                 body["toolConfig"] = {

{code_puppy-0.0.855 → code_puppy-0.0.856}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "code-puppy"
-version = "0.0.855"
+version = "0.0.856"
 description = "Code generation agent"
 readme = "README.md"
 requires-python = ">=3.11,<3.15"