feat(py): add agents conformance test harness and align wire initialization errors

[huangjeff5]

Summary

This pull request adds the Python test harness for the Agent Conformance Specification (tests/specs/agent.yaml) to ensure Python SDK behavior stays consistent with the cross-language wire standards (JS/Go).

Public API & Behavior Changes

• Agent Conformance Test Suite: Added agent_conformance_test.py executing the shared YAML spec suite against Python agent implementations.
• Wire Error Alignment: Aligned wire-facing agent initialization error formats with the conformance spec to return structured standard error responses when agent session setup fails.

Verification

• Ran pytest packages/genkit/tests/genkit/ai/agent_conformance_test.py (33 passed, 6 expected xfailed prior to behavior fixes in stacked PR B).

[gemini-code-assist]

Code Review

This pull request updates wire-facing error messages in the agent runtime to use camelCase field names and introduces a comprehensive agent conformance test runner that executes test cases from a shared YAML specification. The review feedback suggests several robust improvements: removing the now-unused seeded_init_fields helper function to eliminate dead code, safely handling empty YAML files to prevent potential crashes, wrapping the bidi stream interactions in a try-except-finally block to ensure proper connection cleanup and error capturing, and catching general exceptions in the test runner loop to provide better debugging context for all step failures.

[gemini-code-assist]

The helper function seeded_init_fields (defined at line 290) is no longer used anywhere in this file after removing its call here. It should be removed to keep the codebase clean and free of dead code.

[gemini-code-assist]

If the YAML file is empty, yaml.safe_load(f) will return None, which will cause an AttributeError when calling .get('tests'). Defaulting to an empty dictionary prevents this potential crash.

Suggested change

	with SPEC_PATH.open() as f:
	suite = yaml.safe_load(f)
	tests = suite.get('tests')
	with SPEC_PATH.open() as f:
	suite = yaml.safe_load(f) or {}
	tests = suite.get('tests')

[gemini-code-assist]

If an exception is thrown during stream_bidi or send (for example, due to an initialization error), it will not be caught by the expectError block because the try...except block is only entered during the receive phase. Additionally, if an exception occurs, the connection may not be closed properly. Wrapping the entire interaction in a try...except...finally block ensures that expected errors are caught correctly and connections are always closed.

    expect_err = resolved.get('expectError')
    thrown: BaseException | None = None
    conn = None
    try:
        conn = await agent.stream_bidi(AgentInit.model_validate(resolved.get('init') or {}))
        for inp in resolved.get('inputs') or []:
            await conn.send(AgentInput.model_validate(inp))
        await conn.close()
        if expect_err:
            async for _chunk in conn.receive():
                pass
            await conn.output()
    except (GenkitError, Exception) as e:
        if expect_err:
            thrown = e
        else:
            raise
    finally:
        if conn is not None:
            try:
                await conn.close()
            except Exception:
                pass

    if expect_err:
        assert thrown is not None, 'Expected the turn to throw an error, but it resolved successfully.'
        if 'status' in expect_err:
            status = getattr(thrown, 'status', None)
            assert status == expect_err['status'], (
                f'Expected thrown error.status {expect_err["status"]!r}, got {status!r} (message: {thrown})'
            )
        if 'message' in expect_err:
            assert expect_err['message'] in str(thrown), (
                f'Expected thrown error.message to contain {expect_err["message"]!r}, got: {thrown}'
            )
        return

[gemini-code-assist]

Catching only AssertionError means that any other unexpected runtime exceptions (such as KeyError, AttributeError, or GenkitError) raised during step execution will propagate directly without being wrapped with the step label. Catching Exception instead ensures that all failures are clearly attributed to the specific step that failed, which greatly simplifies debugging.

Suggested change

	except AssertionError as e:
	raise AssertionError(f'{label} in test {spec_test["name"]!r} failed: {e}') from e
	except Exception as e:
	raise AssertionError(f'{label} in test {spec_test["name"]!r} failed: {e}') from e