Update @github/copilot to 1.0.55-6 (#1471)

* Update @github/copilot to 1.0.55-6

- Updated nodejs and test harness dependencies
- Re-ran code generators
- Formatted generated code

* Update canvas API for canvas.action.invoke rename in 1.0.55-6

The 1.0.55-6 schema renamed the Canvas action invocation API:

- `CanvasInvokeActionRequest` -> `CanvasActionInvokeRequest`
- `CanvasInvokeActionResult` -> `CanvasActionInvokeResult`
- Host API `canvas.invokeAction(...)` -> `canvas.action.invoke(...)`
- Provider handler `invokeAction`/`invoke_action`/`InvokeAction` ->
  `invoke`/`Invoke`
- Wire methods `session.canvas.invokeAction` / `canvas.invokeAction` ->
  `session.canvas.action.invoke` / `canvas.action.invoke`
- Rust constants `SESSION_CANVAS_INVOKEACTION` / `CANVAS_INVOKEACTION` ->
  `SESSION_CANVAS_ACTION_INVOKE` / `CANVAS_ACTION_INVOKE`

The provider-side request type `CanvasProviderInvokeActionRequest` is
unchanged.

Update the host/provider adapters and tests in Node, Python, Go, .NET, and Rust
to follow the new nested `action` group and renamed handler method.

Also fix a Python codegen bug in `scripts/codegen/python.ts`:
`emitClientSessionApiRegistration` was iterating only top-level methods of
each handler group via `Object.entries(...).filter(isRpcMethod)`, so methods
nested under sub-groups (like `canvas.action.*`) were silently dropped from
the generated `CanvasHandler` Protocol and from
`register_client_session_api_handlers`. Use the existing recursive
`collectRpcMethods` helper and derive the handler method name from the last
segment of the RPC method path, matching how TS/C#/Go/Rust codegens already
flatten nested groups.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

* Wait for session.start in OnEvent tests

In CLI 1.0.55-6 the `session.start` event is dispatched via the asynchronous
`session.event` notification channel, so it may not be delivered to the
`onEvent`/`on_event` callback by the time `createSession` returns.

Update the Node and Python `should receive session events` tests to wait for
the event using `vi.waitFor`/`asyncio.Event`. The .NET and Go equivalents
already use async wait primitives (`TaskCompletionSource`/channel + timeout).

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Stephen Toub <stoub@microsoft.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

dotnet/src/Canvas.cs

@@ -130,7 +130,7 @@ internal partial class CanvasJsonContext : JsonSerializerContext;
 /// <remarks>
 /// A session installs a single <see cref="ICanvasHandler"/> via
 /// <c>SessionConfigBase.CanvasHandler</c>. The handler receives every
-/// inbound <c>canvas.open</c> / <c>canvas.close</c> / <c>canvas.invokeAction</c>
+/// inbound <c>canvas.open</c> / <c>canvas.close</c> / <c>canvas.action.invoke</c>
 /// JSON-RPC request the runtime issues for this session and decides — typically
 /// by inspecting <see cref="CanvasProviderOpenRequest.CanvasId"/> — which
 /// application-side canvas should handle the call.

dotnet/src/Generated/Rpc.cs

@@ -939,7 +939,7 @@ public async Task CloseAsync(CanvasProviderCloseRequest request, CancellationTok
             }
         }
 
-        public async Task<object> InvokeActionAsync(CanvasProviderInvokeActionRequest request, CancellationToken cancellationToken = default)
+        public async Task<object> InvokeAsync(CanvasProviderInvokeActionRequest request, CancellationToken cancellationToken = default)
         {
             try
             {

dotnet/src/Session.cs

@@ -2630,7 +2630,7 @@ protected SessionConfigBase(SessionConfigBase? other)
 
     /// <summary>
     /// Provider-side canvas lifecycle handler. The SDK routes inbound
-    /// <c>canvas.open</c> / <c>canvas.close</c> / <c>canvas.invokeAction</c>
+    /// <c>canvas.open</c> / <c>canvas.close</c> / <c>canvas.action.invoke</c>
     /// requests to this handler.
     /// </summary>
     [Experimental(Diagnostics.Experimental)]

dotnet/src/Types.cs

@@ -77,7 +77,7 @@ await session.Rpc.Canvas.OpenAsync(
             extensionId: canvas.ExtensionId,
             input: new Dictionary<string, object> { ["start"] = 41 });
 
-        var result = await session.Rpc.Canvas.InvokeActionAsync(
+        var result = await session.Rpc.Canvas.Action.InvokeAsync(
             instanceId: "counter-1",
             actionName: "increment",
             input: new Dictionary<string, object> { ["delta"] = 1 });

dotnet/test/E2E/CanvasE2ETests.cs

@@ -70,7 +70,7 @@ func CanvasErrorNoHandler() *CanvasError {
 //
 // A session installs a single CanvasHandler (via SessionConfig.CanvasHandler).
 // The handler receives every inbound `canvas.open` / `canvas.close` /
-// `canvas.invokeAction` JSON-RPC request the runtime issues for this session
+// `canvas.action.invoke` JSON-RPC request the runtime issues for this session
 // and decides — typically by inspecting CanvasProviderOpenRequest.CanvasID — which
 // application-side canvas should handle the call.
 //

go/canvas.go

@@ -156,7 +156,7 @@ func TestCanvasAdapter_DispatchesToHandler(t *testing.T) {
 		t.Fatalf("response URL not propagated: %+v", openResp)
 	}
 
-	actionResp, err := session.clientSessionApis.Canvas.InvokeAction(&rpc.CanvasProviderInvokeActionRequest{
+	actionResp, err := session.clientSessionApis.Canvas.Invoke(&rpc.CanvasProviderInvokeActionRequest{
 		SessionID:   "s1",
 		ExtensionID: "project:echo",
 		CanvasID:    "echo",
@@ -284,7 +284,7 @@ func TestCanvasRegisterClientSessionApiHandlers_RawJSONRoundTrip(t *testing.T) {
 		t.Fatalf("expected status=ready, got %v", decoded["status"])
 	}
 
-	actionRaw, err := requester.Request("canvas.invokeAction", map[string]any{
+	actionRaw, err := requester.Request("canvas.action.invoke", map[string]any{
 		"sessionId":   "s1",
 		"extensionId": "ext",
 		"canvasId":    "echo",

go/canvas_test.go

@@ -78,15 +78,15 @@ func TestCanvasE2E(t *testing.T) {
 		t.Fatalf("unexpected open calls: %+v", calls)
 	}
 
-	actionResult, err := session.RPC.Canvas.InvokeAction(t.Context(), &rpc.CanvasInvokeActionRequest{
+	actionResult, err := session.RPC.Canvas.Action().Invoke(t.Context(), &rpc.CanvasActionInvokeRequest{
 		InstanceID: "counter-1",
 		ActionName: "increment",
 		Input: map[string]any{
 			"amount": float64(2),
 		},
 	})
 	if err != nil {
-		t.Fatalf("Canvas.InvokeAction failed: %v", err)
+		t.Fatalf("Canvas.Action.Invoke failed: %v", err)
 	}
 	actionPayload, ok := actionResult.Result.(map[string]any)
 	if !ok || actionPayload["count"] != float64(5) {

go/internal/e2e/canvas_e2e_test.go

@@ -152,7 +152,7 @@ func (a *canvasClientSessionAdapter) Close(request *rpc.CanvasProviderCloseReque
 	return nil, nil
 }
 
-func (a *canvasClientSessionAdapter) InvokeAction(request *rpc.CanvasProviderInvokeActionRequest) (any, error) {
+func (a *canvasClientSessionAdapter) Invoke(request *rpc.CanvasProviderInvokeActionRequest) (any, error) {
 	if request == nil {
 		return nil, canvasJSONRPCError(NewCanvasError("canvas_handler_unset", "missing canvas action request"))
 	}