synth-ai 0.2.4.dev7__py3-none-any.whl → 0.2.4.dev9__py3-none-any.whl

synth_ai/learning/rl_client.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Callable
+import os
+import time
+
+from ..http import AsyncHttpClient, HTTPError, sleep
+
+
+def _api_base(b: str) -> str:
+    b = (b or "").rstrip("/")
+    return b if b.endswith("/api") else f"{b}/api"
+
+
+class RlClient:
+    """Lightweight RL client for provider-agnostic job control.
+
+    Notes:
+    - Uses learning/* for status/events/metrics and rl/* for creation/start.
+    - Trainer endpoints are resolved server-side via trainer_id.
+    """
+
+    def __init__(self, base_url: str, api_key: str, *, timeout: float = 600.0) -> None:
+        self._base_url = base_url.rstrip("/")
+        self._api_key = api_key
+        self._timeout = timeout
+
+    async def resolve_trainer_start_url(self, trainer_id: str) -> str:
+        """GET /api/rl/services/{id} → { training_start_url }"""
+        path = f"/api/rl/services/{trainer_id}"
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            js = await http.get(path)
+        if not isinstance(js, dict):
+            raise HTTPError(status=500, url=path, message="invalid_service_response", body_snippet=str(js)[:200])
+        start_url = js.get("training_start_url")
+        if not isinstance(start_url, str) or not start_url:
+            raise HTTPError(status=500, url=path, message="missing_training_start_url", body_snippet=str(js)[:200])
+        return start_url
+
+    async def create_job(
+        self,
+        *,
+        model: str,
+        task_app_url: str,
+        trainer: Dict[str, Any],
+        trainer_id: Optional[str] = None,
+        job_config_id: Optional[str] = None,
+        inline_config: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        body = {
+            "job_type": "rl",
+            "data": {
+                "model": model,
+                "endpoint_base_url": task_app_url,
+                **({"job_config_id": job_config_id} if job_config_id else {}),
+                **({"config": inline_config} if inline_config else {}),
+                "trainer": {
+                    "batch_size": int(trainer.get("batch_size", 1)),
+                    "group_size": max(2, int(trainer.get("group_size", 2))),
+                },
+            },
+        }
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
+            js = await http.post_json(f"{_api_base(self._base_url)}/rl/jobs", json=body)
+        if not isinstance(js, dict):
+            raise HTTPError(status=500, url="/api/rl/jobs", message="invalid_create_response", body_snippet=str(js)[:200])
+        return js
+
+    async def start_job_if_supported(self, job_id: str) -> Optional[Dict[str, Any]]:
+        path = f"{_api_base(self._base_url)}/rl/jobs/{job_id}/start"
+        try:
+            async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+                return await http.post_json(path, json={})
+        except HTTPError as he:  # noqa: PERF203
+            if he.status == 404:
+                return None
+            raise
+
+    async def get_job(self, job_id: str) -> Dict[str, Any]:
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            return await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}")
+
+    async def get_events(self, job_id: str, *, since_seq: int = 0, limit: int = 200) -> List[Dict[str, Any]]:
+        params = {"since_seq": since_seq, "limit": limit}
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            try:
+                js = await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}/events", params=params)
+            except HTTPError as he:
+                try:
+                    print(
+                        f"[poll] events HTTPError status={he.status} url={he.url} since_seq={since_seq} body={(he.body_snippet or '')[:200]}"
+                    )
+                except Exception:
+                    pass
+                raise
+        if isinstance(js, dict):
+            evs = js.get("events") or js.get("data")
+            if isinstance(evs, list):
+                return evs
+        return []
+
+    async def get_metrics(self, job_id: str, *, after_step: int = -1, limit: int = 200) -> List[Dict[str, Any]]:
+        params = {"after_step": after_step, "limit": limit}
+        async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
+            js = await http.get(f"{_api_base(self._base_url)}/learning/jobs/{job_id}/metrics", params=params)
+        if isinstance(js, dict) and isinstance(js.get("points"), list):
+            return js["points"]
+        return []
+
+    async def poll_until_terminal(
+        self,
+        job_id: str,
+        *,
+        interval_seconds: float = 2.0,
+        max_seconds: float | None = None,
+        empty_polls_threshold: int = 5,
+        startup_deadline_s: int = 45,
+        on_event: Optional[Callable[[Dict[str, Any]], None]] = None,
+        on_metric: Optional[Callable[[Dict[str, Any]], None]] = None,
+    ) -> Dict[str, Any]:
+        last_seq_by_stream: Dict[str, int] = {}
+        events_job_id: Optional[str] = None
+        last_status: Optional[str] = None
+        last_step_by_name: Dict[str, int] = {}
+        empty_polls = 0
+        saw_any_event = False
+        start_t = time.time()
+        terminal = {"succeeded", "failed", "cancelled", "canceled", "error", "completed"}
+
+        while True:
+            status_data: Optional[Dict[str, Any]] = None
+            try:
+                status_data = await self.get_job(job_id)
+            except Exception:
+                status_data = None
+            if status_data is None:
+                try:
+                    print(f"[poll] get_job returned None base={self._base_url} job_id={job_id}")
+                except Exception:
+                    pass
+            status = str((status_data or {}).get("status") or "").lower()
+            if status_data:
+                linked = status_data.get("linked_job_id")
+                if isinstance(linked, str) and linked and linked != events_job_id:
+                    events_job_id = linked
+                    try:
+                        print(f"[poll] discovered linked_job_id stream={events_job_id}")
+                    except Exception:
+                        pass
+            if status and status != last_status:
+                last_status = status
+                # Status transitions only to avoid log spam
+                if on_event:
+                    try:
+                        on_event({"type": "rl.status", "message": status})
+                    except Exception:
+                        pass
+
+            # Events
+            stream_ids = [job_id]
+            if events_job_id and events_job_id not in stream_ids:
+                stream_ids.append(events_job_id)
+            try:
+                print(f"[poll] streams={stream_ids} intervals={interval_seconds}s since_map={last_seq_by_stream} empty_polls={empty_polls}")
+            except Exception:
+                pass
+            total_events_this_cycle = 0
+            terminal_event_seen = False
+            terminal_event_status: Optional[str] = None
+            for ev_id in stream_ids:
+                since = last_seq_by_stream.get(ev_id, 0)
+                try:
+                    events = await self.get_events(ev_id, since_seq=since, limit=200)
+                except HTTPError as he:
+                    try:
+                        print(f"[poll] get_events error status={he.status} url={he.url} since={since} body={(he.body_snippet or '')[:200]}")
+                    except Exception:
+                        pass
+                    events = []
+                except Exception as e:
+                    try:
+                        print(f"[poll] get_events unexpected error ev_id={ev_id} since={since} err={type(e).__name__}: {e}")
+                    except Exception:
+                        pass
+                    events = []
+                total_events_this_cycle += len(events)
+                if events:
+                    saw_any_event = True
+                for e in events:
+                    seq_val = int(e.get("seq") or 0)
+                    if seq_val <= last_seq_by_stream.get(ev_id, 0):
+                        continue
+                    last_seq_by_stream[ev_id] = seq_val
+                    if on_event:
+                        try:
+                            on_event(e)
+                        except Exception:
+                            pass
+                    et = str(e.get("type") or e.get("event_type") or "").lower()
+                    if et in ("rl.job.completed", "workflow.completed", "rl.train.completed"):
+                        terminal_event_seen = True
+                        terminal_event_status = "succeeded"
+                    elif et in ("rl.job.failed", "workflow.failed"):
+                        terminal_event_seen = True
+                        terminal_event_status = "failed"
+
+            # Metrics
+            try:
+                after = max(last_step_by_name.values()) if last_step_by_name else -1
+                points = await self.get_metrics(job_id, after_step=after, limit=200)
+                for p in points:
+                    name = str(p.get("name") or "")
+                    step = int(p.get("step") or -1)
+                    if step <= last_step_by_name.get(name, -1):
+                        continue
+                    last_step_by_name[name] = step
+                    if on_metric:
+                        try:
+                            on_metric(p)
+                        except Exception:
+                            pass
+            except Exception:
+                pass
+
+            if terminal_event_seen:
+                return {"status": terminal_event_status or status or "completed", "job_id": job_id}
+            if status and status in terminal:
+                return {"status": status, "job_id": job_id}
+
+            if total_events_this_cycle == 0:
+                empty_polls += 1
+            else:
+                empty_polls = 0
+            if empty_polls >= max(1, int(empty_polls_threshold)):
+                try:
+                    print(
+                        f"[poll] threshold hit: empty_polls={empty_polls} >= {empty_polls_threshold} streams={stream_ids} last_seq_map={last_seq_by_stream}"
+                    )
+                except Exception:
+                    pass
+                raise AssertionError(f"No new events detected for {empty_polls_threshold} consecutive polls. Check event ingestion.")
+
+            if not saw_any_event and (time.time() - start_t) > int(startup_deadline_s):
+                try:
+                    print(
+                        f"[poll] startup window exceeded: {startup_deadline_s}s base={self._base_url} job={job_id} streams={stream_ids} last_seq_map={last_seq_by_stream}"
+                    )
+                except Exception:
+                    pass
+                raise AssertionError(f"No events observed within startup window ({startup_deadline_s}s). Investigate event streaming.")
+
+            await sleep(interval_seconds)
+            if max_seconds is not None and (time.time() - start_t) >= max_seconds:
+                raise TimeoutError(f"Polling timed out after {max_seconds}s for job {job_id}")
+
+

synth_ai/learning/sse.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import json
+import time
+from typing import Any, Callable, Optional
+
+import aiohttp
+
+
+def _api_base(b: str) -> str:
+    b = (b or "").rstrip("/")
+    return b if b.endswith("/api") else f"{b}/api"
+
+
+async def stream_events(
+    base_url: str,
+    api_key: str,
+    job_id: str,
+    *,
+    seconds: int = 60,
+    on_event: Optional[Callable[[dict], None]] = None,
+) -> None:
+    if seconds <= 0:
+        return
+    headers = {"Accept": "text/event-stream", "Authorization": f"Bearer {api_key}"}
+    candidates = [
+        f"{_api_base(base_url)}/rl/jobs/{job_id}/events?since_seq=0",
+        f"{_api_base(base_url)}/learning/jobs/{job_id}/events?since_seq=0",
+    ]
+    for url in candidates:
+        try:
+            async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=None)) as session:
+                async with session.get(url, headers=headers) as resp:
+                    if resp.status != 200:
+                        continue
+                    start_t = time.time()
+                    async for raw in resp.content:
+                        line = raw.decode(errors="ignore").strip()
+                        if not line or line.startswith(":"):
+                            continue
+                        if not line.startswith("data:"):
+                            continue
+                        data = line[5:].strip()
+                        try:
+                            obj = json.loads(data)
+                        except Exception:
+                            continue
+                        if on_event:
+                            try:
+                                on_event(obj)
+                            except Exception:
+                                pass
+                        if (time.time() - start_t) >= seconds:
+                            return
+        except Exception:
+            continue
+
+

synth_ai/learning/validators.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from pathlib import Path
+import json
+from typing import Any, Dict
+from urllib.parse import urlparse
+
+
+def validate_training_jsonl(path: str | Path, *, sample_lines: int = 50) -> None:
+    p = Path(path)
+    if not p.exists():
+        raise FileNotFoundError(str(p))
+    lines = p.read_text().splitlines()
+    if not lines:
+        raise ValueError("empty JSONL")
+    for i, line in enumerate(lines[: max(1, sample_lines) ], start=1):
+        if not line.strip():
+            continue
+        try:
+            obj = json.loads(line)
+        except Exception as e:
+            raise ValueError(f"invalid json on line {i}: {e}") from e
+        msgs = obj.get("messages")
+        if not isinstance(msgs, list) or len(msgs) < 2:
+            raise ValueError(f"line {i}: missing messages[] with at least 2 turns")
+        roles = [m.get("role") for m in msgs if isinstance(m, dict)]
+        if not roles or not isinstance(roles[0], str):
+            raise ValueError(f"line {i}: missing first role")
+        for m in msgs:
+            if not isinstance(m, dict):
+                raise ValueError(f"line {i}: non-dict message")
+            if not isinstance(m.get("role"), str) or not isinstance(m.get("content"), str) or not m["content"].strip():
+                raise ValueError(f"line {i}: invalid role/content")
+
+
+def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
+    from synth_ai.task.validators import validate_task_app_url as _vt
+
+    _vt(url, name=name)
+
+
+def validate_trainer_cfg_rl(trainer: Dict[str, Any]) -> None:
+    bs = int(trainer.get("batch_size", 1))
+    gs = int(trainer.get("group_size", 2))
+    if bs < 1:
+        raise ValueError("trainer.batch_size must be >= 1")
+    if gs < 2:
+        raise ValueError("trainer.group_size must be >= 2")

synth_ai/lm/core/main_v3.py

@@ -117,7 +117,11 @@ class LM:
         if enable_v2_tracing is not None:
             enable_v3_tracing = enable_v2_tracing
 
+        # Debug logging
+        print(f"🔍 LM __init__: provider={provider}, vendor={vendor}, model={model}")
+
         # If vendor not provided, infer from model name
+        # But only if no explicit provider was given
         if vendor is None and model is not None:
             # Import vendor detection logic
             from synth_ai.lm.core.vendor_clients import (
@@ -156,6 +160,7 @@ class LM:
 
         self.vendor = vendor
         self.model = model
+        print(f"🔍 LM final: vendor={self.vendor}, model={self.model}")
         self.is_structured = is_structured
         self.structured_outputs_vendor = structured_outputs_vendor
         self.response_format = response_format
@@ -337,6 +342,14 @@ class LM:
             if hasattr(vendor_wrapper, "_hit_api_async"):
                 # OpenAIStandard expects lm_config
                 lm_config = {"temperature": self.temperature, **self.additional_params, **kwargs}
+                # Map convenience enable_thinking => thinking_mode unless explicitly set
+                if "enable_thinking" in lm_config and "thinking_mode" not in lm_config:
+                    try:
+                        et = lm_config.get("enable_thinking")
+                        if isinstance(et, bool):
+                            lm_config["thinking_mode"] = "think" if et else "no_think"
+                    except Exception:
+                        pass
                 if self.json_mode:
                     lm_config["response_format"] = {"type": "json_object"}
 

synth_ai/lm/core/synth_models.py

@@ -0,0 +1,48 @@
+"""
+Synth-supported models registry.
+
+This module defines the specific models that are supported by Synth's infrastructure.
+Models are organized by family and size for easy maintenance and extension.
+
+MAINTENANCE GUIDE:
+1. Add new model families to the appropriate lists (QWEN_MODELS, OTHER_SYNTH_MODELS)
+2. Fine-tuned models (ft:) are automatically detected by regex
+3. Update SYNTH_SUPPORTED_MODELS set when adding new models
+4. Test changes with: pytest tests/lms/test_qwen_chat_completions.py
+
+WHY THIS EXISTS:
+- The previous regex (^.*\/.*$) was too broad and caught unintended models
+- This provides explicit control over which models use Synth infrastructure
+- Easier to maintain and debug model routing issues
+"""
+
+from typing import List, Set
+
+# Qwen3 model families supported by Synth
+QWEN3_MODELS: List[str] = [
+    # Qwen3 base models
+    "Qwen/Qwen3-0.6B",
+    "Qwen/Qwen3-1.7B",
+    "Qwen/Qwen3-4B",
+    "Qwen/Qwen3-8B",
+    "Qwen/Qwen3-14B",
+    "Qwen/Qwen3-32B",
+
+    # Qwen3 specialized variants
+    "Qwen/Qwen3-4B-Instruct-2507",
+    "Qwen/Qwen3-4B-Thinking-2507",
+]
+
+# Fine-tuned models pattern - any model starting with "ft:" is considered Synth-compatible
+# These are dynamically detected, but we can add specific known ones here
+FINE_TUNED_MODELS: List[str] = [
+    # Add specific fine-tuned models that are known to work with Synth
+    # Examples:
+    # "ft:Qwen/Qwen3-4B-Instruct-2507:ftjob-22",
+]
+
+# Combine all Synth-supported models
+SYNTH_SUPPORTED_MODELS: Set[str] = set(QWEN3_MODELS + FINE_TUNED_MODELS)
+
+# Export the main set for easy import
+__all__ = ["SYNTH_SUPPORTED_MODELS", "QWEN3_MODELS", "FINE_TUNED_MODELS"]

synth_ai/lm/core/vendor_clients.py

@@ -21,6 +21,7 @@ from synth_ai.lm.core.all import (
     OpenRouterClient,
     TogetherClient,
 )
+from synth_ai.lm.core.synth_models import SYNTH_SUPPORTED_MODELS
 
 # Regular expressions to match model names to their respective providers
 openai_naming_regexes: list[Pattern] = [
@@ -39,8 +40,10 @@ gemini_naming_regexes: list[Pattern] = [
 deepseek_naming_regexes: list[Pattern] = [
     re.compile(r"^deepseek-.*$"),
 ]
-together_naming_regexes: list[Pattern] = [
-    re.compile(r"^.*\/.*$"),
+# Synth-specific model patterns (Qwen3 and fine-tuned models)
+synth_naming_regexes: list[Pattern] = [
+    re.compile(r"^ft:.*$"),  # Fine-tuned models (ft:model-name)
+    re.compile(r"^Qwen/Qwen3.*$"),  # Qwen3 models specifically (Qwen/Qwen3-*)
 ]
 
 groq_naming_regexes: list[Pattern] = [
@@ -79,8 +82,6 @@ openrouter_naming_regexes: list[Pattern] = [
 
 # Custom endpoint patterns - check these before generic patterns
 custom_endpoint_naming_regexes: list[Pattern] = [
-    # Modal endpoints: org--app.modal.run
-    re.compile(r"^[a-zA-Z0-9\-]+--[a-zA-Z0-9\-]+\.modal\.run$"),
     # Generic domain patterns for custom endpoints
     re.compile(r"^[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+\.[a-zA-Z]+$"),  # domain.tld
     re.compile(r"^[a-zA-Z0-9\-]+\.[a-zA-Z0-9\-]+\.[a-zA-Z]+\/[a-zA-Z0-9\-\/]+$"),  # domain.tld/path
@@ -179,7 +180,9 @@ def get_client(
     elif any(regex.match(model_name) for regex in custom_endpoint_naming_regexes):
         # Custom endpoints are passed as the endpoint URL
         return CustomEndpointClient(endpoint_url=model_name)
-    elif any(regex.match(model_name) for regex in together_naming_regexes):
-        return TogetherClient()
+    elif (any(regex.match(model_name) for regex in synth_naming_regexes) or
+          model_name in SYNTH_SUPPORTED_MODELS):
+        # Synth models use OpenAI-compatible client with custom endpoint
+        return OpenAIStructuredOutputClient(synth_logging=synth_logging)
     else:
         raise ValueError(f"Invalid model name: {model_name}")

synth_ai/lm/vendors/core/openai_api.py

@@ -6,6 +6,7 @@ supporting both standard and structured output modes.
 """
 
 import json
+import os
 from typing import Any
 
 import openai
@@ -42,18 +43,45 @@ class OpenAIStructuredOutputClient(OpenAIStandard):
     """
 
     def __init__(self, synth_logging: bool = True):
-        if synth_logging:
+        # Check if we should use Synth clients instead of OpenAI
+        openai_base = os.getenv("OPENAI_API_BASE", "")
+        use_synth = (openai_base.startswith("https://synth") or
+                    openai_base.startswith("https://agent-learning") or
+                    os.getenv("SYNTH_BASE_URL") or os.getenv("MODAL_BASE_URL"))
+
+        if use_synth:
+            # Use Synth clients for Synth endpoints
+            from synth_ai.lm.vendors.synth_client import AsyncSynthClient, SyncSynthClient
+            from synth_ai.lm.config import SynthConfig
+
+            # Create config from OPENAI_* environment variables if available
+            openai_base = os.getenv("OPENAI_API_BASE")
+            openai_key = os.getenv("OPENAI_API_KEY")
+
+            if openai_base and openai_key:
+                config = SynthConfig(base_url=openai_base, api_key=openai_key)
+                sync_client = SyncSynthClient(config)
+                async_client = AsyncSynthClient(config)
+            else:
+                # Fall back to default config loading
+                sync_client = SyncSynthClient()
+                async_client = AsyncSynthClient()
+        elif synth_logging:
             # print("Using synth logging - OpenAIStructuredOutputClient")
             from synth_ai.lm.provider_support.openai import AsyncOpenAI, OpenAI
+            sync_client = OpenAI()
+            async_client = AsyncOpenAI()
         else:
             # print("Not using synth logging - OpenAIStructuredOutputClient")
             from openai import AsyncOpenAI, OpenAI
+            sync_client = OpenAI()
+            async_client = AsyncOpenAI()
 
         super().__init__(
             used_for_structured_outputs=True,
             exceptions_to_retry=OPENAI_EXCEPTIONS_TO_RETRY,
-            sync_client=OpenAI(),
-            async_client=AsyncOpenAI(),
+            sync_client=sync_client,
+            async_client=async_client,
         )
 
     async def _hit_api_async_structured_output(

synth_ai/lm/vendors/openai_standard.py

@@ -207,7 +207,22 @@ class OpenAIStandard(VendorBase, OpenAIResponsesAPIMixin):
             api_params = apply_tool_overrides(api_params)
             api_params = apply_param_overrides(api_params)
 
-        # Forward Qwen3 chat template kwargs via extra_body when requested
+        # Thinking controls: route via extra_body.chat_template_kwargs for compatibility
+        thinking_mode_val = lm_config.get("thinking_mode")
+        thinking_budget_val = lm_config.get("thinking_budget")
+        if thinking_mode_val is not None or thinking_budget_val is not None:
+            api_params["extra_body"] = api_params.get("extra_body", {})
+            ctk = api_params["extra_body"].get("chat_template_kwargs", {})
+            if thinking_mode_val is not None:
+                ctk["thinking_mode"] = thinking_mode_val
+            if thinking_budget_val is not None:
+                try:
+                    ctk["thinking_budget"] = int(thinking_budget_val)
+                except Exception:
+                    ctk["thinking_budget"] = thinking_budget_val
+            api_params["extra_body"]["chat_template_kwargs"] = ctk
+
+        # Backward-compatible: forward legacy enable_thinking only via extra_body for callers still using it
         if lm_config.get("enable_thinking") is not None:
             api_params["extra_body"] = api_params.get("extra_body", {})
             ctk = api_params["extra_body"].get("chat_template_kwargs", {})
@@ -220,7 +235,7 @@ class OpenAIStandard(VendorBase, OpenAIResponsesAPIMixin):
                 **api_params.get("extra_body", {}),
                 **(lm_config.get("extra_body") or {}),
             }
-        # Forward Qwen3 chat template kwargs via extra_body when requested
+        # Ensure legacy extra_body flag remains merged (do not override top-level fields)
         if lm_config.get("enable_thinking") is not None:
             api_params["extra_body"] = api_params.get("extra_body", {})
             ctk = api_params["extra_body"].get("chat_template_kwargs", {})
@@ -387,20 +402,36 @@ class OpenAIStandard(VendorBase, OpenAIResponsesAPIMixin):
         #     raise
         message = output.choices[0].message
 
-        # Convert tool calls to dict format
+        # Convert tool calls to dict format, preferring dict-shaped entries first
         tool_calls = None
         if message.tool_calls:
-            tool_calls = [
-                {
-                    "id": tc.id,
-                    "type": tc.type,
-                    "function": {
-                        "name": tc.function.name,
-                        "arguments": tc.function.arguments,
-                    },
-                }
-                for tc in message.tool_calls
-            ]
+            converted: list[dict] = []
+            for tc in message.tool_calls:
+                if isinstance(tc, dict):
+                    fn = tc.get("function") or {}
+                    converted.append(
+                        {
+                            "id": tc.get("id"),
+                            "type": tc.get("type", "function"),
+                            "function": {
+                                "name": fn.get("name") or tc.get("name"),
+                                "arguments": fn.get("arguments") or tc.get("arguments"),
+                            },
+                        }
+                    )
+                else:
+                    # SDK object path
+                    converted.append(
+                        {
+                            "id": getattr(tc, "id", None),
+                            "type": getattr(tc, "type", "function"),
+                            "function": {
+                                "name": getattr(getattr(tc, "function", None), "name", None),
+                                "arguments": getattr(getattr(tc, "function", None), "arguments", None),
+                            },
+                        }
+                    )
+            tool_calls = converted or None
 
         # Attach basic usage if available
         usage_dict = None

synth_ai/lm/vendors/supported/custom_endpoint.py

@@ -38,8 +38,18 @@ class CustomEndpointAPI(VendorBase):
         # Construct full chat completions URL
         if endpoint_url.endswith("/"):
             endpoint_url = endpoint_url[:-1]
-        self.chat_completions_url = f"https://{endpoint_url}/chat/completions"
-        self.health_url = f"https://{endpoint_url}/health"
+
+        # Handle full URLs that already include protocol
+        if endpoint_url.startswith(("http://", "https://")):
+            # Remove protocol and domain part, keep only the base path if any
+            parsed = endpoint_url.replace("https://", "").replace("http://", "")
+            base_url = parsed.split("/")[0]  # Get domain only
+            self.chat_completions_url = f"https://{base_url}/chat/completions"
+            self.health_url = f"https://{base_url}/health"
+        else:
+            # Original logic for domain-only URLs
+            self.chat_completions_url = f"https://{endpoint_url}/chat/completions"
+            self.health_url = f"https://{endpoint_url}/health"
 
         # Setup session with connection pooling and retries
         self.session = self._create_session()