fix(runtime): Restore telemetry in v2 endpoints after refactor (CopilotKit#4266)

<!--
Thank you for sending the PR! We appreciate you spending the time to
work on these changes.

Help us understand your motivation by explaining why you decided to make
this change.


**Please PLEASE reach out to us first before starting any significant
work on new or existing features.**

By the time you've gotten here, you're looking at creating a pull
request so hopefully we're not too late.

We love community contributions! That said, we want to make sure we're
all on the same page before you start.
Investing a lot of time and effort just to find out it doesn't align
with the upstream project feels awful, and we don't want that to happen.
It also helps to make sure the work you're planning isn't already in
progress.

As described in our contributing guide, please file an issue first:
https://github.com/ag-ui-protocol/ag-ui/issues
Or, reach out to us on Discord: https://discord.com/invite/6dffbvGU3D


You can learn more about contributing to copilotkit here:
https://github.com/copilotkit/copilotkit/blob/master/CONTRIBUTING.md

Happy contributing!

-->

## What does this PR do?

(Describe the changes introduced in this PR)

This PR restores several telemetry tracking calls that were
inadvertently removed during the migration to have all endpoints use
'fetch'. It doesn't affect functionality, only metrics gathering.

Segment publishing is removed because nothing in v2 telemetry downstream
uses anything via Segment.

Test coverage is intentionally a bit elevated for this, as metrics
silently going away affects downstream flows and is effectively an
integration concern more than a unit test one.

## Related PRs and Issues

- (Direct link to related PR or issue, if relevant)

## Checklist

- [ ] I have read the [Contribution
Guide](https://github.com/copilotkit/copilotkit/blob/master/CONTRIBUTING.md)
- [ ] If the PR changes or adds functionality, I have updated the
relevant documentation

Author: BenTaylorDev

packages/runtime/src/v2/runtime/__tests__/express-single-telemetry.integration.test.ts

@@ -0,0 +1,65 @@
+/**
+ * Integration test: Express single-route adapter (deprecated convenience
+ * wrapper) + telemetry. This adapter delegates to createCopilotExpressHandler
+ * with mode: "single-route".
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+import { Observable, of } from "rxjs";
+
+import { telemetry } from "../telemetry";
+import { createCopilotEndpointSingleRouteExpress } from "../endpoints/express-single";
+import { CopilotRuntime } from "../core/runtime";
+
+function makeAgent(): AbstractAgent {
+  const a: unknown = { execute: async () => ({ events: [] }) };
+  (a as { clone: () => unknown }).clone = () => makeAgent();
+  return a as AbstractAgent;
+}
+
+function makeRuntime() {
+  const runner = {
+    run: () =>
+      new Observable((observer) => {
+        observer.next({});
+        observer.complete();
+        return () => undefined;
+      }),
+    connect: () => of({}),
+    stop: async () => true,
+  };
+  return new CopilotRuntime({
+    agents: { default: makeAgent() },
+    runner,
+  });
+}
+
+describe("Express single-route adapter — telemetry firing (integration)", () => {
+  let captureSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    captureSpy = vi.spyOn(telemetry, "capture").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    captureSpy.mockRestore();
+  });
+
+  it("fires instance_created on handler creation", async () => {
+    const runtime = makeRuntime();
+    createCopilotEndpointSingleRouteExpress({
+      runtime,
+      basePath: "/api/copilotkit",
+    });
+
+    await vi.waitFor(() => {
+      expect(captureSpy).toHaveBeenCalledWith(
+        "oss.runtime.instance_created",
+        expect.objectContaining({
+          agentsAmount: 1,
+          "cloud.api_key_provided": false,
+        }),
+      );
+    });
+  });
+});

packages/runtime/src/v2/runtime/__tests__/express-telemetry.integration.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Integration test: Express adapter + telemetry.
+ */
+import express from "express";
+import request from "supertest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+import { Observable, of } from "rxjs";
+
+import { telemetry } from "../telemetry";
+import { createCopilotExpressHandler } from "../endpoints/express";
+import { CopilotRuntime } from "../core/runtime";
+
+function makeAgent(): AbstractAgent {
+  const a: unknown = { execute: async () => ({ events: [] }) };
+  (a as { clone: () => unknown }).clone = () => makeAgent();
+  return a as AbstractAgent;
+}
+
+function makeRuntime() {
+  const runner = {
+    run: () =>
+      new Observable((observer) => {
+        observer.next({});
+        observer.complete();
+        return () => undefined;
+      }),
+    connect: () => of({}),
+    stop: async () => true,
+  };
+  return new CopilotRuntime({
+    agents: { default: makeAgent() },
+    runner,
+  });
+}
+
+describe("Express adapter — telemetry firing (integration)", () => {
+  let captureSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    captureSpy = vi.spyOn(telemetry, "capture").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    captureSpy.mockRestore();
+  });
+
+  it("fires instance_created on handler creation (multi-route)", async () => {
+    const runtime = makeRuntime();
+    createCopilotExpressHandler({ runtime, basePath: "/" });
+
+    await vi.waitFor(() => {
+      expect(captureSpy).toHaveBeenCalledWith(
+        "oss.runtime.instance_created",
+        expect.objectContaining({
+          agentsAmount: 1,
+          "cloud.api_key_provided": false,
+        }),
+      );
+    });
+  });
+
+  it("fires copilot_request_created when a real HTTP request hits the handler", async () => {
+    const runtime = makeRuntime();
+    const app = express();
+    app.use(createCopilotExpressHandler({ runtime, basePath: "/" }));
+
+    await request(app)
+      .post("/agent/default/run")
+      .set("Content-Type", "application/json")
+      .send({ messages: [], state: {}, threadId: "t1" });
+
+    expect(captureSpy).toHaveBeenCalledWith(
+      "oss.runtime.copilot_request_created",
+      expect.objectContaining({
+        requestType: "run",
+        "cloud.api_key_provided": false,
+      }),
+    );
+  });
+
+  it("includes cloud.public_api_key on request when header is present", async () => {
+    const runtime = makeRuntime();
+    const app = express();
+    app.use(createCopilotExpressHandler({ runtime, basePath: "/" }));
+
+    await request(app)
+      .post("/agent/default/run")
+      .set("Content-Type", "application/json")
+      .set("x-copilotcloud-public-api-key", "ck_pub_test_xyz")
+      .send({ messages: [], state: {}, threadId: "t1" });
+
+    expect(captureSpy).toHaveBeenCalledWith(
+      "oss.runtime.copilot_request_created",
+      expect.objectContaining({
+        "cloud.api_key_provided": true,
+        "cloud.public_api_key": "ck_pub_test_xyz",
+      }),
+    );
+  });
+});

packages/runtime/src/v2/runtime/__tests__/handle-connect.test.ts

@@ -475,4 +475,68 @@ describe("handleConnectAgent", () => {
       }
     });
   });
+
+  describe("telemetry", () => {
+    it("captures oss.runtime.copilot_request_created on every invocation", async () => {
+      const { telemetry } = await import("../telemetry");
+      const captureSpy = vi
+        .spyOn(telemetry, "capture")
+        .mockResolvedValue(undefined);
+
+      try {
+        const runtime = createMockRuntime({});
+        const request = new Request("https://example.com/agent/test/connect", {
+          method: "POST",
+        });
+        await handleConnectAgent({
+          runtime,
+          request,
+          agentId: "nonexistent-agent",
+        });
+
+        expect(captureSpy).toHaveBeenCalledWith(
+          "oss.runtime.copilot_request_created",
+          expect.objectContaining({
+            requestType: "connect",
+            "cloud.api_key_provided": false,
+          }),
+        );
+      } finally {
+        captureSpy.mockRestore();
+      }
+    });
+
+    it("includes cloud.public_api_key when x-copilotcloud-public-api-key header is set", async () => {
+      const { telemetry } = await import("../telemetry");
+      const captureSpy = vi
+        .spyOn(telemetry, "capture")
+        .mockResolvedValue(undefined);
+
+      try {
+        const runtime = createMockRuntime({});
+        const request = new Request("https://example.com/agent/test/connect", {
+          method: "POST",
+          headers: {
+            "x-copilotcloud-public-api-key": "ck_pub_connect_test",
+          },
+        });
+
+        await handleConnectAgent({
+          runtime,
+          request,
+          agentId: "nonexistent-agent",
+        });
+
+        expect(captureSpy).toHaveBeenCalledWith(
+          "oss.runtime.copilot_request_created",
+          expect.objectContaining({
+            "cloud.api_key_provided": true,
+            "cloud.public_api_key": "ck_pub_connect_test",
+          }),
+        );
+      } finally {
+        captureSpy.mockRestore();
+      }
+    });
+  });
 });

packages/runtime/src/v2/runtime/__tests__/handle-run.test.ts

@@ -938,4 +938,66 @@ describe("handleRunAgent", () => {
       }
     });
   });
+
+  describe("telemetry", () => {
+    it("captures oss.runtime.copilot_request_created on every invocation", async () => {
+      // Dynamic import so we spy on the module singleton the handler uses.
+      const { telemetry } = await import("../telemetry");
+      const captureSpy = vi
+        .spyOn(telemetry, "capture")
+        .mockResolvedValue(undefined);
+
+      try {
+        const runtime = createMockRuntime({});
+        await handleRunAgent({
+          runtime,
+          request: createMockRequest(),
+          agentId: "nonexistent-agent",
+        });
+
+        expect(captureSpy).toHaveBeenCalledWith(
+          "oss.runtime.copilot_request_created",
+          expect.objectContaining({
+            requestType: "run",
+            "cloud.api_key_provided": false,
+          }),
+        );
+      } finally {
+        captureSpy.mockRestore();
+      }
+    });
+
+    it("includes cloud.public_api_key when x-copilotcloud-public-api-key header is set", async () => {
+      const { telemetry } = await import("../telemetry");
+      const captureSpy = vi
+        .spyOn(telemetry, "capture")
+        .mockResolvedValue(undefined);
+
+      try {
+        const runtime = createMockRuntime({});
+        const request = new Request("https://example.com/agent/test/run", {
+          method: "POST",
+          headers: {
+            "x-copilotcloud-public-api-key": "ck_pub_run_test",
+          },
+        });
+
+        await handleRunAgent({
+          runtime,
+          request,
+          agentId: "nonexistent-agent",
+        });
+
+        expect(captureSpy).toHaveBeenCalledWith(
+          "oss.runtime.copilot_request_created",
+          expect.objectContaining({
+            "cloud.api_key_provided": true,
+            "cloud.public_api_key": "ck_pub_run_test",
+          }),
+        );
+      } finally {
+        captureSpy.mockRestore();
+      }
+    });
+  });
 });

packages/runtime/src/v2/runtime/__tests__/hono-single-telemetry.integration.test.ts

@@ -0,0 +1,46 @@
+/**
+ * Integration test: Hono single-route adapter (deprecated path) + telemetry.
+ *
+ * `createCopilotEndpointSingleRoute` is the legacy direct single-route entry
+ * point, superseded by `createCopilotHonoHandler({ mode: "single-route" })`
+ * but still exported.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { AbstractAgent } from "@ag-ui/client";
+
+import { telemetry } from "../telemetry";
+import { createCopilotEndpointSingleRoute } from "../endpoints/hono-single";
+import { CopilotRuntime } from "../core/runtime";
+
+function makeAgent(): AbstractAgent {
+  const a: unknown = { execute: async () => ({ events: [] }) };
+  (a as { clone: () => unknown }).clone = () => makeAgent();
+  return a as AbstractAgent;
+}
+
+describe("Hono single-route adapter — telemetry firing (integration)", () => {
+  let captureSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    captureSpy = vi.spyOn(telemetry, "capture").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    captureSpy.mockRestore();
+  });
+
+  it("fires instance_created on handler creation", async () => {
+    const runtime = new CopilotRuntime({ agents: { default: makeAgent() } });
+    createCopilotEndpointSingleRoute({ runtime, basePath: "/api/copilotkit" });
+
+    await vi.waitFor(() => {
+      expect(captureSpy).toHaveBeenCalledWith(
+        "oss.runtime.instance_created",
+        expect.objectContaining({
+          agentsAmount: 1,
+          "cloud.api_key_provided": false,
+        }),
+      );
+    });
+  });
+});