Forward internalCorrelationIds through session create/resume

nodejs/src/client.ts

@@ -1448,6 +1448,7 @@ export class CopilotClient {
                 remoteSession: config.remoteSession,
                 cloud: config.cloud,
                 expAssignments: config.expAssignments,
+                internalCorrelationIds: config.internalCorrelationIds,
             });
 
             const {
@@ -1646,6 +1647,7 @@ export class CopilotClient {
                 remoteSession: config.remoteSession,
                 openCanvases: config.openCanvases,
                 expAssignments: config.expAssignments,
+                internalCorrelationIds: config.internalCorrelationIds,
             });
 
             const { workspacePath, capabilities, openCanvases } = response as {

nodejs/src/types.ts

@@ -2165,6 +2165,27 @@ export interface SessionConfigBase {
      * @internal
      */
     expAssignments?: Record<string, unknown>;
+
+    /**
+     * First-party session correlation IDs forwarded verbatim to the runtime,
+     * which stamps them onto every telemetry event emitted for the session
+     * (each entry becomes an `sdk_correlation_<key>` property). Intended for
+     * trusted hosts (e.g. the Copilot cloud agent) that need to join the
+     * runtime's CLI telemetry stream back to their own job/repo identifiers;
+     * `session_id` alone only correlates within a single invocation.
+     *
+     * Keys must match `^[a-z0-9][a-z0-9_]{0,63}$`; the runtime drops malformed
+     * keys, empty/oversized values, and anything beyond its per-session limit
+     * (fail-open). Applies to both session creation and resume.
+     *
+     * Deliberately not part of the public, typed SDK surface: it is stripped
+     * from the published type declarations so third-party integrators do not
+     * see it, while first-party hosts can still set it (via a cast) and have it
+     * threaded through to the runtime.
+     *
+     * @internal
+     */
+    internalCorrelationIds?: Record<string, string>;
 }
 
 /**

nodejs/test/client.test.ts

@@ -251,6 +251,70 @@ describe("CopilotClient", () => {
         expect(resumePayload.expAssignments).toBeUndefined();
     });
 
+    it("forwards internalCorrelationIds in session.create and session.resume", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, params: any) => {
+                if (method === "session.create") return { sessionId: params.sessionId };
+                if (method === "session.resume") return { sessionId: params.sessionId };
+                throw new Error(`Unexpected method: ${method}`);
+            });
+
+        const correlationIds = {
+            cca_job_id: "job-123",
+            owner_id: "1",
+            repo_id: "2",
+        };
+
+        const session = await client.createSession({
+            onPermissionRequest: approveAll,
+            internalCorrelationIds: correlationIds,
+        });
+        await client.resumeSession(session.sessionId, {
+            onPermissionRequest: approveAll,
+            internalCorrelationIds: correlationIds,
+        });
+
+        const createPayload = spy.mock.calls.find(
+            ([method]) => method === "session.create"
+        )![1] as any;
+        const resumePayload = spy.mock.calls.find(
+            ([method]) => method === "session.resume"
+        )![1] as any;
+        expect(createPayload.internalCorrelationIds).toEqual(correlationIds);
+        expect(resumePayload.internalCorrelationIds).toEqual(correlationIds);
+    });
+
+    it("omits internalCorrelationIds from session.create and session.resume when unset", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, params: any) => {
+                if (method === "session.create") return { sessionId: params.sessionId };
+                if (method === "session.resume") return { sessionId: params.sessionId };
+                throw new Error(`Unexpected method: ${method}`);
+            });
+
+        const session = await client.createSession({ onPermissionRequest: approveAll });
+        await client.resumeSession(session.sessionId, { onPermissionRequest: approveAll });
+
+        const createPayload = spy.mock.calls.find(
+            ([method]) => method === "session.create"
+        )![1] as any;
+        const resumePayload = spy.mock.calls.find(
+            ([method]) => method === "session.resume"
+        )![1] as any;
+        expect(createPayload.internalCorrelationIds).toBeUndefined();
+        expect(resumePayload.internalCorrelationIds).toBeUndefined();
+    });
+
     it("forwards capi options in session.create and session.resume", async () => {
         const client = new CopilotClient();
         await client.start();