Add experimental GitHub telemetry redirection across all SDKs

[MackinnonBuck]

Why

The runtime can now forward per-session GitHub (hydro) telemetry to opted-in host connections via a new JSON-RPC server to client notification, gitHubTelemetry.event. This PR implements the consumer side of that contract in every language SDK so hosts can receive those events. The feature is internal and experimental, so it is intentionally kept low-profile and undocumented for public consumers.

What

For each SDK this adds an onGitHubTelemetry callback (per-language naming) and a hand-written opt-in: when a host registers a handler, the client sets enableGitHubTelemetryRedirection on every session it creates or resumes, and dispatches each gitHubTelemetry.event notification to the callback.

Key pieces:

• Generated types. Regenerated the RPC types in all languages from the new schema (GitHubTelemetryNotification, GitHubTelemetryEvent, GitHubTelemetryClientInfo, and the gitHubTelemetry.event clientGlobal method). The shared codegen change adds a notification flag to RpcMethod so generators emit notification-style dispatch (no JSON-RPC reply) for void clientGlobal methods.
• Hand-written glue. Each SDK surfaces the callback using its existing llmInference / notification idiom and wires the opt-in flag into the create/resume requests. We deliberately reuse the generated RPC types directly rather than introducing friendly wrapper types.
• Tests. Real-wire tests per language verify the handler fires with a correctly typed payload and that the opt-in flag is present when a handler is registered and omitted otherwise.

Notable decisions

• One commit per language (plus a small shared codegen-infra commit for utils.ts). This makes the feature trivially revertible language-by-language: reverting a single language's commit removes its support without touching the others. The shared utils.ts change is purely additive (an optional notification? field), so it stays put and never breaks the remaining generators.
• "Unadvertised" where the language supports it. C# uses [EditorBrowsable(EditorBrowsableState.Never)] and Rust uses #[doc(hidden)]. Languages without a true "exported but hidden" mechanism stay visible + experimental with minimal docs.
• No public docs. The types are internal/experimental by design.

Review notes

This is the SDK side of a contract whose runtime counterpart is merged-in-progress on the @github/copilot (copilot-agent-runtime) side. The schema is the source of truth; generated files were produced by codegen, not hand-edited.

[Copilot]

Pull request overview

Implements an experimental cross-SDK surface for receiving per-session GitHub (hydro) telemetry forwarded by the runtime via a new JSON-RPC client-global notification (gitHubTelemetry.event). The PR extends shared codegen to understand notification-style RPC methods and wires opt-in + dispatch behavior across TypeScript/Node, Python, Go, Rust, Java, and .NET, with tests validating forwarding and handler invocation.

Changes:

• Added schema override + shared codegen support for notification-style client-global methods (RpcMethod.notification) and for injecting additive API schema entries during schema loading.
• Implemented per-SDK “on GitHub telemetry” callback wiring and session create/resume opt-in (enableGitHubTelemetryForwarding) when a handler is registered.
• Added/updated unit/integration tests across SDKs to validate handler dispatch and the opt-in flag behavior.

Show a summary per file

File	Description
scripts/codegen/utils.ts	Loads API schema and applies additive overrides; adds notification?: boolean to RpcMethod.
scripts/codegen/typescript.ts	Emits onNotification wiring for notification-style client-global methods.
scripts/codegen/schema-overrides/api-additions.schema.json	Adds gitHubTelemetry.event + telemetry types via additive schema override (marked notification + experimental).
scripts/codegen/rust.ts	Switches schema loading to shared loadSchemaJson (enabling overrides).
scripts/codegen/python.ts	Emits notification-handler wiring for notification-style client-global methods.
scripts/codegen/go.ts	Adjusts Go codegen for client-global void/notification methods and emits notification-safe handler signatures.
rust/src/github_telemetry.rs	New Rust module re-exporting telemetry types + callback alias (doc-hidden).
rust/src/lib.rs	Adds client option + plumbing for telemetry callback; adds test constructor helper.
rust/src/router.rs	Routes gitHubTelemetry.event client-global notifications to callback (if set).
rust/src/session.rs	Sets enableGitHubTelemetryForwarding on create/resume when callback registered.
rust/src/types.rs	Initializes new wire fields to None in config→wire conversion.
rust/src/wire.rs	Adds enableGitHubTelemetryForwarding wire field to create/resume request DTOs.
rust/src/generated/api_types.rs	Generated telemetry DTOs.
rust/tests/session_test.rs	Rust integration tests validating opt-in flag and callback dispatch.
python/copilot/_jsonrpc.py	Adds method-specific notification handler registry + dispatch path.
python/copilot/generated/rpc.py	Generated telemetry DTOs + client-global notification handler registration for gitHubTelemetry.event.
python/copilot/client.py	Adds on_github_telemetry option, opt-in flag wiring, and registers client-global handlers.
python/copilot/init.py	Re-exports telemetry DTOs at package level.
python/test_client.py	Python unit tests for opt-in flag and notification dispatch path.
nodejs/src/generated/rpc.ts	Generated telemetry DTOs + onNotification registration for gitHubTelemetry.event.
nodejs/src/types.ts	Exposes telemetry DTOs and adds onGitHubTelemetry option type.
nodejs/src/index.ts	Re-exports telemetry DTO types from the public entrypoint.
nodejs/src/client.ts	Wires onGitHubTelemetry, registers client-global handlers, and sets session opt-in flag.
nodejs/test/client.test.ts	Node tests for opt-in flag behavior and notification dispatch.
go/rpc/zrpc.go	Generated Go telemetry DTOs + client-global handler interface + registration.
go/types.go	Adds OnGitHubTelemetry client option and wire fields on create/resume DTOs.
go/client.go	Sets opt-in flag on create/resume and registers telemetry callback adapter.
go/client_test.go	Go tests validating opt-in flag serialization and notification routing to callback.
java/src/main/java/com/github/copilot/GitHubTelemetryAdapter.java	Java adapter bridging gitHubTelemetry.event into consumer callback.
java/src/main/java/com/github/copilot/CopilotClient.java	Registers telemetry adapter on connect; sets opt-in flag on create/resume when handler set.
java/src/main/java/com/github/copilot/rpc/CopilotClientOptions.java	Adds experimental setOnGitHubTelemetry option and clones it.
java/src/main/java/com/github/copilot/rpc/CreateSessionRequest.java	Adds enableGitHubTelemetryForwarding field + accessors.
java/src/main/java/com/github/copilot/rpc/ResumeSessionRequest.java	Adds enableGitHubTelemetryForwarding field + accessors.
java/src/main/java/com/github/copilot/rpc/GitHubTelemetryClientInfo.java	Java telemetry DTO.
java/src/main/java/com/github/copilot/rpc/GitHubTelemetryEvent.java	Java telemetry DTO.
java/src/main/java/com/github/copilot/rpc/GitHubTelemetryNotification.java	Java telemetry DTO.
java/src/test/java/com/github/copilot/GitHubTelemetryTest.java	Java tests verifying adapter dispatch and opt-in flag on create/resume.
dotnet/src/Generated/Rpc.cs	Generated telemetry DTOs + client-global handler interface and registration.
dotnet/src/Types.cs	Adds hidden experimental OnGitHubTelemetry option to CopilotClientOptions.
dotnet/src/Client.cs	Sets opt-in flag when handler present; registers telemetry adapter in client-global handlers.
dotnet/test/Unit/GitHubTelemetryTests.cs	.NET unit tests validating opt-in behavior and notification forwarding.

Review details

Files not reviewed (1)

• go/rpc/zrpc.go: Generated file

• Files reviewed: 36/41 changed files
• Comments generated: 6
• Review effort level: Low

[github-actions]

Cross-SDK Consistency Review ✅

I reviewed this PR for cross-language consistency across all six SDK implementations.

Feature Coverage

All six SDKs implement the experimental onGitHubTelemetry callback:

SDK	Option Name	Callback Type
Node.js	onGitHubTelemetry	(n: GitHubTelemetryNotification) => void | Promise<void>
Python	on_github_telemetry	Callable[[GitHubTelemetryNotification], None]
Go	OnGitHubTelemetry	func(notification *rpc.GitHubTelemetryNotification)
.NET	OnGitHubTelemetry	Action<Rpc.GitHubTelemetryNotification>?
Java	setOnGitHubTelemetry / getOnGitHubTelemetry	Consumer<GitHubTelemetryNotification>
Rust	on_github_telemetry + with_on_github_telemetry()	Arc<dyn Fn(GitHubTelemetryNotification) + Send + Sync>

Consistency Checklist

• ✅ All 6 SDKs have the feature — no language is missing
• ✅ Wire flag — enableGitHubTelemetryForwarding: true is set on both CreateSession and ResumeSession in every SDK
• ✅ Adapter pattern — all SDKs bridge from the generated RPC handler protocol to the user-facing callback
• ✅ Naming — follows language conventions (camelCase / snake_case / PascalCase) with the same semantic
• ✅ Tests — every language has a test covering handler registration and payload dispatch
• ✅ Experimental hiding — .NET uses [EditorBrowsable(Never)], Rust uses #[doc(hidden)], others keep it low-profile as noted in the PR description
• ✅ Generated types — GitHubTelemetryNotification, GitHubTelemetryEvent, and GitHubTelemetryClientInfo are codegen'd in all SDKs

Language-Idiomatic Differences (expected, not inconsistencies)

• Node.js accepts Promise<void> from the callback (async-friendly), while all other SDKs accept only synchronous callbacks — consistent with each language's idioms
• Go uses recover() to swallow handler panics; Node.js uses try/catch; Java wraps in try/catch with logging; Python error handling flows through _dispatch_notification — all effectively prevent callback errors from breaking the RPC loop
• Rust wraps the callback in Arc for thread-safety — idiomatic for Rust's ownership model

No cross-SDK inconsistencies found. This is a well-coordinated multi-language feature addition.

Generated by SDK Consistency Review Agent for issue #1835 · sonnet46 2.5M · ◷