@cursor/july 0.1.30 → 0.1.32

package/src/internal/host-files.ts

@@ -0,0 +1,372 @@
+/**
+ * Author-facing durable file storage for {@link HostContext.files}.
+ *
+ * On Cursor-managed hosting the bytes live in the deployment's durable
+ * store; otherwise they land under `--state-root/files` on local disk, which
+ * is what makes `host.files` work self-hosted with no storage service at all.
+ *
+ * Everything that decides *which* bytes an author may reach lives here rather
+ * than in the sink: scope selection, path validation, and key minting through
+ * {@link fileKeys}. A sink only ever sees a fully-qualified opaque key, so an
+ * authored sink — including one a customer wrote against their own Dropbox —
+ * cannot be steered into another deployment's or another session's files.
+ */
+
+import { join, normalize, sep } from "node:path";
+import {
+  FilePathRejectedError,
+  FileSessionRequiredError,
+  type FileSink,
+  type FileSinkEntry,
+  FileTooLargeError,
+  fileKeys,
+} from "../files.js";
+import {
+  cursorHostedFiles,
+  isCursorHostedFilesAvailable,
+} from "../files-backends/cursor-hosted.js";
+import { localFiles } from "../files-backends/local-fs.js";
+import type {
+  HostFileEntry,
+  HostFileStat,
+  HostFilesApi,
+  HostFilesCapabilities,
+  HostFilesScope,
+} from "../types.js";
+
+export interface CreateHostFilesApiOptions {
+  agentName: string;
+  /** Local disk root for the default sink. Required unless `sink` is supplied. */
+  stateRoot?: string;
+  /** Explicit sink override (tests). Omitted → hosted store or local disk. */
+  sink?: FileSink;
+  /** Session bound for `scope: "session"` calls; prefer {@link HostFilesApi.forSession}. */
+  sessionId?: string;
+  /** Environment consulted when choosing the default sink (tests). */
+  env?: NodeJS.ProcessEnv;
+}
+
+/** Build the host file API for one agent process. */
+export function createHostFilesApi(
+  options: CreateHostFilesApiOptions
+): HostFilesApi {
+  const sink = options.sink ?? createDefaultSink(options);
+  return createBoundHostFilesApi({
+    agentName: options.agentName,
+    sink,
+    ...(options.sessionId === undefined
+      ? {}
+      : { sessionId: options.sessionId }),
+  });
+}
+
+/**
+ * Pick the default sink.
+ *
+ * On Cursor-managed hosting the durable store is the only correct answer —
+ * falling back to pod-local disk there would accept writes that vanish with
+ * the pod, which is the failure this surface exists to remove. Off hosting,
+ * local disk keeps `serve --dev`, replay, fixtures, and evals working with no
+ * storage service. This is the gate all six hosted agents write by hand in
+ * their `agent/storage.ts`; resolving it here means authors do not repeat it.
+ */
+function createDefaultSink(options: CreateHostFilesApiOptions): FileSink {
+  if (isCursorHostedFilesAvailable(options.env ?? process.env)) {
+    return cursorHostedFiles();
+  }
+  if (options.stateRoot === undefined) {
+    throw new Error(
+      "createHostFilesApi needs a stateRoot for the default local-disk sink, or an explicit sink"
+    );
+  }
+  return localFiles({
+    filesRoot: join(options.stateRoot, "files"),
+    stripKeyPrefix: localKeyPrefix(options.agentName),
+  });
+}
+
+/** On-disk layout drops the framework key prefix so paths stay navigable. */
+function localKeyPrefix(agentName: string): string {
+  return fileKeys.deploymentPrefix(agentName).replace(/deployment\/$/, "");
+}
+
+interface BoundState {
+  agentName: string;
+  sink: FileSink;
+  sessionId?: string;
+}
+
+function createBoundHostFilesApi(state: BoundState): HostFilesApi {
+  const sinkCaps = state.sink.capabilities ?? {};
+  const capabilities: HostFilesCapabilities = {
+    conflictDetection: sinkCaps.etags === true,
+    materialized:
+      sinkCaps.materialized === true &&
+      typeof state.sink.materializedPath === "function",
+    ...(sinkCaps.maxBytes === undefined ? {} : { maxBytes: sinkCaps.maxBytes }),
+  };
+
+  const keyFor = (path: string, scope: HostFilesScope | undefined): string =>
+    mintKey(state, path, scope);
+
+  const api: HostFilesApi = {
+    capabilities,
+
+    forSession(sessionId: string): HostFilesApi {
+      const trimmed = sessionId.trim();
+      if (trimmed === "") {
+        throw new FileSessionRequiredError(
+          "host.files.forSession requires a non-empty session id"
+        );
+      }
+      return createBoundHostFilesApi({ ...state, sessionId: trimmed });
+    },
+
+    async read(path, options): Promise<string | undefined> {
+      const bytes = await api.readBytes(path, options);
+      return bytes === undefined
+        ? undefined
+        : Buffer.from(bytes).toString(options?.encoding ?? "utf8");
+    },
+
+    async readBytes(path, options): Promise<Uint8Array | undefined> {
+      const found = await state.sink.get(keyFor(path, options?.scope));
+      if (found === undefined) {
+        return undefined;
+      }
+      return found instanceof Uint8Array ? found : found.body;
+    },
+
+    async write(path, data, options): Promise<void> {
+      const key = keyFor(path, options?.scope);
+      const body =
+        typeof data === "string"
+          ? Buffer.from(data, "utf8")
+          : Buffer.from(data);
+      const maxBytes = capabilities.maxBytes;
+      if (maxBytes !== undefined && body.byteLength > maxBytes) {
+        throw new FileTooLargeError(key, body.byteLength, maxBytes);
+      }
+      await state.sink.put(
+        key,
+        body,
+        options?.ifMatch === undefined
+          ? undefined
+          : { ifMatch: options.ifMatch }
+      );
+    },
+
+    async remove(path, options): Promise<void> {
+      await state.sink.delete(keyFor(path, options?.scope));
+    },
+
+    async exists(path, options): Promise<boolean> {
+      return (await api.stat(path, options)) !== undefined;
+    },
+
+    async stat(path, options): Promise<HostFileStat | undefined> {
+      const key = keyFor(path, options?.scope);
+      const entry = await statKey(state.sink, key);
+      if (entry === undefined) {
+        return undefined;
+      }
+      return {
+        size: entry.size,
+        ...(entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs }),
+        ...(entry.etag === undefined ? {} : { etag: entry.etag }),
+      };
+    },
+
+    async list(prefix, options): Promise<HostFileEntry[]> {
+      const scopePrefix = mintPrefix(state, options?.scope);
+      const rel = prefix === undefined ? "" : normalizeRelPath(prefix, true);
+      const entries = await state.sink.list(`${scopePrefix}${rel}`);
+      const out: HostFileEntry[] = [];
+      for (const entry of entries) {
+        if (!entry.key.startsWith(scopePrefix)) {
+          // A sink that widens the prefix must not leak keys from another
+          // scope through a listing.
+          continue;
+        }
+        out.push({
+          path: entry.key.slice(scopePrefix.length),
+          size: entry.size,
+          ...(entry.mtimeMs === undefined ? {} : { mtimeMs: entry.mtimeMs }),
+        });
+      }
+      return out.sort((a, b) =>
+        a.path < b.path ? -1 : a.path > b.path ? 1 : 0
+      );
+    },
+
+    materializedPath(path, options): string | undefined {
+      if (!capabilities.materialized) {
+        return undefined;
+      }
+      return state.sink.materializedPath?.(keyFor(path, options?.scope));
+    },
+  };
+  return api;
+}
+
+async function statKey(
+  sink: FileSink,
+  key: string
+): Promise<FileSinkEntry | undefined> {
+  if (typeof sink.stat === "function") {
+    return await sink.stat(key);
+  }
+  const entries = await sink.list(key);
+  return entries.find((entry) => entry.key === key);
+}
+
+// ============================================================================
+// Key minting
+// ============================================================================
+
+function mintKey(
+  state: BoundState,
+  path: string,
+  scope: HostFilesScope | undefined
+): string {
+  const rel = normalizeRelPath(path, false);
+  const resolved = resolveScope(state, scope);
+  if (resolved.kind === "session") {
+    return fileKeys.session(state.agentName, resolved.sessionId, rel);
+  }
+  return resolved.partition === undefined
+    ? fileKeys.deployment(state.agentName, rel)
+    : fileKeys.deploymentPartition(state.agentName, resolved.partition, rel);
+}
+
+function mintPrefix(
+  state: BoundState,
+  scope: HostFilesScope | undefined
+): string {
+  const resolved = resolveScope(state, scope);
+  if (resolved.kind === "session") {
+    return fileKeys.sessionPrefix(state.agentName, resolved.sessionId);
+  }
+  const base = fileKeys.deploymentPrefix(state.agentName);
+  return resolved.partition === undefined
+    ? base
+    : `${base}${resolved.partition}/`;
+}
+
+type ResolvedScope =
+  | { kind: "session"; sessionId: string }
+  | { kind: "deployment"; partition?: string };
+
+function resolveScope(
+  state: BoundState,
+  scope: HostFilesScope | undefined
+): ResolvedScope {
+  if (scope === "deployment") {
+    return { kind: "deployment" };
+  }
+  if (scope !== undefined && typeof scope === "object") {
+    if (scope.kind === "deployment") {
+      return scope.partition === undefined
+        ? { kind: "deployment" }
+        : { kind: "deployment", partition: segment(scope.partition) };
+    }
+    const explicit = scope.sessionId ?? state.sessionId;
+    return { kind: "session", sessionId: requireSession(explicit) };
+  }
+  // Default and explicit `"session"` both bind to the caller's own session, so
+  // a relative path can never be re-read as another session's.
+  return { kind: "session", sessionId: requireSession(state.sessionId) };
+}
+
+function requireSession(sessionId: string | undefined): string {
+  if (sessionId === undefined || sessionId.trim() === "") {
+    throw new FileSessionRequiredError(
+      "host.files needs a session in scope: call forSession(sessionId), pass { scope: { kind: 'session', sessionId } }, or use { scope: 'deployment' }"
+    );
+  }
+  return segment(sessionId);
+}
+
+/**
+ * Normalize an author path into key-relative form. Rejects traversal, NUL,
+ * backslashes, trailing slashes, and the `.cursor*` prefix the Agent Store
+ * reserves for Cursor-managed content — refusing here turns an opaque failure
+ * deep in a sink (or a 400 from the hosted API, which accepts each path in
+ * exactly one spelling) into one the author can act on, and keeps the rule
+ * identical across sinks.
+ */
+function normalizeRelPath(path: string, allowEmpty: boolean): string {
+  if (typeof path !== "string") {
+    throw new FilePathRejectedError("host.files path must be a string");
+  }
+  const trimmed = path.trim().replace(/^\/+/, "");
+  if (trimmed === "") {
+    if (allowEmpty) {
+      return "";
+    }
+    throw new FilePathRejectedError("host.files path must be non-empty");
+  }
+  if (trimmed.includes("\0")) {
+    throw new FilePathRejectedError(`host.files path is not allowed: ${path}`);
+  }
+  // A backslash is a separator on Windows and a literal on POSIX, so a key
+  // minted from one would name different objects on different hosts — and the
+  // hosted API refuses it. Same rule as `segment()` below.
+  if (trimmed.includes("\\")) {
+    throw new FilePathRejectedError(`host.files path is not allowed: ${path}`);
+  }
+  // On an object path, a trailing slash would mint a key ending in "/" — an
+  // empty "directory marker" object, never what an author writing a file
+  // meant, and refused by the hosted API. A listing prefix (`allowEmpty`) is
+  // a different thing: there a trailing slash legitimately scopes to a
+  // directory's contents.
+  if (!allowEmpty && trimmed.endsWith("/")) {
+    throw new FilePathRejectedError(`host.files path is not allowed: ${path}`);
+  }
+  const normalized = normalize(trimmed).split(sep).join("/");
+  if (
+    normalized === ".." ||
+    normalized === "." ||
+    normalized.startsWith("../") ||
+    normalized.includes("/../") ||
+    normalized.endsWith("/..")
+  ) {
+    throw new FilePathRejectedError(`host.files path is not allowed: ${path}`);
+  }
+  for (const part of normalized.split("/")) {
+    if (isReservedSegment(part)) {
+      throw new FilePathRejectedError(
+        `host.files path segment "${part}" is reserved for Cursor-managed content: ${path}`
+      );
+    }
+  }
+  return normalized;
+}
+
+/** One key segment (session id, partition): no separators, no traversal. */
+function segment(value: string): string {
+  const trimmed = value.trim();
+  if (
+    trimmed === "" ||
+    trimmed === "." ||
+    trimmed === ".." ||
+    trimmed.includes("/") ||
+    trimmed.includes("\\") ||
+    trimmed.includes("\0")
+  ) {
+    throw new FilePathRejectedError(
+      `host.files key segment is not allowed: ${value}`
+    );
+  }
+  if (isReservedSegment(trimmed)) {
+    throw new FilePathRejectedError(
+      `host.files key segment "${trimmed}" is reserved for Cursor-managed content`
+    );
+  }
+  return trimmed;
+}
+
+/** Mirrors the server's reserved-prefix rule (`AGENT_STORE_RESERVED_CURSOR_PATH_PREFIX`). */
+function isReservedSegment(value: string): boolean {
+  return value.toLowerCase().startsWith(".cursor");
+}

package/src/internal/host-platforms.ts

@@ -136,7 +136,7 @@ export async function warmupHostGitHubAuth(options: {
   const source = options.authSource ?? (await resolveHostGitHubAuthSource());
   if (source === "unavailable") {
     options.logger(
-      "[agentkit] GitHub auth: unavailable (set GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY + GITHUB_APP_INSTALLATION_ID, or GITHUB_TOKEN / GH_TOKEN, or run `gh auth login`)"
+      "[agent-sdk] GitHub auth: unavailable (set GITHUB_APP_ID + GITHUB_APP_PRIVATE_KEY + GITHUB_APP_INSTALLATION_ID, or GITHUB_TOKEN / GH_TOKEN, or run `gh auth login`)"
     );
     return source;
   }
@@ -147,7 +147,7 @@ export async function warmupHostGitHubAuth(options: {
       exportedGhToken = await ensureGhCliTokenEnv();
     } catch (error) {
       options.logger(
-        `[agentkit] GitHub auth: failed to export GH_TOKEN for gh CLI: ${
+        `[agent-sdk] GitHub auth: failed to export GH_TOKEN for gh CLI: ${
           error instanceof Error ? error.message : String(error)
         }`
       );
@@ -165,16 +165,16 @@ export async function warmupHostGitHubAuth(options: {
           ? "GITHUB_TOKEN/GH_TOKEN"
           : "gh auth token";
   if (options.github === undefined) {
-    options.logger(`[agentkit] GitHub auth: ${label}`);
+    options.logger(`[agent-sdk] GitHub auth: ${label}`);
     return source;
   }
 
   try {
     await options.github.getOctokit();
-    options.logger(`[agentkit] GitHub auth: ${label}`);
+    options.logger(`[agent-sdk] GitHub auth: ${label}`);
   } catch (error) {
     options.logger(
-      `[agentkit] GitHub auth: ${label} resolved but Octokit warmup failed: ${
+      `[agent-sdk] GitHub auth: ${label} resolved but Octokit warmup failed: ${
         error instanceof Error ? error.message : String(error)
       }`
     );

package/src/internal/hosting.ts

@@ -1,7 +1,7 @@
 /**
  * Client-side mirrors of the Agent Serve hosting validation rules
  * (backend/server/src/agentServe/agentServeShared.ts). Shared by discovery
- * (`hosting` block diagnostics on `agentkit validate`) and the deploy /
+ * (`hosting` block diagnostics on `agent-sdk validate`) and the deploy /
  * secrets CLI verbs (actionable errors before any network call). The
  * backend stays authoritative — these exist so mistakes fail fast and
  * locally with the same grammar the server enforces.

package/src/internal/http-channel.ts

@@ -326,6 +326,35 @@ export function buildHttpChannelRoutes(args: {
     },
   };
 
+  const cost: ServerRoute = {
+    method: "GET",
+    pattern: `${base}/v1/session/:sessionId/cost`,
+    auth,
+    handler: async (_request, ctx) => {
+      const sessionId = ctx.params.sessionId ?? "";
+      const record = await engine.getOrRestoreSession(sessionId);
+      if (record === undefined) {
+        return errorResponse(
+          404,
+          "session_not_found",
+          `Unknown session ${sessionId}.`
+        );
+      }
+      const ownership = requireSessionOwner(record, ctx.auth, {
+        relax: relaxSessionReadAuth,
+        beyondLoopback: relaxSessionReadAuthBeyondLoopback,
+        requestIp: ctx.requestIp,
+      });
+      if (ownership !== undefined) {
+        return ownership;
+      }
+      const payload = await engine.sessionCost(sessionId);
+      return jsonResponse(payload, {
+        headers: { [SESSION_ID_HEADER]: sessionId },
+      });
+    },
+  };
+
   const listApprovals: ServerRoute = {
     method: "GET",
     pattern: `${base}/v1/session/:sessionId/approvals`,
@@ -459,6 +488,7 @@ export function buildHttpChannelRoutes(args: {
     stop,
     stream,
     events,
+    cost,
     listApprovals,
     resolveApproval,
   ];

package/src/internal/install-cursor-skills.ts

@@ -9,11 +9,13 @@
 
 import {
   access,
+  chmod,
   cp,
   mkdir,
   readdir,
   readFile,
   rm,
+  stat,
   writeFile,
 } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -146,6 +148,11 @@ export async function installCursorSkills(
   for (const skill of skills) {
     const target = skillInstallPath(skill, skillsHome);
     await cp(skill.sourceDir, target, { recursive: true, force: true });
+    // cp() preserves source modes, and installs can come from read-only
+    // stores (Bazel runfiles, pnpm's content-addressed store, nix). Make the
+    // copies writable so the SKILL.md rewrite below and the overwrite on the
+    // next upgrade both work.
+    await makeTreeWritable(target);
     const skillMdPath = join(target, "SKILL.md");
     const raw = await readFile(skillMdPath, "utf8");
     const adjusted = prepareSkillMarkdownForCursorInstall(raw);
@@ -157,6 +164,27 @@ export async function installCursorSkills(
   return { installed, removed };
 }
 
+async function makeTreeWritable(root: string): Promise<void> {
+  await addOwnerWrite(root);
+  const entries = await readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const child = join(root, entry.name);
+    if (entry.isDirectory()) {
+      await makeTreeWritable(child);
+    } else {
+      await addOwnerWrite(child);
+    }
+  }
+}
+
+/** Add owner-write, preserving every other mode bit (e.g. exec on scripts). */
+async function addOwnerWrite(path: string): Promise<void> {
+  const mode = (await stat(path)).mode & 0o7777;
+  if ((mode & 0o200) === 0) {
+    await chmod(path, mode | 0o200);
+  }
+}
+
 /** Installed leaf dirs the package no longer ships. Installing deletes these. */
 async function orphanLeaves(
   namespaceDir: string,
@@ -243,14 +271,14 @@ export async function planSkillInstall(options?: {
   };
 }
 
-/** `Installed 9 agentkit skills`, what it dropped, and where it went. */
+/** `Installed 9 Agent SDK skills`, what it dropped, and where it went. */
 export function formatSkillInstall(
   plan: SkillInstallPlan,
   result: SkillInstallResult
 ): string {
   const noun = result.installed.length === 1 ? "skill" : "skills";
   const verb = plan.firstInstall ? "Installed" : "Updated";
-  const lines = [`${verb} ${result.installed.length} agentkit ${noun}`];
+  const lines = [`${verb} ${result.installed.length} Agent SDK ${noun}`];
   if (result.removed.length > 0) {
     lines.push(`  removed:  ${result.removed.join(", ")}`);
   }
@@ -297,7 +325,7 @@ export async function offerInstallCursorSkills(
   const verb = plan.firstInstall ? "Install" : "Update";
   const c = stdoutPalette();
   out(
-    `${verb} ${plan.shipped.length} agentkit ${noun} in ${plan.directory}?\n`
+    `${verb} ${plan.shipped.length} Agent SDK ${noun} in ${plan.directory}?\n`
   );
   out(c.dim(`  ${plan.leaves.join(", ")}\n`));
   if (!plan.firstInstall) {

package/src/internal/local-control-plane.ts

@@ -91,7 +91,7 @@ export async function createLocalControlPlane(opts: {
         }
         void opts.fireSchedule(name).catch((error) => {
           logger(
-            `[agentkit] schedule "${name}" dispatch failed: ${
+            `[agent-sdk] schedule "${name}" dispatch failed: ${
               error instanceof Error ? error.message : String(error)
             }`
           );
@@ -127,7 +127,7 @@ export async function createLocalControlPlane(opts: {
       }
       void opts.fireReminder(current.id, current.fireCount).catch((error) => {
         logger(
-          `[agentkit] reminder "${current.id}" dispatch failed: ${
+          `[agent-sdk] reminder "${current.id}" dispatch failed: ${
             error instanceof Error ? error.message : String(error)
           }`
         );

package/src/internal/logs-client.ts

@@ -1,5 +1,5 @@
 /**
- * `agentkit logs` — follow deploy progress (hosted) then runtime `/v1/logs`.
+ * `agent-sdk logs` — follow deploy progress (hosted) then runtime `/v1/logs`.
  *
  * Customer-facing output never includes hosting URLs, tokens, or infra jargon.
  */
@@ -110,7 +110,7 @@ export function sanitizeCustomerError(message: string): string {
 }
 
 /**
- * One-line label for `agentkit deploy` polling (TTY spinner / non-TTY
+ * One-line label for `agent-sdk deploy` polling (TTY spinner / non-TTY
  * transitions). Uses statusMessage → progress → raw status.
  */
 export function deployProgressLabel(detail: {

package/src/internal/mcp-endpoint.ts

@@ -106,7 +106,7 @@ export async function handleStatelessMcpRequest(args: {
     // so closing in `finally` never truncates a streamed response.
     return await transport.handleRequest(args.request);
   } catch (error) {
-    logger(`[agentkit] ${args.label} request failed: ${describeError(error)}`);
+    logger(`[agent-sdk] ${args.label} request failed: ${describeError(error)}`);
     return new Response(
       JSON.stringify({
         jsonrpc: "2.0",

package/src/internal/mcp-oauth.ts

@@ -278,7 +278,7 @@ export class HostMcpOAuthProvider implements OAuthClientProvider {
       token_endpoint_auth_method: "none",
       grant_types: ["authorization_code", "refresh_token"],
       response_types: ["code"],
-      client_name: "agentkit",
+      client_name: "Agent SDK",
     };
   }
 
@@ -432,7 +432,7 @@ export async function waitForMcpOAuthCallback(args?: {
         res
           .writeHead(200, { "content-type": "text/html; charset=utf-8" })
           .end(
-            "<!doctype html><html><body><h1>Authorized</h1><p>Return to agentkit.</p></body></html>"
+            "<!doctype html><html><body><h1>Authorized</h1><p>Return to Agent SDK.</p></body></html>"
           );
         finish({ code, state });
         return;

package/src/internal/platform-schedule-sync.ts

@@ -32,7 +32,7 @@ export async function syncHostedPlatformSchedules(args: {
     } catch (error) {
       failedDeletes.push(name);
       args.logger(
-        `[agentkit] platform timer delete failed for schedule "${name}": ${
+        `[agent-sdk] platform timer delete failed for schedule "${name}": ${
           error instanceof Error ? error.message : String(error)
         }`
       );
@@ -47,7 +47,7 @@ export async function syncHostedPlatformSchedules(args: {
       });
     } catch (error) {
       args.logger(
-        `[agentkit] platform timer upsert failed for schedule "${schedule.name}": ${
+        `[agent-sdk] platform timer upsert failed for schedule "${schedule.name}": ${
           error instanceof Error ? error.message : String(error)
         }`
       );

package/src/internal/playground/toolchain.ts

@@ -121,7 +121,7 @@ export async function runPlaygroundBuild(
       "playground vite toolchain unavailable (need playground/ sources and the vite package)"
     );
   }
-  logger("[agentkit] building playground (vite)...");
+  logger("[agent-sdk] building playground (vite)...");
   const code = await spawnVite(toolchain, ["build", "--config", VITE_CONFIG], {
     env: process.env,
   });
@@ -133,7 +133,7 @@ export async function runPlaygroundBuild(
       "playground vite build finished but dist/playground/index.html is missing"
     );
   }
-  logger("[agentkit] playground build complete");
+  logger("[agent-sdk] playground build complete");
 }
 
 /**
@@ -149,7 +149,7 @@ export async function ensurePlaygroundBundle(
   }
   if (resolvePlaygroundToolchain() === undefined) {
     logger(
-      "[agentkit] playground bundle missing and vite toolchain unavailable; /playground will show a build hint"
+      "[agent-sdk] playground bundle missing and vite toolchain unavailable; /playground will show a build hint"
     );
     return;
   }
@@ -215,7 +215,7 @@ export function startPlaygroundDevServer(options: {
   child.stderr?.on("data", (chunk: Buffer) => {
     const text = chunk.toString().trimEnd();
     if (text !== "") {
-      logger(`[agentkit] playground: ${text}`);
+      logger(`[agent-sdk] playground: ${text}`);
     }
   });
 
@@ -225,7 +225,7 @@ export function startPlaygroundDevServer(options: {
       return;
     }
     logger(
-      `[agentkit] playground spawn failed: ${err.message} — static /playground still served when built`
+      `[agent-sdk] playground spawn failed: ${err.message} — static /playground still served when built`
     );
   });
   child.on("exit", (code, signal) => {
@@ -234,7 +234,7 @@ export function startPlaygroundDevServer(options: {
     }
     if (code !== 0 && code !== null) {
       logger(
-        `[agentkit] playground exited (code ${code}${
+        `[agent-sdk] playground exited (code ${code}${
           signal ? `, signal ${signal}` : ""
         }) — static /playground still served when built`
       );