timbal 2.2.8__tar.gz → 2.2.10__tar.gz

{timbal-2.2.8 → timbal-2.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: timbal
-Version: 2.2.8
+Version: 2.2.10
 Summary: Simple, performant, battle-tested framework for building reliable AI applications
 Project-URL: Source, https://github.com/timbal-ai/timbal
 Author-email: Timbal <team@timbal.ai>

timbal-2.2.10/docs/api-reference/ace/jobs/create.mdx

@@ -0,0 +1,4 @@
+---
+title: "Enqueue Job"
+openapi: "POST /ace/{ace_uid}/jobs"
+---

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.2.8'
-__version_tuple__ = version_tuple = (2, 2, 8)
+__version__ = version = '2.2.10'
+__version_tuple__ = version_tuple = (2, 2, 10)
 
 __commit_id__ = commit_id = None

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/codegen/__main__.py

@@ -83,10 +83,42 @@ def main() -> None:
         "--stream", "-s", action="store_true", help="Print every event instead of only the final output event."
     )
 
+    # Evals operation
+    evals_parser = subparsers.add_parser(
+        "evals",
+        help="Run evals against the workspace entry point.",
+    )
+    evals_parser.add_argument(
+        "evals_path",
+        nargs="?",
+        default=None,
+        help="Path to an eval file or directory (defaults to the workspace path). "
+        "Use ::eval_name to run a single eval.",
+    )
+    evals_parser.add_argument(
+        "--tags",
+        default=None,
+        help="Comma-separated tag filter; evals matching ANY tag will run.",
+    )
+    evals_parser.add_argument(
+        "--jobs",
+        "-j",
+        type=int,
+        default=1,
+        help="Run up to N evals concurrently (default 1). Results are emitted as they complete.",
+    )
+    evals_parser.add_argument(
+        "--format",
+        choices=["json", "pretty"],
+        default="json",
+        help="Output format: 'json' (default) streams one JSON event per line to stdout as each eval "
+        "completes; 'pretty' is the rich terminal report.",
+    )
+
     # Defer transformer module loading (pulls in libcst + timbal.codegen which
     # are expensive) — only needed for transformer operations, not for
     # list-tools, get-flow, or test.
-    _lightweight_ops = {"get-models", "get-tools", "get-flow", "test"}
+    _lightweight_ops = {"get-models", "get-tools", "get-flow", "test", "evals"}
     if not (_lightweight_ops & set(sys.argv[1:])):
         from timbal.codegen.transformers import load_modules
 
@@ -230,6 +262,73 @@ def main() -> None:
         asyncio.run(run_test(import_spec, params, run_context=run_context, stream=args.stream))
         return
 
+    if operation == "evals":
+        import asyncio
+        import os
+
+        os.environ.setdefault("TIMBAL_SUPPRESS_EVENTS", "tracing_setup")
+        os.environ["TIMBAL_LOG_LEVEL"] = "CRITICAL"
+
+        from ..logs import setup_logging
+
+        setup_logging()
+
+        from dotenv import load_dotenv
+
+        load_dotenv(override=True)
+
+        from . import parse_fqn
+
+        # The workspace entry point is the default runnable for all evals;
+        # individual evals can still override it with their own 'runnable' key.
+        try:
+            runnable = parse_fqn(workspace_path).load()
+        except (FileNotFoundError, ValueError) as e:
+            print(f"error: {e}", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"error: failed to load entry point: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        from timbal.evals.utils import collect_evals
+
+        evals_path_arg = args.evals_path if args.evals_path is not None else str(workspace_path)
+        eval_name = None
+        if "::" in evals_path_arg:
+            evals_path_arg, eval_name = evals_path_arg.rsplit("::", 1)
+        tags = {t.strip() for t in args.tags.split(",")} if args.tags else None
+
+        # Resolve relative eval paths against the workspace (--path), not the
+        # process cwd, so running codegen from outside the workspace works.
+        evals_path = Path(evals_path_arg)
+        if not evals_path.is_absolute():
+            evals_path = workspace_path / evals_path
+
+        try:
+            evals = collect_evals(evals_path, runnable, eval_name, tags)
+        except ValueError as e:
+            print(f"error: {e}", file=sys.stderr)
+            sys.exit(1)
+
+        if not evals:
+            # Warn but keep going, matching the evals CLI: an empty run must
+            # still emit the start/summary events consumers expect.
+            print(f"warning: no evals found in {evals_path}", file=sys.stderr)
+
+        from timbal.evals.runner import run_evals
+
+        if args.format == "pretty":
+            from timbal.evals.reporters import PrettyReporter
+
+            reporter = PrettyReporter()
+        else:
+            from timbal.evals.reporters import JsonReporter
+
+            reporter = JsonReporter()
+
+        summary = asyncio.run(run_evals(evals, reporter=reporter, max_concurrency=args.jobs))
+        sys.exit(0 if summary.failed == 0 else 1)
+
     # Transformer operations — heavy imports already loaded above.
     from timbal.codegen import parse_fqn
     from timbal.codegen.transformers import apply_operation

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/codegen/model_discovery.py

@@ -5,17 +5,18 @@ import yaml
 _MODELS_YAML = Path(__file__).parent.parent / "models.yaml"
 
 _PROVIDER_LOGOS = {
-    "anthropic": "https://content.timbal.ai/assets/anthropic_favicon.svg",
-    "openai": "https://content.timbal.ai/assets/openai_favicon.svg",
-    "google": "https://content.timbal.ai/assets/google_favicon.svg",
-    "togetherai": "https://content.timbal.ai/assets/togetherai_favicon.svg",
-    "xai": "https://content.timbal.ai/assets/xai_favicon.svg",
-    "groq": "https://content.timbal.ai/assets/groq_favicon.svg",
-    "fireworks": "https://content.timbal.ai/assets/fireworks_favicon.svg",
-    "xiaomi": "https://content.timbal.ai/assets/xiaomi_favicon.svg",
-    "byteplus": "https://content.timbal.ai/assets/byteplus_favicon.svg",
-    "cerebras": "https://content.timbal.ai/assets/cerebras_favicon.svg",
-    "sambanova": "https://content.timbal.ai/assets/sambanova_favicon.svg",
+    "anthropic": "https://timbalusercontent.com/assets/anthropic_favicon.svg",
+    "openai": "https://timbalusercontent.com/assets/openai_favicon.svg",
+    "google": "https://timbalusercontent.com/assets/google_favicon.svg",
+    "togetherai": "https://timbalusercontent.com/assets/togetherai_favicon.svg",
+    "xai": "https://timbalusercontent.com/assets/xai_favicon.svg",
+    "groq": "https://timbalusercontent.com/assets/groq_favicon.svg",
+    "fireworks": "https://timbalusercontent.com/assets/fireworks_favicon.svg",
+    "xiaomi": "https://timbalusercontent.com/assets/xiaomi_favicon.svg",
+    "byteplus": "https://timbalusercontent.com/assets/byteplus_favicon.svg",
+    "cerebras": "https://timbalusercontent.com/assets/cerebras_favicon.svg",
+    "sambanova": "https://timbalusercontent.com/assets/sambanova_favicon.svg",
+    "moonshot": "https://timbalusercontent.com/assets/moonshot_favicon.svg",
 }
 
 

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/codegen/tool_discovery.py

@@ -132,7 +132,7 @@ def _discover_framework_tools() -> dict[str, FrameworkTool]:
                         for meta in typing.get_args(candidate)[1:]:
                             if isinstance(meta, _Integration):
                                 provider = meta.provider
-                                provider_logo = f"https://content.timbal.ai/assets/{provider}_favicon.svg"
+                                provider_logo = f"https://timbalusercontent.com/assets/{provider}_favicon.svg"
                                 break
                     if provider:
                         break

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/collectors/impl/openai.py

@@ -1,4 +1,5 @@
 import time
+from collections import deque
 from typing import Any
 
 # `override` was introduced in Python 3.12; use `typing_extensions` for compatibility with older versions
@@ -98,17 +99,37 @@ ResponseEvent = (
 logger = structlog.get_logger("timbal.collectors.impl.openai")
 
 
+def _delta_reasoning_content(delta: Any) -> str | None:
+    """Extract chat-completions reasoning text (Fireworks / DeepSeek / etc.).
+
+    OpenAI's typed ``ChoiceDelta`` does not declare ``reasoning_content``; providers
+    put it on the delta as an extra field (kept in ``model_extra``).
+    """
+    rc = getattr(delta, "reasoning_content", None)
+    if isinstance(rc, str) and rc:
+        return rc
+    extra = getattr(delta, "model_extra", None) or {}
+    if isinstance(extra, dict):
+        for key in ("reasoning_content", "reasoning"):
+            val = extra.get(key)
+            if isinstance(val, str) and val:
+                return val
+    return None
+
+
 @register_collector
 class ChatCompletionCollector(BaseCollector):
     """Collector for OpenAI chat completions streaming events."""
 
     # Content block ID for text content (chat completions only have one text block)
     TEXT_BLOCK_ID = "text_0"
+    THINKING_BLOCK_ID = "thinking_0"
 
     def __init__(self, start: float, **kwargs: Any):
         super().__init__(**kwargs)
         self._start = start
         self._content: str = ""
+        self._thinking: str = ""
         # `_current_tool_call` is appended to `_tool_calls` by reference (same dict).
         # Subsequent mutations of `_current_tool_call` propagate to the entry in
         # `_tool_calls` without needing to re-append.
@@ -118,15 +139,40 @@ class ChatCompletionCollector(BaseCollector):
         self._first_token: float | None = None
         self._output_tokens: int = 0
         self._text_block_started: bool = False
+        self._thinking_block_started: bool = False
         self._content_blocks: set[str] = set()
         self._stop_reason: str | None = None
         self._pending_usage: Any | None = None  # Last usage event, written once in result()
+        # One source chunk can produce multiple stream items (e.g. reasoning + text).
+        # process() returns the first; the rest drain via __anext__ / pop_pending_stream_item().
+        self._pending_stream_items: deque[Any] = deque()
 
     @classmethod
     @override
     def can_handle(cls, event: Any) -> bool:
         return isinstance(event, ChatCompletionEvent)
 
+    def pop_pending_stream_item(self) -> Any | None:
+        """Return the next queued stream item, if any (used after process() on the peek chunk)."""
+        if self._pending_stream_items:
+            return self._pending_stream_items.popleft()
+        return None
+
+    async def __anext__(self):
+        pending = self.pop_pending_stream_item()
+        if pending is not None:
+            return pending
+        return await super().__anext__()
+
+    def _emit_stream_items(self, items: list[Any]) -> Any:
+        """Return the first stream item and queue any remaining for later yields."""
+        filtered = [item for item in items if item is not None]
+        if not filtered:
+            return None
+        first, *rest = filtered
+        self._pending_stream_items.extend(rest)
+        return first
+
     @override
     def process(self, event: ChatCompletionEvent) -> Any:
         """Processes OpenAI streaming events."""
@@ -143,15 +189,24 @@ class ChatCompletionCollector(BaseCollector):
         # 'length' indicates max_tokens was reached
         if event.choices[0].finish_reason:
             self._stop_reason = event.choices[0].finish_reason
-        # Calculate TTFT (Time To First Token) on first token
-        if self._first_token is None:
+        delta = event.choices[0].delta
+        has_tool_calls = bool(delta.tool_calls)
+        reasoning = _delta_reasoning_content(delta)
+        has_text = bool(delta.content)
+        # Calculate TTFT on first visible / reasoning / tool token
+        if self._first_token is None and (has_tool_calls or reasoning or has_text):
             self._first_token = time.perf_counter()
-        # Handle tool calls
-        if event.choices[0].delta.tool_calls:
-            return self._handle_tool_calls(event)
-        # Handle text content
-        if event.choices[0].delta.content:
-            return self._handle_text_content(event)
+
+        # Fireworks / Moonshot / DeepSeek-style: reasoning may co-arrive with
+        # visible content or tool_calls on the same chunk. Emit all of them.
+        items: list[Any] = []
+        if reasoning:
+            items.append(self._handle_reasoning_content(reasoning))
+        if has_tool_calls:
+            items.append(self._handle_tool_calls(event))
+        elif has_text:
+            items.append(self._handle_text_content(event))
+        return self._emit_stream_items(items)
 
     @staticmethod
     def _usage_billing_id(api_model: str) -> str:
@@ -296,6 +351,21 @@ class ChatCompletionCollector(BaseCollector):
             )
         return None
 
+    def _handle_reasoning_content(self, reasoning_chunk: str) -> TimbalThinking | TimbalThinkingDelta:
+        """Handle ``delta.reasoning_content`` from OpenAI-compatible reasoning models."""
+        self._thinking += reasoning_chunk
+        if not self._thinking_block_started:
+            self._thinking_block_started = True
+            self._content_blocks.add(self.THINKING_BLOCK_ID)
+            return TimbalThinking(
+                id=self.THINKING_BLOCK_ID,
+                thinking=reasoning_chunk,
+            )
+        return TimbalThinkingDelta(
+            id=self.THINKING_BLOCK_ID,
+            thinking_delta=reasoning_chunk,
+        )
+
     def _handle_text_content(self, event: ChatCompletionEvent) -> TimbalText | TimbalTextDelta:
         """Handle text content from OpenAI events."""
         text_chunk = event.choices[0].delta.content
@@ -325,12 +395,17 @@ class ChatCompletionCollector(BaseCollector):
             self._handle_usage(self._pending_usage)
 
         span = get_run_context().current_span()
-        ttft = self._first_token - self._start
+        # finish_reason-only chunks never set _first_token — keep metrics defined.
+        first = self._first_token if self._first_token is not None else time.perf_counter()
+        ttft = first - self._start
         span.metadata["ttft"] = ttft
-        tps = self._output_tokens / (time.perf_counter() - self._first_token)
+        elapsed = time.perf_counter() - first
+        tps = self._output_tokens / elapsed if elapsed > 0 else 0.0
         span.metadata["tps"] = tps
 
-        content = []
+        content: list[Any] = []
+        if self._thinking:
+            content.append({"type": "thinking", "thinking": self._thinking})
         if self._content:
             content.append(self._content)
 

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/core/llm_router.py

@@ -118,6 +118,15 @@ class _ProviderConfig:
     supports_stream_options: bool = True
     """Whether the provider supports ``stream_options`` in Chat Completions."""
 
+    supports_platform_proxy: bool = True
+    """If False, never fall back to the Timbal platform proxy — require the provider API key."""
+
+    supports_chat_reasoning_content: bool = False
+    """If True, serialize ThinkingContent as top-level ``reasoning_content`` (Moonshot/Fireworks-style).
+
+    Otherwise thinking is omitted from outbound chat-completions messages (Vercel/LiteLLM default).
+    """
+
 
 _PROVIDERS: dict[str, _ProviderConfig] = {
     "openai": _ProviderConfig(
@@ -137,6 +146,7 @@ _PROVIDERS: dict[str, _ProviderConfig] = {
     "togetherai": _ProviderConfig(
         env_key="TOGETHER_API_KEY",
         default_base_url="https://api.together.xyz/v1/",
+        supports_chat_reasoning_content=True,
     ),
     "xai": _ProviderConfig(
         env_key="XAI_API_KEY",
@@ -150,10 +160,12 @@ _PROVIDERS: dict[str, _ProviderConfig] = {
     "fireworks": _ProviderConfig(
         env_key="FIREWORKS_API_KEY",
         default_base_url="https://api.fireworks.ai/inference/v1",
+        supports_chat_reasoning_content=True,
     ),
     "byteplus": _ProviderConfig(
         env_key="BYTEPLUS_API_KEY",
         default_base_url="https://ark.ap-southeast.bytepluses.com/api/v3",
+        supports_chat_reasoning_content=True,
     ),
     "xiaomi": _ProviderConfig(
         env_key="XIAOMI_API_KEY",
@@ -165,6 +177,12 @@ _PROVIDERS: dict[str, _ProviderConfig] = {
         env_key="CEREBRAS_API_KEY",
         default_base_url="https://api.cerebras.ai/v1",
     ),
+    "moonshot": _ProviderConfig(
+        env_key="MOONSHOT_API_KEY",
+        default_base_url="https://api.moonshot.ai/v1",
+        supports_platform_proxy=False,
+        supports_chat_reasoning_content=True,
+    ),
     "sambanova": _ProviderConfig(
         env_key="SAMBANOVA_API_KEY",
         default_base_url="https://api.sambanova.ai/v1",
@@ -188,7 +206,11 @@ def _resolve_client(
     if not api_key:
         api_key = os.getenv(config.env_key)
     if not api_key:
-        if run_context.platform_config is not None and run_context.platform_config.subject is not None:
+        if (
+            config.supports_platform_proxy
+            and run_context.platform_config is not None
+            and run_context.platform_config.subject is not None
+        ):
             api_key = run_context.platform_config.auth.header_value
             base_url = (
                 f"https://{run_context.platform_config.host}"
@@ -416,8 +438,9 @@ async def _llm_router(
     # Per-request headers: change every call, so passed via extra_headers on each .create().
     request_headers: dict[str, str] = {
         "x-timbal-run-id": run_context.id,
-        "x-timbal-call-id": call_id,
     }
+    if call_id:
+        request_headers["x-timbal-call-id"] = call_id
     if run_context.platform_config and run_context.platform_config.subject:
         if run_context.platform_config.subject.app_id:
             request_headers["x-timbal-app-id"] = run_context.platform_config.subject.app_id
@@ -528,8 +551,9 @@ async def _llm_router(
         chat_completions_messages = []
         if system_prompt:
             chat_completions_messages.append({"role": "system", "content": system_prompt})
+        reasoning_as = "reasoning_content" if config.supports_chat_reasoning_content else "omit"
         for message in messages:
-            chat_completions_message = message.to_openai_chat_completions_input()
+            chat_completions_message = message.to_openai_chat_completions_input(reasoning_as=reasoning_as)
             chat_completions_messages.append(chat_completions_message)
 
         # Some providers have incomplete OpenAI chat completions support.

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/core/models.py

@@ -54,7 +54,12 @@ Model = Literal[
     "anthropic/claude-sonnet-4-5",
     "anthropic/claude-haiku-4-5",
     "openai/gpt-5.5",
+    "openai/gpt-5.5-pro",
+    "openai/gpt-5.6-sol",
+    "openai/gpt-5.6-terra",
+    "openai/gpt-5.6-luna",
     "openai/gpt-5.4",
+    "openai/gpt-5.4-pro",
     "openai/gpt-5.4-mini",
     "openai/gpt-5.4-nano",
     "openai/gpt-5.3-chat-latest",
@@ -88,9 +93,12 @@ Model = Literal[
     "togetherai/deepseek-ai/DeepSeek-V3.1",
     "togetherai/deepseek-ai/DeepSeek-V4-Pro",
     "togetherai/moonshotai/Kimi-K2.6",
+    "togetherai/moonshotai/Kimi-K2.7-Code",
     "togetherai/MiniMaxAI/MiniMax-M2.7",
+    "togetherai/MiniMaxAI/MiniMax-M3",
     "togetherai/zai-org/GLM-5",
     "togetherai/zai-org/GLM-5.1",
+    "togetherai/zai-org/GLM-5.2",
     "togetherai/zai-org/GLM-4.7",
     "togetherai/openai/gpt-oss-120b",
     "togetherai/openai/gpt-oss-20b",
@@ -108,28 +116,27 @@ Model = Literal[
     "google/gemini-2.5-flash-lite",
     "google/gemini-2.5-flash-image",
     "google/gemini-2.5-flash-preview-tts",
-    "xai/grok-4",
-    "xai/grok-4-fast-reasoning",
-    "xai/grok-4-fast-non-reasoning",
-    "xai/grok-4-1-fast-reasoning",
-    "xai/grok-4-1-fast-non-reasoning",
-    "groq/meta-llama/llama-4-scout-17b-16e-instruct",
+    "xai/grok-4.5",
+    "xai/grok-4.3",
     "groq/llama-3.3-70b-versatile",
     "groq/llama-3.1-8b-instant",
-    "groq/qwen/qwen3-32b",
+    "groq/qwen/qwen3.6-27b",
     "groq/openai/gpt-oss-120b",
     "groq/openai/gpt-oss-20b",
     "fireworks/accounts/fireworks/models/deepseek-v4-pro",
+    "fireworks/accounts/fireworks/models/deepseek-v4-flash",
     "fireworks/accounts/fireworks/models/qwen3p6-plus",
+    "fireworks/accounts/fireworks/models/qwen3p7-plus",
     "fireworks/accounts/fireworks/models/kimi-k2p6",
+    "fireworks/accounts/fireworks/models/kimi-k2p7-code",
     "fireworks/accounts/fireworks/models/kimi-k2p5",
     "fireworks/accounts/fireworks/models/minimax-m2p5",
+    "fireworks/accounts/fireworks/models/minimax-m2p7",
+    "fireworks/accounts/fireworks/models/minimax-m3",
     "fireworks/accounts/fireworks/models/gpt-oss-120b",
     "fireworks/accounts/fireworks/models/gpt-oss-20b",
     "fireworks/accounts/fireworks/models/glm-5p1",
-    "xiaomi/mimo-v2-pro",
-    "xiaomi/mimo-v2-omni",
-    "xiaomi/mimo-v2-flash",
+    "fireworks/accounts/fireworks/models/glm-5p2",
     "xiaomi/mimo-v2.5",
     "xiaomi/mimo-v2.5-pro",
     "byteplus/seed-2-0-lite-260228",
@@ -156,4 +163,9 @@ Model = Literal[
     "sambanova/MiniMax-M2.7",
     "sambanova/gemma-3-12b-it",
     "sambanova/gemma-4-31B-it",
+    "moonshot/kimi-k3",
+    "moonshot/kimi-k2.7-code",
+    "moonshot/kimi-k2.7-code-highspeed",
+    "moonshot/kimi-k2.6",
+    "moonshot/kimi-k2.5",
 ]

{timbal-2.2.8 → timbal-2.2.10}/python/timbal/core/runnable.py

@@ -1022,12 +1022,22 @@ class Runnable(ABC, BaseModel):
                         event_queue.put_nowait(event)
                     return event
 
-                # We need to manually process the first chunk, since we removed it from the generator
+                # We need to manually process the first chunk, since we removed it from the generator.
+                # Some collectors (e.g. ChatCompletionCollector) can emit multiple stream items
+                # per source chunk — process() returns the first and queues the rest.
                 first_event = collector.process(first_chunk)
-                if first_event is not None:
-                    first_event = process_event(first_event)
-                    if first_event is not None:
-                        yield (first_event, None, collector)
+                pending_events = [first_event] if first_event is not None else []
+                pop_pending = getattr(collector, "pop_pending_stream_item", None)
+                if callable(pop_pending):
+                    while True:
+                        pending_item = pop_pending()
+                        if pending_item is None:
+                            break
+                        pending_events.append(pending_item)
+                for raw_event in pending_events:
+                    event = process_event(raw_event)
+                    if event is not None:
+                        yield (event, None, collector)
                 # Process remaining events
                 async for event in collector:
                     event = process_event(event)