@copilotkit/runtime 1.57.3 → 1.58.0-canary.thread-id-propagation

package/src/v2/runtime/handlers/intelligence/run.ts

@@ -1,351 +0,0 @@
-import type {
-  AbstractAgent,
-  BaseEvent,
-  Message,
-  RunAgentInput,
-} from "@ag-ui/client";
-import { EventType } from "@ag-ui/client";
-import type { CopilotIntelligenceRuntimeLike } from "../../core/runtime";
-import { generateThreadNameForNewThread } from "./thread-names";
-import { logger } from "@copilotkit/shared";
-import { telemetry } from "../../telemetry";
-import { resolveIntelligenceUser } from "../shared/resolve-intelligence-user";
-import { isHandlerResponse } from "../shared/json-response";
-import type { AgentRunnerRunRequest } from "../../runner/agent-runner";
-import type { Observable } from "rxjs";
-
-/**
- * Builds browser-facing realtime connection metadata owned by the runtime.
- */
-function buildRealtimeConnectionInfo(params: {
-  clientUrl: string;
-  threadId: string;
-}): { clientUrl: string; topic: string } {
-  return {
-    clientUrl: params.clientUrl,
-    topic: `thread:${params.threadId}`,
-  };
-}
-
-interface RunnerStartupBoundary {
-  events: Observable<BaseEvent>;
-  startup: Promise<void>;
-}
-
-interface RunnerWithStartupBoundary {
-  runWithStartupBoundary(request: AgentRunnerRunRequest): RunnerStartupBoundary;
-}
-
-function hasRunnerStartupBoundary(
-  runner: CopilotIntelligenceRuntimeLike["runner"],
-): runner is CopilotIntelligenceRuntimeLike["runner"] &
-  RunnerWithStartupBoundary {
-  const candidate = runner as { runWithStartupBoundary?: unknown };
-
-  return (
-    typeof candidate.runWithStartupBoundary === "function" &&
-    (Object.prototype.hasOwnProperty.call(runner, "runWithStartupBoundary") ||
-      Object.prototype.hasOwnProperty.call(runner, "threads"))
-  );
-}
-
-interface HandleIntelligenceRunParams {
-  runtime: CopilotIntelligenceRuntimeLike;
-  request: Request;
-  agentId: string;
-  agent: AbstractAgent;
-  input: RunAgentInput;
-}
-
-export async function handleIntelligenceRun({
-  runtime,
-  request,
-  agentId,
-  agent,
-  input,
-}: HandleIntelligenceRunParams): Promise<Response> {
-  if (!runtime.intelligence) {
-    return Response.json(
-      {
-        error: "Intelligence not configured",
-        message: "Intelligence mode requires a CopilotKitIntelligence",
-      },
-      { status: 500 },
-    );
-  }
-
-  const user = await resolveIntelligenceUser({ runtime, request });
-  if (isHandlerResponse(user)) {
-    return user;
-  }
-  const userId = user.id;
-
-  try {
-    const { thread, created } = await runtime.intelligence.getOrCreateThread({
-      threadId: input.threadId,
-      userId,
-      agentId,
-    });
-
-    if (created && runtime.generateThreadNames && !thread.name?.trim()) {
-      void generateThreadNameForNewThread({
-        runtime,
-        request,
-        agentId,
-        sourceInput: input,
-        thread,
-        userId,
-      }).catch((nameError) => {
-        logger.error("Failed to generate thread name:", nameError);
-      });
-    }
-  } catch (error) {
-    logger.error("Failed to get or create thread:", error);
-    return Response.json(
-      {
-        error: "Failed to initialize thread",
-      },
-      { status: 502 },
-    );
-  }
-
-  let canonicalThreadId = input.threadId;
-  let canonicalRunId = input.runId;
-  let joinToken: string | undefined;
-  try {
-    const lockResult = await runtime.intelligence.ɵacquireThreadLock({
-      threadId: input.threadId,
-      runId: input.runId,
-      userId,
-      agentId,
-      ...(runtime.lockKeyPrefix !== undefined
-        ? { lockKeyPrefix: runtime.lockKeyPrefix }
-        : {}),
-      ttlSeconds: runtime.lockTtlSeconds,
-    });
-    canonicalThreadId = lockResult.threadId;
-    canonicalRunId = lockResult.runId;
-    joinToken = lockResult.joinToken;
-  } catch (error) {
-    logger.error("Thread lock denied:", error);
-    return Response.json(
-      {
-        error: "Thread lock denied",
-      },
-      { status: 409 },
-    );
-  }
-
-  const cleanupLock = (reason: string): Promise<void> =>
-    runtime.intelligence
-      .ɵcleanupThreadLock({
-        threadId: canonicalThreadId || input.threadId,
-        runId: canonicalRunId || input.runId,
-      })
-      .catch((cleanupError) => {
-        logger.error(
-          { err: cleanupError, reason },
-          "Failed to cleanup thread lock",
-        );
-      });
-
-  if (!canonicalThreadId || !canonicalRunId || !joinToken) {
-    await cleanupLock("malformed-lock-response");
-    return Response.json(
-      {
-        error: "Run connection credentials not available",
-        message:
-          "Intelligence platform did not return canonical threadId, runId, and joinToken",
-      },
-      { status: 502 },
-    );
-  }
-
-  // When Intelligence has `mcpServer: true`, hand the agent the per-request
-  // bits it needs to attach the platform's MCP server: the resolved user-id,
-  // the project Bearer (`apiKey`), and the MCP URL. These ride through
-  // `forwardedProps.auth.copilotkitIntelligence` so the agent doesn't need a
-  // typed reference to the Intelligence client. `BuiltInAgent` reads the
-  // bag and builds a per-request MCP config with a closure-baked fetch;
-  // non-BuiltInAgent agents naturally ignore the key. The `auth` namespace
-  // is the convention for credentials that downstream redaction policies
-  // strip before durable storage and FE replay.
-  const upstreamAuth =
-    (input.forwardedProps as { auth?: Record<string, unknown> } | undefined)
-      ?.auth ?? {};
-  const copilotkitIntelligenceAuth =
-    runtime.intelligence.ɵisMcpServerEnabled?.()
-      ? {
-          copilotkitIntelligence: {
-            userId,
-            apiKey: runtime.intelligence.ɵgetApiKey(),
-            mcpUrl: `${runtime.intelligence.ɵgetApiUrl()}/mcp`,
-          },
-        }
-      : {};
-  const mergedAuth = { ...upstreamAuth, ...copilotkitIntelligenceAuth };
-
-  const canonicalInput: RunAgentInput = {
-    ...input,
-    threadId: canonicalThreadId,
-    runId: canonicalRunId,
-    forwardedProps: {
-      ...input.forwardedProps,
-      ...(Object.keys(mergedAuth).length > 0 ? { auth: mergedAuth } : {}),
-    },
-  };
-
-  let persistedInputMessages: Message[] | undefined;
-  if (Array.isArray(input.messages)) {
-    try {
-      const history = await runtime.intelligence.getThreadMessages({
-        threadId: canonicalThreadId,
-      });
-      const historicMessageIds = new Set(
-        history.messages.map((message) => message.id),
-      );
-      persistedInputMessages = input.messages.filter(
-        (message) => !historicMessageIds.has(message.id),
-      );
-    } catch (error) {
-      logger.error("Thread history lookup failed:", error);
-      await cleanupLock("thread-history-lookup-failed");
-      return Response.json(
-        {
-          error: "Thread history lookup failed",
-        },
-        { status: 502 },
-      );
-    }
-  }
-
-  telemetry.capture("oss.runtime.agent_execution_stream_started", {});
-
-  // Start heartbeat timer to renew the thread lock.
-  let heartbeatTimer: ReturnType<typeof setInterval> | undefined;
-  heartbeatTimer = setInterval(() => {
-    runtime.intelligence
-      .ɵrenewThreadLock({
-        threadId: canonicalThreadId,
-        runId: canonicalRunId,
-        ttlSeconds: runtime.lockTtlSeconds,
-        ...(runtime.lockKeyPrefix !== undefined
-          ? { lockKeyPrefix: runtime.lockKeyPrefix }
-          : {}),
-      })
-      .catch((err) => {
-        logger.error("Failed to renew thread lock:", err);
-        clearHeartbeat();
-        try {
-          agent.abortRun();
-        } catch (abortError) {
-          logger.error(
-            "Failed to abort agent after lock renewal failure:",
-            abortError,
-          );
-        }
-      });
-  }, runtime.lockHeartbeatIntervalSeconds * 1_000);
-
-  const clearHeartbeat = () => {
-    if (heartbeatTimer !== undefined) {
-      clearInterval(heartbeatTimer);
-      heartbeatTimer = undefined;
-    }
-  };
-
-  const runStarted = { current: false };
-  let immediateStartupErrorMessage: string | undefined;
-  let immediateStartupCleanup: Promise<void> | undefined;
-
-  const runRequest: AgentRunnerRunRequest = {
-    threadId: canonicalThreadId,
-    agent,
-    input: canonicalInput,
-    ...(persistedInputMessages !== undefined ? { persistedInputMessages } : {}),
-  };
-
-  try {
-    const runStart = hasRunnerStartupBoundary(runtime.runner)
-      ? runtime.runner.runWithStartupBoundary(runRequest)
-      : {
-          events: runtime.runner.run(runRequest),
-          startup: Promise.resolve(),
-        };
-
-    runStart.events.subscribe({
-      next: (event: BaseEvent) => {
-        if (event.type === EventType.RUN_STARTED) {
-          runStarted.current = true;
-        }
-        if (event.type === EventType.RUN_ERROR && !runStarted.current) {
-          clearHeartbeat();
-          immediateStartupErrorMessage =
-            "message" in event && typeof event.message === "string"
-              ? event.message
-              : "Runner failed before the run started";
-          immediateStartupCleanup = cleanupLock("runner-start-failed");
-        }
-      },
-      error: (error) => {
-        clearHeartbeat();
-        if (!runStarted.current) {
-          immediateStartupErrorMessage =
-            error instanceof Error ? error.message : String(error);
-          immediateStartupCleanup = cleanupLock("runner-start-error");
-        } else {
-          cleanupLock("runner-error");
-        }
-        telemetry.capture("oss.runtime.agent_execution_stream_errored", {
-          error: error instanceof Error ? error.message : String(error),
-        });
-        logger.error("Error running agent:", error);
-      },
-      complete: () => {
-        clearHeartbeat();
-        telemetry.capture("oss.runtime.agent_execution_stream_ended", {});
-      },
-    });
-
-    await runStart.startup;
-  } catch (error) {
-    clearHeartbeat();
-    await (immediateStartupCleanup ?? cleanupLock("runner-start-threw"));
-    logger.error("Error starting agent runner:", error);
-    return Response.json(
-      {
-        error: "Failed to start runner",
-        message: error instanceof Error ? error.message : String(error),
-      },
-      { status: 502 },
-    );
-  }
-
-  if (immediateStartupErrorMessage) {
-    await immediateStartupCleanup;
-    return Response.json(
-      {
-        error: "Failed to start runner",
-        message: immediateStartupErrorMessage,
-      },
-      { status: 502 },
-    );
-  }
-
-  // IntelligenceAgentRunner resolves this boundary after Phoenix channel join.
-  // Other runner implementations fall back to construction/subscription errors.
-  return Response.json(
-    {
-      threadId: canonicalThreadId,
-      runId: canonicalRunId,
-      joinToken,
-      realtime: buildRealtimeConnectionInfo({
-        clientUrl: runtime.intelligence.ɵgetClientWsUrl(),
-        threadId: canonicalThreadId,
-      }),
-    },
-    {
-      headers: { "Cache-Control": "no-cache" },
-    },
-  );
-}

package/src/v2/runtime/handlers/intelligence/thread-names.ts

@@ -1,246 +0,0 @@
-import { AbstractAgent, Message, RunAgentInput } from "@ag-ui/client";
-import { logger } from "@copilotkit/shared";
-import { randomUUID } from "node:crypto";
-import { CopilotIntelligenceRuntimeLike } from "../../core/runtime";
-import {
-  cloneAgentForRequest,
-  configureAgentForRequest,
-} from "../shared/agent-utils";
-import { ThreadSummary } from "../../intelligence-platform";
-import { isHandlerResponse } from "../shared/json-response";
-
-const THREAD_NAME_SYSTEM_PROMPT = [
-  "You generate short, specific conversation titles.",
-  'Return JSON only in this exact shape: {"title":"..."}',
-  "The title must be 2 to 5 words.",
-  "Use sentence case.",
-  "No quotes.",
-  "No emoji.",
-  "No markdown characters or formatting.",
-  "Do not use *, _, #, `, [, ], (, ), !, ~, >, or |.",
-  "No trailing punctuation.",
-  "No explanations.",
-  "Do not call tools.",
-].join("\n");
-
-const MAX_TITLE_LENGTH = 80;
-const MAX_TITLE_WORDS = 8;
-const MAX_TRANSCRIPT_MESSAGES = 8;
-const MAX_TITLE_GENERATION_ATTEMPTS = 3;
-const FALLBACK_THREAD_TITLE = "Untitled";
-
-interface GenerateThreadNameParams {
-  runtime: CopilotIntelligenceRuntimeLike;
-  request: Request;
-  agentId: string;
-  sourceInput: RunAgentInput;
-  thread: ThreadSummary;
-  userId: string;
-}
-
-export async function generateThreadNameForNewThread({
-  runtime,
-  request,
-  agentId,
-  sourceInput,
-  thread,
-  userId,
-}: GenerateThreadNameParams): Promise<void> {
-  if (!runtime.generateThreadNames || hasThreadName(thread.name)) {
-    return;
-  }
-
-  const prompt = buildThreadTitlePrompt(sourceInput.messages);
-  if (!prompt) {
-    return;
-  }
-
-  let generatedTitle: string | null = null;
-
-  for (let attempt = 1; attempt <= MAX_TITLE_GENERATION_ATTEMPTS; attempt++) {
-    try {
-      generatedTitle = await runTitleGenerationAttempt({
-        runtime,
-        request,
-        agentId,
-        threadId: thread.id,
-        prompt,
-      });
-
-      if (generatedTitle) {
-        break;
-      }
-
-      logger.warn(
-        { agentId, attempt, threadId: thread.id },
-        "Thread name generation returned an empty or invalid title",
-      );
-    } catch (error) {
-      logger.warn(
-        { err: error, agentId, attempt, threadId: thread.id },
-        "Thread name generation attempt failed",
-      );
-    }
-  }
-
-  await runtime.intelligence.updateThread({
-    threadId: thread.id,
-    userId,
-    agentId,
-    updates: { name: generatedTitle ?? FALLBACK_THREAD_TITLE },
-  });
-}
-
-async function runTitleGenerationAttempt(params: {
-  runtime: CopilotIntelligenceRuntimeLike;
-  request: Request;
-  agentId: string;
-  threadId: string;
-  prompt: string;
-}): Promise<string | null> {
-  const { runtime, request, agentId, threadId, prompt } = params;
-  const agent = await cloneAgentForRequest(runtime, agentId, request);
-  if (isHandlerResponse(agent)) {
-    logger.warn(
-      { agentId, threadId },
-      "Skipping thread naming because the agent could not be cloned",
-    );
-    return null;
-  }
-
-  configureAgentForRequest({
-    runtime,
-    request,
-    agentId,
-    agent,
-  });
-
-  const messages: Message[] = [
-    {
-      id: randomUUID(),
-      role: "system",
-      content: THREAD_NAME_SYSTEM_PROMPT,
-    },
-    {
-      id: randomUUID(),
-      role: "user",
-      content: prompt,
-    },
-  ];
-
-  agent.setMessages(messages);
-  agent.setState({});
-  agent.threadId = randomUUID();
-  const { newMessages } = await agent.runAgent({
-    messages,
-    state: {},
-    tools: [],
-    context: [],
-    forwardedProps: {},
-  });
-
-  const lastMessage = newMessages.at(-1);
-  const titleContent = lastMessage
-    ? stringifyMessageContent(lastMessage.content)
-    : "";
-
-  return normalizeGeneratedTitle(titleContent);
-}
-
-function buildThreadTitlePrompt(
-  messages: Message[] | undefined,
-): string | null {
-  const transcript = (messages ?? [])
-    .filter((message) =>
-      ["user", "assistant", "system", "developer"].includes(message.role),
-    )
-    .map((message) => {
-      const content = stringifyMessageContent(message.content);
-      if (!content) {
-        return null;
-      }
-
-      return `${message.role}: ${content}`;
-    })
-    .filter((message): message is string => !!message)
-    .slice(-MAX_TRANSCRIPT_MESSAGES);
-
-  if (transcript.length === 0) {
-    return null;
-  }
-
-  return [
-    "Generate a short title for this conversation.",
-    "Conversation:",
-    transcript.join("\n"),
-  ].join("\n\n");
-}
-
-function stringifyMessageContent(content: Message["content"]): string {
-  if (typeof content === "string") {
-    return content.trim();
-  }
-
-  if (content == null) {
-    return "";
-  }
-
-  try {
-    return JSON.stringify(content).trim();
-  } catch {
-    return "";
-  }
-}
-
-function normalizeGeneratedTitle(rawTitle: string): string | null {
-  let candidate = rawTitle.trim();
-  if (!candidate) {
-    return null;
-  }
-
-  candidate = candidate
-    .replace(/^```(?:json)?\s*/i, "")
-    .replace(/\s*```$/, "")
-    .trim();
-
-  try {
-    const parsed = JSON.parse(candidate) as { title?: unknown };
-    if (typeof parsed.title === "string") {
-      candidate = parsed.title;
-    }
-  } catch {
-    // Fall back to using the raw text.
-  }
-
-  candidate = candidate
-    .replace(/^["'`]+|["'`]+$/g, "")
-    .replace(/[*_#[\]()!~>|]+/g, "")
-    .replace(/[.!?,;:]+$/g, "")
-    .replace(/\s+/g, " ")
-    .trim();
-
-  if (!candidate) {
-    return null;
-  }
-
-  if (candidate.length > MAX_TITLE_LENGTH) {
-    candidate = candidate.slice(0, MAX_TITLE_LENGTH).trim();
-  }
-
-  if (candidate.split(/\s+/).length > MAX_TITLE_WORDS) {
-    return null;
-  }
-
-  return candidate;
-}
-
-function hasThreadName(name: string | null | undefined): boolean {
-  return typeof name === "string" && name.trim().length > 0;
-}
-
-/** @internal Exported for testing only. */
-export const ɵnormalizeGeneratedTitle = normalizeGeneratedTitle;
-/** @internal Exported for testing only. */
-export const ɵbuildThreadTitlePrompt = buildThreadTitlePrompt;
-/** @internal Exported for testing only. */
-export const ɵhasThreadName = hasThreadName;