@cursor/july 0.1.101 → 0.1.103

package/src/internal/init-project.ts

@@ -1,5 +1,5 @@
 /**
- * Scaffold a minimal agent-serve project (`agent-serve init`).
+ * Scaffold a minimal agent-serve project (`agent-sdk init`).
  */
 
 import { spawn } from "node:child_process";
@@ -702,7 +702,7 @@ export function initNextCommands(options: {
 }
 
 /**
- * Coding-agent setup guide printed by `agent-serve init`
+ * Coding-agent setup guide printed by `agent-sdk init`
  * with no target directory (does not scaffold).
  */
 export function printInitGuide(): void {

package/src/internal/inline-stdio-define-stub.ts

@@ -1,4 +1,4 @@
-/** Bundled stand-in for `@anysphere/agent-serve/connections` / `@cursor/july/connections`. */
+/** Bundled stand-in for `@cursor/july/connections`. */
 export function defineConnection<T>(config: T): T {
   return config;
 }

package/src/internal/is-record.ts

@@ -0,0 +1,3 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/internal/json-schema.ts

@@ -13,12 +13,13 @@ export function isZodSchema(value: unknown): value is z.ZodTypeAny {
     return true;
   }
   // Structural check for zod instances that come from a different module
-  // copy in the authoring project's node_modules.
+  // copy in the authoring project's node_modules. Zod 4 keeps `_zod`
+  // (and often `_def`).
   return (
     typeof value === "object" &&
     value !== null &&
     typeof (value as { safeParse?: unknown }).safeParse === "function" &&
-    "_def" in value
+    ("_def" in value || "_zod" in value)
   );
 }
 
@@ -50,15 +51,23 @@ export function toolOutputJsonSchema(
 function authoredSchemaToJsonSchema(
   schema: z.ZodTypeAny | JsonSchemaObject
 ): JsonSchemaObject {
-  if (isZodSchema(schema)) {
-    const converted = zodToJsonSchema(schema as z.ZodTypeAny, {
-      $refStrategy: "none",
-      target: "jsonSchema7",
-    }) as Record<string, unknown>;
-    delete converted.$schema;
-    return converted;
+  if (!isZodSchema(schema)) {
+    return schema;
   }
-  return schema;
+  const converted = convertZodSchema(schema);
+  delete converted.$schema;
+  return converted;
+}
+
+function convertZodSchema(schema: z.ZodTypeAny): Record<string, unknown> {
+  const native = (schema as { toJSONSchema?: () => unknown }).toJSONSchema;
+  if (typeof native === "function") {
+    return native.call(schema) as Record<string, unknown>;
+  }
+  return zodToJsonSchema(schema, {
+    $refStrategy: "none",
+    target: "jsonSchema7",
+  }) as Record<string, unknown>;
 }
 
 export type ToolInputValidation =

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

@@ -9,7 +9,7 @@
  * Hosted `--no-control-plane` v2 skips that poll — the hosted CP delivers.
  */
 
-import { dirname, join } from "node:path";
+import { join } from "node:path";
 import { type CronExpression, parseCron } from "./cron.js";
 import {
   type LocalIngressContinuation,
@@ -43,8 +43,7 @@ export async function createLocalControlPlane(opts: {
   fireReminder: (id: string, fireCount: number) => Promise<unknown>;
   /**
    * Persist reminder documents under `<stateDir>/reminders`. Local serve
-   * passes `<stateRoot>/control-plane`; records previously stored at
-   * `<stateRoot>/reminders` are migrated in on first boot.
+   * passes `<stateRoot>/control-plane`.
    */
   stateDir?: string;
   /** Arm deadline timers. Off in `--dev`. Defaults to true. */
@@ -59,31 +58,13 @@ export async function createLocalControlPlane(opts: {
       : new ReminderStore(join(opts.stateDir, "reminders"));
   const schedules = new Map<string, CronExpression>();
   const reminderTimers = new Map<string, NodeJS.Timeout>();
-  const reminders = new Map<string, ReminderRecord>();
+  const reminders = new Map<string, ReminderRecord>(
+    ((await store?.list()) ?? []).map((record) => [record.id, record])
+  );
   let scheduleTimer: NodeJS.Timeout | undefined;
   let lastFiredMinute = -1;
   let scmRelay: { start(): void; stop(): Promise<void> } | undefined;
 
-  if (store !== undefined) {
-    for (const record of await store.list()) {
-      reminders.set(record.id, record);
-    }
-    if (opts.stateDir !== undefined) {
-      const legacyStore = new ReminderStore(
-        join(dirname(opts.stateDir), "reminders")
-      );
-      for (const record of await legacyStore.list()) {
-        if (reminders.has(record.id)) {
-          await legacyStore.delete(record.id);
-          continue;
-        }
-        reminders.set(record.id, record);
-        await store.save(record);
-        await legacyStore.delete(record.id);
-      }
-    }
-  }
-
   function armScheduleTicker(): void {
     if (scheduleTimer !== undefined || schedules.size === 0) {
       return;

package/src/internal/mcp-endpoint.ts

@@ -37,6 +37,7 @@ import type {
   TurnOutcome,
 } from "../types.js";
 import { samePrincipal } from "./auth.js";
+import { describeError } from "./describe-error.js";
 import {
   SessionBusyError,
   type SessionEngine,
@@ -790,7 +791,3 @@ function raceTimeout<T>(
     );
   });
 }
-
-function describeError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}

package/src/internal/mcp-host.ts

@@ -26,6 +26,11 @@ import {
 } from "../types.js";
 import { CLI_COMMAND_NAME as CLI } from "./distribution.js";
 import { createHostMcpOAuthProvider } from "./mcp-oauth.js";
+import {
+  instrumentedMcpFetch,
+  mcpTraceMeta,
+  runMcpClientSpan,
+} from "./otel/mcp.js";
 
 export class McpNeedsAuthError extends Error {
   readonly connection: string;
@@ -115,12 +120,16 @@ export class McpHost implements HostMcpRegistry {
 
   async listTools(connectionName: string): Promise<HostMcpToolInfo[]> {
     const connection = this.requireConnection(connectionName);
-    return this.withClient(connectionName, async (client) => {
-      const listed = await client.listTools();
-      return listed.tools
-        .map(toToolInfo)
-        .filter((tool) => connectionAllowsTool(connection, tool.name));
-    });
+    return runMcpClientSpan(
+      { method: "tools/list", connection: connectionName },
+      () =>
+        this.withClient(connectionName, async (client) => {
+          const listed = await client.listTools(mcpListParams());
+          return listed.tools
+            .map(toToolInfo)
+            .filter((tool) => connectionAllowsTool(connection, tool.name));
+        })
+    );
   }
 
   /**
@@ -146,24 +155,37 @@ export class McpHost implements HostMcpRegistry {
     };
     return {
       listTools: () =>
-        withFreshClient(async (client) => {
-          const listed = await client.listTools();
-          return listed.tools
-            .map(toToolInfo)
-            .filter((tool) => connectionAllowsTool(connection, tool.name));
-        }),
+        runMcpClientSpan(
+          { method: "tools/list", connection: connection.name },
+          () =>
+            withFreshClient(async (client) => {
+              const listed = await client.listTools(mcpListParams());
+              return listed.tools
+                .map(toToolInfo)
+                .filter((tool) => connectionAllowsTool(connection, tool.name));
+            })
+        ),
       callTool: (toolName, args = {}) => {
         assertConnectionAllowsTool(connection, toolName);
-        return withFreshClient(async (client) => {
-          const result = await client.callTool({
-            name: toolName,
-            arguments: args,
-          });
-          return throwIfCallNeedsAuth(
-            connection.name,
-            normalizeCallResult(result)
-          );
-        });
+        return runMcpClientSpan(
+          {
+            method: "tools/call",
+            connection: connection.name,
+            toolName,
+          },
+          () =>
+            withFreshClient(async (client) => {
+              const result = await client.callTool({
+                name: toolName,
+                arguments: args,
+                ...mcpCallMeta(),
+              });
+              return throwIfCallNeedsAuth(
+                connection.name,
+                normalizeCallResult(result)
+              );
+            })
+        );
       },
     };
   }
@@ -175,13 +197,21 @@ export class McpHost implements HostMcpRegistry {
   ): Promise<HostMcpCallResult> {
     const connection = this.requireConnection(connectionName);
     assertConnectionAllowsTool(connection, toolName);
-    return this.withClient(connectionName, async (client) => {
-      const result = await client.callTool({
-        name: toolName,
-        arguments: args,
-      });
-      return throwIfCallNeedsAuth(connectionName, normalizeCallResult(result));
-    });
+    return runMcpClientSpan(
+      { method: "tools/call", connection: connectionName, toolName },
+      () =>
+        this.withClient(connectionName, async (client) => {
+          const result = await client.callTool({
+            name: toolName,
+            arguments: args,
+            ...mcpCallMeta(),
+          });
+          return throwIfCallNeedsAuth(
+            connectionName,
+            normalizeCallResult(result)
+          );
+        })
+    );
   }
 
   async dropClient(name: string): Promise<void> {
@@ -460,10 +490,33 @@ async function createTransport(
         })
       : undefined;
 
+  const fetchImpl = instrumentedMcpFetch();
+  const fetchLike = (url: string | URL, init?: RequestInit) =>
+    fetchImpl(url, init);
   if (transport.type === "sse") {
-    return new SSEClientTransport(url, { requestInit, authProvider });
+    return new SSEClientTransport(url, {
+      requestInit,
+      authProvider,
+      fetch: fetchLike,
+    });
   }
-  return new StreamableHTTPClientTransport(url, { requestInit, authProvider });
+  return new StreamableHTTPClientTransport(url, {
+    requestInit,
+    authProvider,
+    fetch: fetchLike,
+  });
+}
+
+function mcpListParams(): { _meta: { traceparent: string } } | undefined {
+  const meta = mcpTraceMeta();
+  return meta === undefined ? undefined : { _meta: meta };
+}
+
+function mcpCallMeta():
+  | { _meta: { traceparent: string } }
+  | Record<string, never> {
+  const meta = mcpTraceMeta();
+  return meta === undefined ? {} : { _meta: meta };
 }
 
 function isOauthHttpTransport(