genkit 0.5.2__tar.gz → 0.6.0__tar.gz

{genkit-0.5.2 → genkit-0.6.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: genkit
-Version: 0.5.2
+Version: 0.6.0
 Summary: Genkit AI Framework
-Project-URL: Bug Tracker, https://github.com/firebase/genkit/issues
-Project-URL: Changelog, https://github.com/firebase/genkit/blob/main/py/packages/genkit/CHANGELOG.md
+Project-URL: Bug Tracker, https://github.com/genkit-ai/genkit/issues
+Project-URL: Changelog, https://github.com/genkit-ai/genkit/blob/main/py/packages/genkit/CHANGELOG.md
 Project-URL: Documentation, https://firebase.google.com/docs/genkit
-Project-URL: Homepage, https://github.com/firebase/genkit
-Project-URL: Repository, https://github.com/firebase/genkit/tree/main/py
+Project-URL: Homepage, https://github.com/genkit-ai/genkit
+Project-URL: Repository, https://github.com/genkit-ai/genkit/tree/main/py
 Author: Google
 License-Expression: Apache-2.0
 License-File: LICENSE

{genkit-0.5.2 → genkit-0.6.0}/pyproject.toml

@@ -76,7 +76,7 @@ license = "Apache-2.0"
 name = "genkit"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.5.2"
+version = "0.6.0"
 
 [project.optional-dependencies]
 flask                 = ["genkit-plugin-flask"]
@@ -87,11 +87,11 @@ openai                = ["genkit-plugin-compat-oai"]
 vertex-ai             = ["genkit-plugin-vertex-ai"]
 
 [project.urls]
-"Bug Tracker"   = "https://github.com/firebase/genkit/issues"
-"Changelog"     = "https://github.com/firebase/genkit/blob/main/py/packages/genkit/CHANGELOG.md"
+"Bug Tracker"   = "https://github.com/genkit-ai/genkit/issues"
+"Changelog"     = "https://github.com/genkit-ai/genkit/blob/main/py/packages/genkit/CHANGELOG.md"
 "Documentation" = "https://firebase.google.com/docs/genkit"
-"Homepage"      = "https://github.com/firebase/genkit"
-"Repository"    = "https://github.com/firebase/genkit/tree/main/py"
+"Homepage"      = "https://github.com/genkit-ai/genkit"
+"Repository"    = "https://github.com/genkit-ai/genkit/tree/main/py"
 
 [build-system]
 build-backend = "hatchling.build"

{genkit-0.5.2 → genkit-0.6.0}/src/genkit/__init__.py

@@ -21,9 +21,15 @@ from genkit._ai._prompt import (
     ExecutablePrompt,
     ModelStreamResponse,
     PromptGenerateOptions,
-    ResumeOptions,
 )
-from genkit._ai._tools import ToolInterruptError, ToolRunContext, tool_response
+from genkit._ai._tools import (
+    Interrupt,
+    Tool,
+    ToolRunContext,
+    respond_to_interrupt,
+    restart_tool,
+    tool,
+)
 from genkit._core._action import Action, StreamResponse
 from genkit._core._error import GenkitError, PublicError
 from genkit._core._model import Document
@@ -93,7 +99,11 @@ __all__ = [
     # Errors
     'GenkitError',
     'PublicError',
-    'ToolInterruptError',
+    'Interrupt',
+    'Tool',
+    'respond_to_interrupt',
+    'restart_tool',
+    'tool',
     # Content types
     'Constrained',
     'CustomPart',
@@ -126,9 +136,7 @@ __all__ = [
     'ActionRunContext',
     'ExecutablePrompt',
     'PromptGenerateOptions',
-    'ResumeOptions',
     'ToolRunContext',
-    'tool_response',
     'ModelRequest',
     'ModelResponse',
     'ModelResponseChunk',

{genkit-0.5.2 → genkit-0.6.0}/src/genkit/_ai/_aio.py

@@ -21,18 +21,17 @@ from __future__ import annotations
 import asyncio
 import inspect
 import json
+import os
 import signal
 import socket
 import threading
 import uuid
-from collections.abc import Awaitable, Callable, Coroutine
+from collections.abc import Awaitable, Callable, Coroutine, Sequence
 from pathlib import Path
-from typing import Any, ParamSpec, TypeVar, cast, overload
+from typing import Any, TypeVar, cast, overload
 
 import anyio
 import uvicorn
-from opentelemetry import trace as trace_api
-from opentelemetry.sdk.trace import TracerProvider
 from pydantic import BaseModel
 
 from genkit._ai._embedding import EmbedderFn, EmbedderOptions, EmbedderRef, define_embedder
@@ -45,7 +44,7 @@ from genkit._ai._evaluator import (
 )
 from genkit._ai._formats import built_in_formats
 from genkit._ai._formats._types import FormatDef
-from genkit._ai._generate import define_generate_action, generate_action
+from genkit._ai._generate import define_generate_action, generate_action, registry_with_inline_tools
 from genkit._ai._model import (
     Message,
     ModelConfig,
@@ -71,7 +70,7 @@ from genkit._ai._resource import (
     ResourceOptions,
     define_resource,
 )
-from genkit._ai._tools import define_tool
+from genkit._ai._tools import Tool, define_interrupt, define_tool
 from genkit._core._action import Action, ActionKind, ActionRunContext
 from genkit._core._background import (
     BackgroundAction,
@@ -94,8 +93,9 @@ from genkit._core._logger import get_logger
 from genkit._core._model import Document
 from genkit._core._plugin import Plugin
 from genkit._core._reflection import ReflectionServer, ServerSpec, create_reflection_asgi_app
+from genkit._core._reflection_v2 import ReflectionServerV2
 from genkit._core._registry import Registry
-from genkit._core._tracing import run_in_new_span
+from genkit._core._tracing import SpanMetadata, run_in_new_span
 from genkit._core._typing import (
     BaseDataPoint,
     Embedding,
@@ -105,8 +105,9 @@ from genkit._core._typing import (
     ModelInfo,
     Operation,
     Part,
-    SpanMetadata,
     ToolChoice,
+    ToolRequestPart,
+    ToolResponsePart,
 )
 
 from ._decorators import _FlowDecorator, _FlowDecoratorWithChunk
@@ -118,7 +119,7 @@ logger = get_logger(__name__)
 InputT = TypeVar('InputT')
 OutputT = TypeVar('OutputT')
 ChunkT = TypeVar('ChunkT')
-P = ParamSpec('P')
+
 R = TypeVar('R')
 T = TypeVar('T')
 
@@ -260,16 +261,45 @@ class Genkit:
             metadata=metadata,
         )
 
-    def tool(
-        self, name: str | None = None, description: str | None = None
-    ) -> Callable[[Callable[P, T]], Callable[P, T]]:
+    def tool(self, name: str | None = None, description: str | None = None) -> Callable[[Callable[..., Any]], Tool]:
         """Decorator to register a function as a tool."""
 
-        def wrapper(func: Callable[P, T]) -> Callable[P, T]:
+        def wrapper(func: Callable[..., Any]) -> Tool:
             return define_tool(self.registry, func, name, description)
 
         return wrapper
 
+    def define_interrupt(
+        self,
+        name: str,
+        *,
+        input_schema: type[BaseModel] | dict[str, object] | None = None,
+        description: str | None = None,
+    ) -> Tool:
+        """Register an interrupt tool that always pauses for user input.
+
+        Args:
+            name: Tool name
+            input_schema: Optional input schema (Pydantic model or JSON schema dict)
+            description: Tool description
+
+        Returns:
+            The registered interrupt tool
+
+        Example:
+            ask_user = ai.define_interrupt(
+                name='ask_user',
+                input_schema=Question,
+                description='Ask the user a question',
+            )
+        """
+        return define_interrupt(
+            self.registry,
+            name,
+            description=description,
+            input_schema=input_schema,
+        )
+
     def define_evaluator(
         self,
         *,
@@ -393,7 +423,7 @@ class Genkit:
         max_turns: int | None = None,
         return_tool_requests: bool | None = None,
         metadata: dict[str, object] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         tool_choice: ToolChoice | None = None,
         use: list[ModelMiddleware] | None = None,
         docs: list[Document] | None = None,
@@ -421,7 +451,7 @@ class Genkit:
         max_turns: int | None = None,
         return_tool_requests: bool | None = None,
         metadata: dict[str, object] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         tool_choice: ToolChoice | None = None,
         use: list[ModelMiddleware] | None = None,
         docs: list[Document] | None = None,
@@ -449,7 +479,7 @@ class Genkit:
         max_turns: int | None = None,
         return_tool_requests: bool | None = None,
         metadata: dict[str, object] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         tool_choice: ToolChoice | None = None,
         use: list[ModelMiddleware] | None = None,
         docs: list[Document] | None = None,
@@ -477,7 +507,7 @@ class Genkit:
         max_turns: int | None = None,
         return_tool_requests: bool | None = None,
         metadata: dict[str, object] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         tool_choice: ToolChoice | None = None,
         use: list[ModelMiddleware] | None = None,
         docs: list[Document] | None = None,
@@ -503,7 +533,7 @@ class Genkit:
         max_turns: int | None = None,
         return_tool_requests: bool | None = None,
         metadata: dict[str, object] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         tool_choice: ToolChoice | None = None,
         use: list[ModelMiddleware] | None = None,
         docs: list[Document] | None = None,
@@ -630,9 +660,22 @@ class Genkit:
     # -------------------------------------------------------------------------
 
     def _start_reflection_background(self) -> None:
-        """Start the Dev UI reflection server in a background daemon thread."""
+        """Start the Dev UI reflection server in a background daemon thread.
+
+        If GENKIT_REFLECTION_V2_SERVER is set (the CLI launches the runtime in
+        v2 mode and provides a WebSocket URL), run the v2 JSON-RPC client.
+        Otherwise start the v1 HTTP server.
+        """
 
         async def _run_server() -> None:
+            v2_url = os.environ.get('GENKIT_REFLECTION_V2_SERVER')
+            if v2_url:
+                await logger.ainfo(f'Genkit Dev UI reflection v2 client connecting to {v2_url}')
+                server_v2 = ReflectionServerV2(self.registry, v2_url)
+                self._reflection_ready.set()
+                await server_v2.run_forever()
+                return
+
             sockets: list[socket.socket] | None = None
             spec = self._reflection_server_spec
             if spec is None:
@@ -668,9 +711,8 @@ class Genkit:
 
     def _initialize_registry(self, model: str | None, plugins: list[Plugin] | None) -> None:
         """Initialize the registry with default model and plugins."""
-        self.registry.default_model = model
         if model:
-            self.registry.register_value('defaultModel', model, model)
+            self.registry.register_value('defaultModel', 'defaultModel', model)
         for fmt in built_in_formats:
             self.define_format(fmt)
 
@@ -743,10 +785,12 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
-        tool_responses: list[Part] | None = None,
+        resume_respond: ToolResponsePart | list[ToolResponsePart] | None = None,
+        resume_restart: ToolRequestPart | list[ToolRequestPart] | None = None,
+        resume_metadata: dict[str, Any] | None = None,
         config: dict[str, object] | ModelConfig | None = None,
         max_turns: int | None = None,
         context: dict[str, object] | None = None,
@@ -768,10 +812,12 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
-        tool_responses: list[Part] | None = None,
+        resume_respond: ToolResponsePart | list[ToolResponsePart] | None = None,
+        resume_restart: ToolRequestPart | list[ToolRequestPart] | None = None,
+        resume_metadata: dict[str, Any] | None = None,
         config: dict[str, object] | ModelConfig | None = None,
         max_turns: int | None = None,
         context: dict[str, object] | None = None,
@@ -791,10 +837,12 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
-        tool_responses: list[Part] | None = None,
+        resume_respond: ToolResponsePart | list[ToolResponsePart] | None = None,
+        resume_restart: ToolRequestPart | list[ToolRequestPart] | None = None,
+        resume_metadata: dict[str, Any] | None = None,
         config: dict[str, object] | ModelConfig | None = None,
         max_turns: int | None = None,
         context: dict[str, object] | None = None,
@@ -806,30 +854,37 @@ class Genkit:
         use: list[ModelMiddleware] | None = None,
         docs: list[Document] | None = None,
     ) -> ModelResponse[Any]:
-        """Generate text or structured data using a language model."""
+        """Generate text or structured data using a language model.
+
+        ``tools`` is typed as ``Sequence`` rather than ``list`` because ``Sequence``
+        is covariant: ``list[Tool]`` or ``list[str]`` are both assignable to
+        ``Sequence[str | Tool]``, but not to ``list[str | Tool]``.
+        """
+        prompt_config = PromptConfig(
+            model=model,
+            prompt=prompt,
+            system=system,
+            messages=messages,
+            tools=tools,
+            return_tool_requests=return_tool_requests,
+            tool_choice=tool_choice,
+            resume_respond=resume_respond,
+            resume_restart=resume_restart,
+            resume_metadata=resume_metadata,
+            config=config,
+            max_turns=max_turns,
+            output_format=output_format,
+            output_content_type=output_content_type,
+            output_instructions=output_instructions,
+            output_schema=output_schema,
+            output_constrained=output_constrained,
+            docs=docs,
+        )
+        registry = await registry_with_inline_tools(self.registry, prompt_config.tools)
+        gen_options = await to_generate_action_options(registry, prompt_config)
         return await generate_action(
-            self.registry,
-            await to_generate_action_options(
-                self.registry,
-                PromptConfig(
-                    model=model,
-                    prompt=prompt,
-                    system=system,
-                    messages=messages,
-                    tools=tools,
-                    return_tool_requests=return_tool_requests,
-                    tool_choice=tool_choice,
-                    tool_responses=tool_responses,
-                    config=config,
-                    max_turns=max_turns,
-                    output_format=output_format,
-                    output_content_type=output_content_type,
-                    output_instructions=output_instructions,
-                    output_schema=output_schema,
-                    output_constrained=output_constrained,
-                    docs=docs,
-                ),
-            ),
+            registry,
+            gen_options,
             middleware=use,
             context=context if context else ActionRunContext._current_context(),  # pyright: ignore[reportPrivateUsage]
         )
@@ -843,9 +898,12 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
+        resume_respond: ToolResponsePart | list[ToolResponsePart] | None = None,
+        resume_restart: ToolRequestPart | list[ToolRequestPart] | None = None,
+        resume_metadata: dict[str, Any] | None = None,
         config: dict[str, object] | ModelConfig | None = None,
         max_turns: int | None = None,
         context: dict[str, object] | None = None,
@@ -868,9 +926,12 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
+        resume_respond: ToolResponsePart | list[ToolResponsePart] | None = None,
+        resume_restart: ToolRequestPart | list[ToolRequestPart] | None = None,
+        resume_metadata: dict[str, Any] | None = None,
         config: dict[str, object] | ModelConfig | None = None,
         max_turns: int | None = None,
         context: dict[str, object] | None = None,
@@ -891,9 +952,12 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
+        resume_respond: ToolResponsePart | list[ToolResponsePart] | None = None,
+        resume_restart: ToolRequestPart | list[ToolRequestPart] | None = None,
+        resume_metadata: dict[str, Any] | None = None,
         config: dict[str, object] | ModelConfig | None = None,
         max_turns: int | None = None,
         context: dict[str, object] | None = None,
@@ -910,28 +974,31 @@ class Genkit:
         channel: Channel[ModelResponseChunk, ModelResponse[Any]] = Channel(timeout=timeout)
 
         async def _run_generate() -> ModelResponse[Any]:
+            prompt_config = PromptConfig(
+                model=model,
+                prompt=prompt,
+                system=system,
+                messages=messages,
+                tools=tools,
+                return_tool_requests=return_tool_requests,
+                tool_choice=tool_choice,
+                resume_respond=resume_respond,
+                resume_restart=resume_restart,
+                resume_metadata=resume_metadata,
+                config=config,
+                max_turns=max_turns,
+                output_format=output_format,
+                output_content_type=output_content_type,
+                output_instructions=output_instructions,
+                output_schema=output_schema,
+                output_constrained=output_constrained,
+                docs=docs,
+            )
+            registry = await registry_with_inline_tools(self.registry, prompt_config.tools)
+            gen_options = await to_generate_action_options(registry, prompt_config)
             return await generate_action(
-                self.registry,
-                await to_generate_action_options(
-                    self.registry,
-                    PromptConfig(
-                        model=model,
-                        prompt=prompt,
-                        system=system,
-                        messages=messages,
-                        tools=tools,
-                        return_tool_requests=return_tool_requests,
-                        tool_choice=tool_choice,
-                        config=config,
-                        max_turns=max_turns,
-                        output_format=output_format,
-                        output_content_type=output_content_type,
-                        output_instructions=output_instructions,
-                        output_schema=output_schema,
-                        output_constrained=output_constrained,
-                        docs=docs,
-                    ),
-                ),
+                registry,
+                gen_options,
                 on_chunk=lambda c: channel.send(c),
                 middleware=use,
                 context=context if context else ActionRunContext._current_context(),  # pyright: ignore[reportPrivateUsage]
@@ -1055,32 +1122,6 @@ class Genkit:
         """Get the current execution context, or None if not in an action."""
         return ActionRunContext._current_context()  # pyright: ignore[reportPrivateUsage]
 
-    def dynamic_tool(
-        self,
-        *,
-        name: str,
-        fn: Callable[..., object],
-        description: str | None = None,
-        metadata: dict[str, object] | None = None,
-    ) -> Action:
-        """Create an unregistered tool action for passing directly to generate()."""
-        tool_meta: dict[str, object] = metadata.copy() if metadata else {}
-        tool_meta['type'] = 'tool'
-        tool_meta['dynamic'] = True
-        return Action(
-            kind=ActionKind.TOOL,
-            name=name,
-            fn=fn,  # type: ignore[arg-type]  # dynamic tools may be sync
-            description=description,
-            metadata=tool_meta,
-        )
-
-    async def flush_tracing(self) -> None:
-        """Flush all pending trace spans to exporters."""
-        provider = trace_api.get_tracer_provider()
-        if isinstance(provider, TracerProvider):
-            await asyncio.to_thread(provider.force_flush)
-
     async def run(
         self,
         *,
@@ -1092,8 +1133,8 @@ class Genkit:
         if not inspect.iscoroutinefunction(fn):
             raise TypeError('fn must be a coroutine function')
 
-        span_metadata = SpanMetadata(name=name, metadata=metadata)
-        with run_in_new_span(span_metadata, labels={'genkit:type': 'flowStep'}) as span:
+        span_metadata = SpanMetadata(name=name, type='flowStep', metadata=metadata)
+        with run_in_new_span(span_metadata) as span:
             try:
                 result = await fn()
                 output = (
@@ -1132,7 +1173,7 @@ class Genkit:
         prompt: str | list[Part] | None = None,
         system: str | list[Part] | None = None,
         messages: list[Message] | None = None,
-        tools: list[str] | None = None,
+        tools: Sequence[str | Tool] | None = None,
         return_tool_requests: bool | None = None,
         tool_choice: ToolChoice | None = None,
         config: dict[str, object] | ModelConfig | None = None,
@@ -1148,7 +1189,7 @@ class Genkit:
     ) -> Operation:
         """Generate content using a long-running model, returning an Operation to poll."""
         # Resolve the model and check for long_running support
-        resolved_model = model or self.registry.default_model
+        resolved_model = model or cast(str | None, self.registry.lookup_value('defaultModel', 'defaultModel'))
         if not resolved_model:
             raise GenkitError(
                 status='INVALID_ARGUMENT',

{genkit-0.5.2 → genkit-0.6.0}/src/genkit/_ai/_embedding.py

@@ -23,11 +23,11 @@ from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 from typing_extensions import Never
 
-from genkit._core._action import Action, ActionKind, ActionMetadata, get_func_description
+from genkit._core._action import Action, ActionKind, get_func_description
 from genkit._core._model import Document
 from genkit._core._registry import Registry
 from genkit._core._schema import to_json_schema
-from genkit._core._typing import EmbedRequest, EmbedResponse
+from genkit._core._typing import ActionMetadata, EmbedRequest, EmbedResponse
 
 
 class EmbedderSupports(BaseModel):
@@ -103,7 +103,7 @@ def embedder_action_metadata(
     embedder_info['customOptions'] = options.config_schema if options.config_schema else None
 
     return ActionMetadata(
-        kind=ActionKind.EMBEDDER,
+        action_type=ActionKind.EMBEDDER,
         name=name,
         input_json_schema=to_json_schema(EmbedRequest),
         output_json_schema=to_json_schema(EmbedResponse),

{genkit-0.5.2 → genkit-0.6.0}/src/genkit/_ai/_evaluator.py

@@ -25,19 +25,19 @@ from typing import Any, ClassVar, TypeVar, cast
 from pydantic import BaseModel, ConfigDict
 from pydantic.alias_generators import to_camel
 
-from genkit._core._action import Action, ActionKind, ActionMetadata
+from genkit._core._action import Action, ActionKind
 from genkit._core._logger import get_logger
 from genkit._core._registry import Registry
 from genkit._core._schema import to_json_schema
-from genkit._core._tracing import run_in_new_span
+from genkit._core._tracing import SpanMetadata, run_in_new_span
 from genkit._core._typing import (
+    ActionMetadata,
     BaseDataPoint,
     EvalFnResponse,
     EvalRequest,
     EvalResponse,
     EvalStatusEnum,
     Score,
-    SpanMetadata,
 )
 
 logger = get_logger(__name__)
@@ -76,7 +76,7 @@ def evaluator_action_metadata(
 ) -> ActionMetadata:
     """Create ActionMetadata for an evaluator action."""
     return ActionMetadata(
-        kind=ActionKind.EVALUATOR,
+        action_type=ActionKind.EVALUATOR,
         name=name,
         input_json_schema=to_json_schema(EvalRequest),
         output_json_schema=to_json_schema(list[EvalFnResponse]),
@@ -132,13 +132,15 @@ def define_evaluator(
                 datapoint.test_case_id = str(uuid.uuid4())
             span_metadata = SpanMetadata(
                 name=f'Test Case {datapoint.test_case_id}',
+                type='evaluator',
+                input=datapoint,
                 metadata={'evaluator:evalRunId': req.eval_run_id},
             )
             try:
                 # Try to run with tracing, but fallback if tracing infrastructure fails
                 # (e.g., in environments with NonRecordingSpans like pre-commit)
                 try:
-                    with run_in_new_span(span_metadata, labels={'genkit:type': 'evaluator'}) as span:
+                    with run_in_new_span(span_metadata) as span:
                         span_id = format(span.get_span_context().span_id, '016x')
                         trace_id = format(span.get_span_context().trace_id, '032x')
                         try: