chore(py): bump versions to 0.5.2 and more fixes (#5005)

Co-authored-by: gemini-code-assist[bot] <176961590+gemini-code-assist[bot]@users.noreply.github.com>

Author: huangjeff5

py/bin/release_check

@@ -187,7 +187,7 @@ fi
 
 echo -e "\n${CYAN}Checking plugins...${NC}"
 for d in plugins/*/; do
-  if [ -d "$d" ]; then
+  if [ -d "$d" ] && [ -f "${d}pyproject.toml" ]; then
     if ! check_package_metadata "$d" "plugin"; then
       ERRORS=$((ERRORS + 1))
     elif [ "$VERBOSE" = true ]; then
@@ -234,8 +234,8 @@ for pkg in plugins/*/; do
     # DEP002: unused deps (may be false positives for optional features)
     # DEP003: transitive deps (expected in workspace setup)
     # Exclude tests/ and test/ directories (they use dev deps like pytest)
-    deptry_output=$(uv run deptry "$pkg" --ignore DEP002,DEP003 -ee ".*/tests/" -ee ".*/test/" 2>&1)
-    deptry_exit=$?
+    deptry_exit=0
+    deptry_output=$(uv run deptry "$pkg" --ignore DEP002,DEP003 -ee ".*/tests/" -ee ".*/test/" 2>&1) || deptry_exit=$?
     if [ $deptry_exit -ne 0 ]; then
       # Only report if there are actual errors (DEP001: missing deps)
       if echo "$deptry_output" | grep -qE "DEP001"; then

py/packages/genkit/pyproject.toml

@@ -54,6 +54,7 @@ dependencies = [
   "pillow>=12.1.1",
   "typing_extensions>=4.0",
   "strenum>=0.4.15; python_version < '3.11'",
+
   "dotpromptz>=0.1.5",
   "uvicorn>=0.34.0",
   "uvloop>=0.21.0; sys_platform != 'win32'",
@@ -75,7 +76,7 @@ license = "Apache-2.0"
 name = "genkit"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "0.5.1"
+version = "0.5.2"
 
 [project.optional-dependencies]
 flask                 = ["genkit-plugin-flask"]

py/packages/genkit/src/genkit/_ai/_aio.py

@@ -669,6 +669,8 @@ async def _run_server() -> None:
     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)
         for fmt in built_in_formats:
             self.define_format(fmt)
 

py/packages/genkit/src/genkit/_ai/_generate.py

@@ -16,6 +16,7 @@
 
 """Generate action."""
 
+import contextlib
 import copy
 import inspect
 import re
@@ -41,10 +42,12 @@
 from genkit._core._logger import get_logger
 from genkit._core._model import GenerateActionOptions
 from genkit._core._registry import Registry
+from genkit._core._tracing import run_in_new_span
 from genkit._core._typing import (
     FinishReason,
     Part,
     Role,
+    SpanMetadata,
     ToolDefinition,
     ToolRequest,
     ToolRequestPart,
@@ -111,6 +114,32 @@ async def generate_action(
     current_turn: int = 0,
     middleware: list[ModelMiddleware] | None = None,
     context: dict[str, Any] | None = None,
+) -> ModelResponse:
+    """Execute a generation request with tool calling and middleware support."""
+    span_name = 'generate'
+    with run_in_new_span(
+        SpanMetadata(name=span_name),
+        labels={'genkit:type': 'util'},
+    ) as span:
+        span.set_attribute('genkit:name', span_name)
+        with contextlib.suppress(Exception):
+            span.set_attribute('genkit:input', raw_request.model_dump_json(by_alias=True, exclude_none=True))
+        result = await _generate_action(
+            registry, raw_request, on_chunk, message_index, current_turn, middleware, context
+        )
+        with contextlib.suppress(Exception):
+            span.set_attribute('genkit:output', result.model_dump_json(by_alias=True, exclude_none=True))
+        return result
+
+
+async def _generate_action(
+    registry: Registry,
+    raw_request: GenerateActionOptions,
+    on_chunk: Callable[[ModelResponseChunk], None] | None = None,
+    message_index: int = 0,
+    current_turn: int = 0,
+    middleware: list[ModelMiddleware] | None = None,
+    context: dict[str, Any] | None = None,
 ) -> ModelResponse:
     """Execute a generation request with tool calling and middleware support."""
     model, tools, format_def = await resolve_parameters(registry, raw_request)
@@ -290,6 +319,24 @@ def message_parser(msg: Message) -> Any:  # noqa: ANN401
         # No message in response, return as-is
         return response
 
+    # Stamp output format metadata on message for Dev UI rendering.
+    # Mirrors JS GenerateResponse constructor which sets message.metadata.generate.output
+    # so the Dev UI knows to render the output as formatted JSON vs plain text.
+    out = raw_request.output
+    if out and (out.content_type or out.format):
+        generate_output: dict[str, str] = {}
+        if out.content_type:
+            generate_output['contentType'] = out.content_type
+        if out.format:
+            generate_output['format'] = out.format
+        existing_meta = dict(generated_msg.metadata) if isinstance(generated_msg.metadata, dict) else {}
+        generate_meta = existing_meta.get('generate')
+        if not isinstance(generate_meta, dict):
+            generate_meta = {}
+        generate_meta['output'] = generate_output
+        existing_meta['generate'] = generate_meta
+        generated_msg.metadata = existing_meta
+
     tool_requests = [x for x in generated_msg.content if x.root.tool_request]
 
     if raw_request.return_tool_requests or len(tool_requests) == 0:
@@ -344,7 +391,7 @@ def message_parser(msg: Message) -> Any:  # noqa: ANN401
         next_request = apply_transfer_preamble(next_request, transfer_preamble)
 
     # then recursively call for another loop
-    return await generate_action(
+    return await _generate_action(
         registry,
         raw_request=next_request,
         # middleware: middleware,

py/packages/genkit/src/genkit/_core/_action.py

@@ -36,6 +36,7 @@
 from genkit._core._compat import StrEnum
 from genkit._core._error import GenkitError
 from genkit._core._trace._path import build_path
+from genkit._core._trace._suppress import suppress_telemetry
 from genkit._core._tracing import tracer
 
 # =============================================================================
@@ -554,52 +555,60 @@ async def tracing_wrapper(
     ) -> ActionResponse[Any]:
         start_time = time.perf_counter()
 
-        with _save_parent_path():
-            with tracer.start_as_current_span(name) as span:
-                # Format trace_id and span_id as hex strings (OpenTelemetry standard format)
-                trace_id = format(span.get_span_context().trace_id, '032x')
-                span_id = format(span.get_span_context().span_id, '016x')
-                if on_trace_start:
-                    on_trace_start(trace_id, span_id)
-
-                # Set telemetry labels as direct span attributes (matches JS/Go behavior)
-                if telemetry_labels:
-                    for key, value in telemetry_labels.items():
-                        span.set_attribute(key, str(value))
-
-                _record_input_metadata(
-                    span=span,
-                    kind=kind,
-                    name=name,
-                    span_metadata=span_metadata,
-                    input=input,
-                )
-
-                try:
-                    match n_action_args:
-                        case 0:
-                            output = await fn()
-                        case 1:
-                            output = await fn(input)
-                        case 2:
-                            output = await fn(input, ctx)
-                        case _:
-                            raise ValueError('action fn must have 0-2 args')
-                except Exception as e:
-                    span.set_attribute('genkit:state', 'error')
-                    span.set_status(status=trace_api.StatusCode.ERROR, description=str(e))
-                    span.record_exception(e)
-                    # Re-raise existing GenkitError instances to avoid double-wrapping
-                    if isinstance(e, GenkitError):
-                        raise
-                    raise GenkitError(
-                        cause=e,
-                        message=f'Error while running action {name}',
-                        trace_id=trace_id,
-                    ) from e
-
-                output = _record_latency(output, start_time)
-                _record_output_metadata(span, output=output)
-                return ActionResponse(response=output, trace_id=trace_id, span_id=span_id)
+        suppress = str((telemetry_labels or {}).get('genkitx:ignore-trace', '')).lower() == 'true'
+        suppress_token = suppress_telemetry.set(True) if suppress else None
+        try:
+            with _save_parent_path():
+                with tracer.start_as_current_span(name) as span:
+                    # Format trace_id and span_id as hex strings (OpenTelemetry standard format)
+                    trace_id = format(span.get_span_context().trace_id, '032x')
+                    span_id = format(span.get_span_context().span_id, '016x')
+                    if on_trace_start:
+                        on_trace_start(trace_id, span_id)
+
+                    # Set telemetry labels as direct span attributes (matches JS/Go behavior)
+                    if telemetry_labels:
+                        for key, value in telemetry_labels.items():
+                            span.set_attribute(key, str(value))
+
+                    _record_input_metadata(
+                        span=span,
+                        kind=kind,
+                        name=name,
+                        span_metadata=span_metadata,
+                        input=input,
+                    )
+
+                    try:
+                        match n_action_args:
+                            case 0:
+                                output = await fn()
+                            case 1:
+                                output = await fn(input)
+                            case 2:
+                                output = await fn(input, ctx)
+                            case _:
+                                raise ValueError('action fn must have 0-2 args')
+                    except Exception as e:
+                        span.set_attribute('genkit:state', 'error')
+                        # Bundled Dev UI reads timeEvents.exception.attributes only; stash text for export synthesis.
+                        span.set_status(trace_api.StatusCode.ERROR, description=str(e))
+                        span.record_exception(e)
+                        if isinstance(e, GenkitError):
+                            span.set_attribute('genkit:error', e.original_message)
+                            raise
+                        span.set_attribute('genkit:error', str(e))
+                        raise GenkitError(
+                            cause=e,
+                            message=f'Error while running action {name}',
+                            trace_id=trace_id,
+                        ) from e
+
+                    output = _record_latency(output, start_time)
+                    _record_output_metadata(span, output=output)
+                    return ActionResponse(response=output, trace_id=trace_id, span_id=span_id)
+        finally:
+            if suppress_token is not None:
+                suppress_telemetry.reset(suppress_token)
 
     return tracing_wrapper

py/packages/genkit/src/genkit/_core/_compat.py

@@ -28,7 +28,10 @@
 # Note: override was added to typing in Python 3.12, but typing_extensions has it for all versions
 from typing import overload as overload  # noqa: E402
 
-from strenum import StrEnum as StrEnum  # noqa: E402
+if sys.version_info >= (3, 11):
+    from enum import StrEnum as StrEnum  # noqa: E402
+else:
+    from strenum import StrEnum as StrEnum  # noqa: E402
 from typing_extensions import override as override  # noqa: E402
 
 

py/packages/genkit/src/genkit/_core/_reflection.py

@@ -94,6 +94,7 @@ async def execute(self) -> None:
                 on_chunk=on_chunk,
                 context=self.payload.get('context', {}),
                 on_trace_start=self.on_trace_start,
+                telemetry_labels=self.payload.get('telemetryLabels'),
             )
             result = (
                 output.response.model_dump(by_alias=True, exclude_none=True)