Add tests to verify forward compatibility for unknown session event types

[Copilot]

Add tests to verify forward compatibility for unknown session event types

Summary

The original issue (session.usage_info ValueError) was already fixed in the base code. The generated session_events.py already includes SESSION_USAGE_INFO in the enum and handles unknown event types by mapping them to SessionEventType.UNKNOWN for forward compatibility.

This PR adds tests to verify that the existing forward compatibility mechanism works correctly.

Changes

• Tests: Added test_event_forward_compatibility.py verifying:
  • session.usage_info is recognized in the enum
  • Unknown event types map to UNKNOWN enum value for forward compatibility
  • Real parsing errors (invalid UUID/timestamp) surface for visibility and are NOT suppressed
• Formatting: Applied ruff formatter to test file

Context

The generated code in session_events.py (lines 676-679) already contains proper error handling for unknown event types:

try:
    type = SessionEventType(obj.get("type"))
except ValueError:
    type = SessionEventType.UNKNOWN  # Forward compatibility

This approach correctly handles unknown event types for forward compatibility while allowing real parsing errors (like malformed UUIDs or timestamps) to surface for debugging visibility.

Testing

✅ All 4 tests pass:

• session.usage_info is recognized
• Unknown event types handled via UNKNOWN enum
• Malformed UUID raises ValueError (not suppressed)
• Malformed timestamp raises error (not suppressed)

Code Review

✅ Addressed all feedback from @SteveSandersonMS
✅ Applied Python formatter (ruff format)

The tests confirm that the SDK already handles the reported issue gracefully without requiring code changes.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>ValueError: 'session.usage_info' is not a valid SessionEventType</issue_title>
<issue_description>## Summary

The SDK throws a ValueError when the Copilot server sends session.usage_info events, because this event type is not defined in the SessionEventType enum. The error is printed to stderr as an unhandled exception in the asyncio event loop callback, which creates noisy output even though the request completes successfully.

Reproduction

import asyncio
from copilot import CopilotClient
from copilot.generated.session_events import SessionEventType

async def repro():
    client = CopilotClient()
    await client.start()
    
    try:
        session = await client.create_session({
            "model": "claude-sonnet-4.5",
            "streaming": False,
            "available_tools": [],
        })
        
        done = asyncio.Event()
        
        def handle_event(event):
            if event.type == SessionEventType.ASSISTANT_TURN_END:
                done.set()
        
        unsubscribe = session.on(handle_event)
        
        try:
            await session.send({"prompt": "Say hello"})
            await asyncio.wait_for(done.wait(), timeout=30)
        finally:
            unsubscribe()
            await session.destroy()
    finally:
        await client.stop()

# Run with GH_TOKEN set
asyncio.run(repro())

Output:

Exception in callback CopilotClient._connect_via_stdio.<locals>.handle_notification(...)
Traceback (most recent call last):
  ...
  File ".../copilot/generated/session_events.py", line 618, in from_dict
    type = SessionEventType(obj.get("type"))
ValueError: 'session.usage_info' is not a valid SessionEventType

Root Cause

In copilot/generated/session_events.py, the SessionEventType enum does not include session.usage_info:

class SessionEventType(Enum):
    ASSISTANT_MESSAGE = "session.assistant.message"
    ASSISTANT_MESSAGE_DELTA = "session.assistant.message.delta"
    ASSISTANT_TURN_END = "session.assistant.turn.end"
    # ... other types
    # Missing: SESSION_USAGE_INFO = "session.usage_info"

When SessionEvent.from_dict() tries to parse an event with type: "session.usage_info", it fails:

type = SessionEventType(obj.get("type"))  # ValueError!

Suggested Fix

Option 1: Add the missing event type to the enum:

class SessionEventType(Enum):
    # ... existing types ...
    SESSION_USAGE_INFO = "session.usage_info"

Option 2: Handle unknown event types gracefully in session_event_from_dict():

def session_event_from_dict(s: dict) -> Optional[SessionEvent]:
    try:
        return SessionEvent.from_dict(s)
    except ValueError:
        # Unknown event type - ignore gracefully
        return None

And update handle_notification() to handle None:

def handle_notification(method: str, params: dict):
    if method == "session.event":
        event = session_event_from_dict(event_dict)
        if event is not None:  # Skip unknown event types
            session._dispatch_event(event)

Environment

• OS: macOS 14.x
• Python: 3.11
• SDK version: Latest from pip

Impact

• Severity: Low (does not break functionality, but creates noisy stderr output)
• Workaround: Suppress the exception via custom asyncio exception handler
  </issue_description>

<agent_instructions>Let's make sure that we fail gracefully on unknown events across all client SDKs, not just the Python one</agent_instructions>

Comments on the Issue (you are @copilot in this section)

Custom agent used: debug-agentic-workflow
Debug and refine agentic workflows using gh-aw CLI tools - analyze logs, audit runs, and improve workflow performance

• Fixes ValueError: 'session.usage_info' is not a valid SessionEventType #30

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

[SteveSandersonMS]

@copilot Don't suppress parsing errors. Those should always surface for visiblity. The only forward compatibility we want here is handling previously-unknown event types, which might already be covered in latest main so rebase and check if the change is still needed. Don't try/catch parsing errors in general.

[Copilot]

@copilot Don't suppress parsing errors. Those should always surface for visiblity. The only forward compatibility we want here is handling previously-unknown event types, which might already be covere...

You're absolutely right. The original issue was already fixed in the base code - session.usage_info is in the enum and unknown event types are handled gracefully via the UNKNOWN enum value in the generated code.

I've reverted the broad try-catch blocks that were suppressing all parsing errors. The generated code at lines 676-679 already handles unknown event types correctly without hiding real errors.

Changes in commit 39d47dc:

• Reverted client.py to original state (no error suppression)
• Added test verifying forward compatibility works AND parsing errors surface
• All tests pass ✅

The SDK now properly:

• Recognizes session.usage_info
• Maps unknown types to UNKNOWN enum
• Surfaces real parsing errors for visibility

[SteveSandersonMS]

@copilot Run the Python formatter

[Copilot]

Pull request overview

This PR adds comprehensive unit tests to verify that the Python SDK's existing forward compatibility mechanism for session events works correctly. The generated code already includes proper handling for unknown event types by mapping them to SessionEventType.UNKNOWN, and this PR validates that behavior.

Changes:

• Added test_event_forward_compatibility.py with 4 test cases verifying enum recognition, unknown event handling, and error visibility
• Tests confirm that malformed data raises appropriate errors and unknown event types map to UNKNOWN enum value
• No code changes required as forward compatibility was already implemented in the generated session_events.py

Comments suppressed due to low confidence (1)

python/test_event_forward_compatibility.py:14

• Missing import for dateutil.parser.ParserError. The from_datetime function in session_events.py uses dateutil.parser.parse() which raises ParserError for invalid timestamps. Add: from dateutil.parser import ParserError

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The expected exceptions should include ParserError from dateutil.parser, as the from_datetime function uses dateutil.parser.parse() which raises ParserError for invalid timestamps, not just ValueError or TypeError. Consider adding: with pytest.raises((ValueError, TypeError, dateutil.parser.ParserError))

This issue also appears in the following locations of the same file:

• line 14

[Copilot]

@copilot Run the Python formatter

Done. Applied ruff formatter in commit dc88aef.