import { CopilotRuntime } from "@copilotkit/runtime";

// SSE mode (default) -- in-memory thread state
const runtime = new CopilotRuntime({
  agents: { default: myAgent },
  runner: new InMemoryAgentRunner(),  // optional, this is the default
});

// Intelligence mode -- durable threads via CopilotKit Intelligence Platform
const runtime = new CopilotRuntime({
  agents: { default: myAgent },
  intelligence: new CopilotKitIntelligence({ ... }),
  identifyUser: (request) => ({ id: "user-123" }),
});

import { BuiltInAgent, defineTool } from "@copilotkit/agent";
import { z } from "zod";

const agent = new BuiltInAgent({
  model: "openai/gpt-4o", // "provider/model" string or LanguageModel instance
  prompt: "You are helpful.", // System prompt
  temperature: 0.7, // Sampling temperature
  maxSteps: 5, // Max tool-calling iterations (default: 1)
  tools: [
    // Server-side tools
    defineTool({
      name: "getWeather",
      description: "Get current weather for a city",
      parameters: z.object({
        city: z.string(),
      }),
      execute: async ({ city }) => {
        return { temp: 72, condition: "sunny" };
      },
    }),
  ],
});

abstract class AgentRunner {
  abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
  abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
  abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
  abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
}

import { CopilotRuntime, createCopilotEndpoint } from "@copilotkit/runtime";

const app = createCopilotEndpoint({
  runtime,
  basePath: "/api/copilotkit",
  cors: {
    // optional CORS config
    origin: "https://myapp.com", // string, string[], or function
    credentials: true, // enable for HTTP-only cookies
  },
});

import { createCopilotEndpointExpress } from "@copilotkit/runtime/express";

const router = createCopilotEndpointExpress({
  runtime,
  basePath: "/api/copilotkit",
});
app.use(router);

import {
  CopilotRuntime,
  createCopilotEndpointSingleRoute,
} from "@copilotkit/runtime";

const app = createCopilotEndpointSingleRoute({
  runtime,
  basePath: "/api/copilotkit",
});

import { createCopilotEndpointSingleRouteExpress } from "@copilotkit/runtime/express";

const router = createCopilotEndpointSingleRouteExpress({
  runtime,
  basePath: "/", // relative to where it's mounted
});
app.use("/api/copilotkit", router);

const runtime = new CopilotRuntime({
  agents: { default: agent },
  beforeRequestMiddleware: async ({ request, path }) => {
    // Validate auth, return modified request or void
    const token = request.headers.get("Authorization");
    if (!token) {
      throw new Response(JSON.stringify({ error: "Unauthorized" }), {
        status: 401,
      });
    }
    return request; // or return void to pass through unchanged
  },
  afterRequestMiddleware: async ({ response, path, messages, threadId }) => {
    // Log, audit, etc. Non-blocking (errors are caught and logged).
    console.log(`Completed request to ${path}, thread: ${threadId}`);
  },
});

createCopilotEndpoint({
  runtime,
  basePath: "/api/copilotkit",
  cors: {
    origin: "https://myapp.com",
    credentials: true,
  },
});

<CopilotKitProvider runtimeUrl="/api/copilotkit" credentials="include">