@cursor/july 0.1.96 → 0.1.99

package/src/channels/slack/setup.ts

@@ -2,7 +2,7 @@
  * Slack setup guide printed by `agent-serve slack setup`.
  *
  * Dedicated Socket Mode app via `slack create` (dashboard wizard).
- * `slack init --manual` is the unmanaged paste-at-api.slack.com path.
+ * `slack init --manual` is the unmanaged Slack CLI / paste path.
  * {@link SLACK_SETUP_PHASES} is that checklist; its ids key
  * `.agent-serve/slack/setup-status.json`.
  */
@@ -21,6 +21,7 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     title: "Generate channel + manifests",
     steps: [
       "agent-serve slack init --manual --dir . --name My Agent",
+      "Installs the Slack app when Slack CLI is logged in. Otherwise next asks the user to install it.",
       "Manifests default to Socket Mode (no public Request URL).",
     ],
   },
@@ -29,9 +30,11 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     actor: "human",
     title: "Create two Slack apps from manifests",
     steps: [
-      "Open https://api.slack.com/apps -> Create New App from a manifest",
-      "Paste .agent-serve/slack/manifest.dev.json -> create the *dev* app",
-      "Repeat with manifest.prod.json for the *prod* app",
+      "Preferred: Slack CLI at ~/.slack/bin/slack. slack login --no-prompt, then slack app install --environment local --team <T> --force",
+      "Prod: SLACK_ENV=deployed slack app install --environment deployed --team <T> --force",
+      "Do not slack deploy; Agent SDK serve owns Socket Mode",
+      "Fallback: https://api.slack.com/apps -> Create New App from a manifest",
+      "Paste .slack/manifest.dev.json, then manifest.prod.json",
     ],
   },
   {
@@ -39,8 +42,9 @@ export const SLACK_SETUP_PHASES: SlackSetupPhase[] = [
     actor: "human",
     title: "Install + mint App-Level Token",
     steps: [
-      "Install to Workspace; copy Bot User OAuth Token (xoxb-...)",
+      "Slack CLI install leaves tokens in that process only. Copy xoxb from OAuth & Permissions at https://api.slack.com/apps/<appId>",
       "App-Level Tokens: create token with connections:write; copy xapp-...",
+      "If Slack CLI wrote SLACK_* to .env, copy them into .env.local using env.example names",
     ],
   },
   {
@@ -106,7 +110,7 @@ export function formatSlackSetupGuide(): string {
     "  Finish Slack consent and the bot name there. The CLI writes",
     "  tokens into .env.local.",
     "",
-    "Manual Slack app: `slack init --manual`. Phases below.",
+    "Manual Slack app: `slack init --manual` (Slack CLI, or paste at api.slack.com).",
     "Goal: importable dev + prod Slack apps over Socket Mode (no public URL).",
     "App-Level Token (xapp-...) + Bot Token (xoxb-...) required.",
     "",

package/src/channels/slack/slack-channel.ts

@@ -487,6 +487,7 @@ export function slackChannel(
               credentials,
               getSession: args.getSession,
               resolveApproval: args.resolveApproval,
+              resolveAuth: args.resolveAuth,
               waitUntil: args.waitUntil,
               log: getLog(),
               blockExternals,

package/src/channels/slack/tool-approval-events.ts

@@ -21,8 +21,11 @@
 import type { ChannelEventHandlers } from "../../types.js";
 import { postMessage, setThreadStatus, updateMessage } from "./api.js";
 import {
+  authThreadStatus,
   buildApprovalBlocks,
+  buildAuthBlocks,
   buildResolvedApprovalBlocks,
+  buildResolvedAuthBlocks,
 } from "./approvals.js";
 import { SLACK_DEFAULT_LOADING_MESSAGES } from "./constants.js";
 import { defaultSlackLog, type SlackLog } from "./log.js";
@@ -132,5 +135,95 @@ export function buildToolApprovalEvents(
         decision: event.data.decision,
       });
     },
+
+    async "action.auth_requested"(event, channel, ctx) {
+      const log = getLog();
+      const state = channel.state;
+      if (state.channelId === null || state.threadTs === null) {
+        return;
+      }
+      const blocks = buildAuthBlocks({
+        sessionId: ctx.session.id,
+        callId: event.data.callId,
+        toolName: event.data.toolName,
+        connection: event.data.connection,
+        authUrl: event.data.authUrl,
+      });
+      try {
+        const posted = await postMessage({
+          botToken,
+          channel: state.channelId,
+          threadTs: state.threadTs,
+          text: `Authorization required for \`${event.data.connection}\``,
+          blocks,
+        });
+        channel.state.approvalMessageByCallId = {
+          ...(state.approvalMessageByCallId ?? {}),
+          [event.data.callId]: posted.ts,
+        };
+        await setThreadStatus({
+          botToken,
+          channelId: state.channelId,
+          threadTs: state.threadTs,
+          status: authThreadStatus(event.data.connection),
+          loadingMessages: [
+            authThreadStatus(event.data.connection),
+            ...SLACK_DEFAULT_LOADING_MESSAGES,
+          ],
+        });
+        log.info("auth card posted", {
+          call_id: event.data.callId,
+          connection: event.data.connection,
+          message_ts: posted.ts,
+        });
+      } catch (error) {
+        log.warn("auth card post failed", {
+          call_id: event.data.callId,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    },
+
+    async "action.auth_resolved"(event, channel) {
+      const log = getLog();
+      const state = channel.state;
+      const messageTs = state.approvalMessageByCallId?.[event.data.callId];
+      if (
+        state.channelId !== null &&
+        messageTs !== undefined &&
+        messageTs !== ""
+      ) {
+        const blocks = buildResolvedAuthBlocks({
+          connection: event.data.connection,
+          decision: event.data.decision,
+          byUserId: event.data.by,
+        });
+        const verb =
+          event.data.decision === "approve" ? "Connected" : "Cancelled";
+        await updateMessage({
+          botToken,
+          channel: state.channelId,
+          ts: messageTs,
+          text: `${verb} — ${event.data.connection}`,
+          blocks,
+        });
+        const next = { ...(state.approvalMessageByCallId ?? {}) };
+        delete next[event.data.callId];
+        channel.state.approvalMessageByCallId = next;
+      }
+      if (state.channelId !== null && state.threadTs !== null) {
+        await setThreadStatus({
+          botToken,
+          channelId: state.channelId,
+          threadTs: state.threadTs,
+          status: "Working…",
+          loadingMessages: [...SLACK_DEFAULT_LOADING_MESSAGES],
+        });
+      }
+      log.info("auth resolved in slack", {
+        call_id: event.data.callId,
+        decision: event.data.decision,
+      });
+    },
   };
 }

package/src/channels/slack/types.ts

@@ -61,8 +61,14 @@ export interface SlackChannelState {
   streamTs: string | null;
   /** Channel id used when the stream was started. */
   streamChannelId?: string | null;
-  /** Last cumulative text sent via appendStream (for incremental append). */
+  /** Last assistant text delivered to the thread (stream or postMessage). */
   lastPostedText?: string | null;
+  /**
+   * Text of the current assistant block already written into the open stream.
+   * The harness restarts its cumulative text at every tool boundary, so the
+   * append delta cannot be measured against {@link lastPostedText}.
+   */
+  streamBlockText?: string | null;
   /**
    * Slack message ts of the agent's last delivered reply in this thread.
    * Warm turns use this as the `<slack_thread_delta>` watermark.
@@ -73,6 +79,8 @@ export interface SlackChannelState {
    * for the rest of the turn.
    */
   streamingUnavailable?: boolean;
+  /** Editable progress message ts when `chat.startStream` is unavailable. */
+  progressTs: string | null;
   /**
    * Message ts of approval cards keyed by tool call id (for
    * replacing Approve/Deny buttons after a decision).

package/src/evals/run-facts.ts

@@ -182,6 +182,38 @@ export function deriveRunFacts(events: readonly SessionEvent[]): EvalRunFacts {
         }
         break;
       }
+      case "action.auth_requested": {
+        const request: EvalInputRequestFact = {
+          callId: event.data.callId,
+          toolName: event.data.toolName,
+          args: {
+            connection: event.data.connection,
+            authUrl: event.data.authUrl,
+          },
+          resolved: false,
+        };
+        inputRequests.push(request);
+        inputRequestsByCallId.set(event.data.callId, request);
+        break;
+      }
+      case "action.auth_resolved": {
+        const request = inputRequestsByCallId.get(event.data.callId);
+        if (request !== undefined) {
+          request.resolved = true;
+          request.decision = event.data.decision;
+        }
+        const fact = ensureCall(
+          event.data.callId,
+          event.data.toolName,
+          event.turnId,
+          event.data.parentCallId
+        );
+        fact.approvalDecision = event.data.decision;
+        if (event.data.decision === "deny") {
+          fact.status = "rejected";
+        }
+        break;
+      }
       case "subagent.called": {
         const existing = subagentsByCallId.get(event.data.callId);
         if (existing === undefined) {

package/src/files-backends/cursor-hosted.ts

@@ -76,8 +76,9 @@ export const AGENT_SERVE_STORE_SOURCE_ID_ENV_VAR =
  * user-level store above. The user store carries author-facing bytes
  * (`ctx.host.files`, skills, memory, artifacts) and is browsable and
  * mountable; the framework store carries engine-owned session state —
- * session records, event transcripts, continuation index, and the SDK
- * conversation mirror — and is never exposed to authors or models.
+ * session records, event transcripts, hosted-execution run logs,
+ * continuation index, and the SDK conversation mirror — and is never
+ * exposed to authors or models.
  * Provisioned by the v2 deploy pipeline alongside the user store; v1
  * deployments have only the user store.
  */

package/src/index.ts

@@ -79,6 +79,10 @@ export {
   V2EngineError,
 } from "./continuation.js";
 export { defineHook } from "./hooks.js";
+export {
+  InvalidAsOfError,
+  VacuousTimeArgsError,
+} from "./internal/as-of.js";
 export type { LoadAgentProjectOptions } from "./internal/discovery.js";
 export {
   formatDiagnostics,

package/src/internal/advertise-tools.ts

@@ -118,24 +118,45 @@ export async function resolveAdvertisedTools(args: {
     return [];
   }
   const sourceFor = args.sourceFor ?? sourceForConnection;
+  // Each connection's listing is a network round trip against a distinct
+  // server (auth callback, MCP initialize, tools/list), so they run
+  // concurrently; the fan-out is bounded by the agent's declared
+  // connections. Name assignment below stays in declaration order so
+  // collision suffixes do not depend on which server answered first.
+  type Listing =
+    | {
+        connection: DiscoveredConnection;
+        ok: true;
+        source: AdvertisedToolSource;
+        listed: HostMcpToolInfo[];
+      }
+    | { connection: DiscoveredConnection; ok: false; error: unknown };
+  const listings = await Promise.all(
+    advertising.map(async (connection): Promise<Listing> => {
+      try {
+        const source = await sourceFor(connection, args.session, args.hostMcp);
+        const listed = await source.listTools();
+        return { connection, ok: true, source, listed };
+      } catch (error) {
+        return { connection, ok: false, error };
+      }
+    })
+  );
   const claimed = new Set(args.agent.tools.map((tool) => tool.name));
   const resolved: DiscoveredTool[] = [];
-  for (const connection of advertising) {
-    let listed: HostMcpToolInfo[];
-    let source: AdvertisedToolSource;
-    try {
-      source = await sourceFor(connection, args.session, args.hostMcp);
-      listed = await source.listTools();
-    } catch (error) {
+  for (const listing of listings) {
+    const { connection } = listing;
+    if (!listing.ok) {
       if (args.onConnectionError !== undefined) {
-        args.onConnectionError(connection.name, error);
+        args.onConnectionError(connection.name, listing.error);
         continue;
       }
       throw new Error(
-        `Failed to list tools on advertised connection "${connection.name}": ${describeError(error)}`,
-        { cause: error }
+        `Failed to list tools on advertised connection "${connection.name}": ${describeError(listing.error)}`,
+        { cause: listing.error }
       );
     }
+    const { source, listed } = listing;
     const intended = listed.filter(
       (info) =>
         !isDoNotCallTool(info.annotations) &&

package/src/internal/approval-gate.ts

@@ -1,13 +1,12 @@
 /**
- * In-memory gate for human-in-the-loop tool approvals. The session
- * engine parks inside a server-tool `execute` by awaiting
- * {@link ApprovalGate.wait}; HTTP (or the playground) unblocks via
- * {@link ApprovalGate.resolve}.
+ * In-memory gate for human-in-the-loop parks. The session engine parks
+ * inside a server-tool `execute` by awaiting {@link ApprovalGate.wait};
+ * HTTP (or the playground) unblocks via {@link ApprovalGate.resolve}.
  *
- * Pending approvals are also mirrored onto {@link SessionRecord} for
- * durability of the *list* across reloads. After a process restart the
- * in-flight SDK tool callback is gone, so resolve returns false and
- * the host treats the approval as interrupted.
+ * Used for `needsApproval` and MCP on-demand auth. Pending rows are also
+ * mirrored onto {@link SessionRecord} for durability of the *list* across
+ * reloads. After a process restart the in-flight SDK tool callback is gone,
+ * so resolve returns false and the host treats the park as interrupted.
  */
 
 import type { ApprovalDecision, PendingApproval } from "../types.js";
@@ -21,33 +20,25 @@ export interface ApprovalResolution {
   by?: string;
 }
 
-interface Waiter {
-  meta: PendingApproval;
+interface Waiter<T> {
+  meta: T;
   resolve: (resolution: ApprovalResolution) => void;
 }
 
-export class ApprovalGate {
-  private readonly waiters = new Map<string, Waiter>();
+export class ApprovalGate<T extends { callId: string } = PendingApproval> {
+  private readonly waiters = new Map<string, Waiter<T>>();
 
-  wait(
-    meta: PendingApproval & { sessionId: string }
-  ): Promise<ApprovalResolution> {
-    const key = approvalKey(meta.sessionId, meta.callId);
+  wait(sessionId: string, meta: T): Promise<ApprovalResolution> {
+    const key = approvalKey(sessionId, meta.callId);
     const existing = this.waiters.get(key);
     if (existing !== undefined) {
       throw new Error(
-        `Approval already pending for session ${meta.sessionId} call ${meta.callId}`
+        `Approval already pending for session ${sessionId} call ${meta.callId}`
       );
     }
     return new Promise<ApprovalResolution>((resolveDecision) => {
       this.waiters.set(key, {
-        meta: {
-          callId: meta.callId,
-          turnId: meta.turnId,
-          toolName: meta.toolName,
-          args: meta.args,
-          requestedAt: meta.requestedAt,
-        },
+        meta,
         resolve: resolveDecision,
       });
     });
@@ -69,11 +60,11 @@ export class ApprovalGate {
       return false;
     }
     this.waiters.delete(key);
+    const by =
+      resolvedBy === undefined || resolvedBy === "" ? undefined : resolvedBy;
     waiter.resolve({
       decision,
-      ...(resolvedBy === undefined || resolvedBy === ""
-        ? {}
-        : { by: resolvedBy }),
+      by,
     });
     return true;
   }
@@ -82,9 +73,9 @@ export class ApprovalGate {
     return this.waiters.has(approvalKey(sessionId, callId));
   }
 
-  list(sessionId: string): PendingApproval[] {
+  list(sessionId: string): T[] {
     const prefix = `${sessionId}\0`;
-    const out: PendingApproval[] = [];
+    const out: T[] = [];
     for (const [key, waiter] of this.waiters) {
       if (key.startsWith(prefix)) {
         out.push(waiter.meta);

package/src/internal/as-of.ts

@@ -0,0 +1,107 @@
+const TIMEZONE_SUFFIX = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+
+export class InvalidAsOfError extends Error {
+  constructor(value: string) {
+    super(
+      `asOf must be an ISO-8601 instant with a timezone (e.g. ` +
+        `2026-08-31T12:00:00Z); received ${JSON.stringify(value)}.`
+    );
+    this.name = "InvalidAsOfError";
+  }
+}
+
+function parseInstant(value: string): Date | undefined {
+  const trimmed = value.trim();
+  if (trimmed === "" || !TIMEZONE_SUFFIX.test(trimmed)) {
+    return undefined;
+  }
+  const instant = new Date(trimmed);
+  return Number.isNaN(instant.getTime()) ? undefined : instant;
+}
+
+export function normalizeAsOf(value: string | undefined): string | undefined {
+  if (value === undefined) {
+    return undefined;
+  }
+  const instant = parseInstant(value);
+  if (instant === undefined) {
+    throw new InvalidAsOfError(value);
+  }
+  return instant.toISOString();
+}
+
+export function sessionClock(asOf: string | undefined): () => Date {
+  if (asOf === undefined) {
+    return () => new Date();
+  }
+  const frozen = new Date(asOf).getTime();
+  return () => new Date(frozen);
+}
+
+export class VacuousTimeArgsError extends Error {
+  constructor(toolName: string, missing: readonly string[]) {
+    super(
+      `Tool "${toolName}" declares timeArgs ` +
+        `${JSON.stringify(missing)} that its input schema does not define, ` +
+        `so bounding would silently check nothing. Make the declaration ` +
+        `match the schema's property names.`
+    );
+    this.name = "VacuousTimeArgsError";
+  }
+}
+
+export function assertTimeArgs(
+  tools: readonly {
+    name: string;
+    definition: { timeArgs?: readonly string[] };
+    inputSchema?: { properties?: Record<string, unknown> };
+  }[],
+  asOf: string | undefined
+): void {
+  if (asOf === undefined) {
+    return;
+  }
+  for (const tool of tools) {
+    const declared = tool.definition.timeArgs;
+    if (declared === undefined || declared.length === 0) {
+      continue;
+    }
+    const properties = tool.inputSchema?.properties ?? {};
+    const missing = declared.filter((name) => !(name in properties));
+    if (missing.length > 0) {
+      throw new VacuousTimeArgsError(tool.name, missing);
+    }
+  }
+}
+
+export function timeArgViolation(
+  input: unknown,
+  timeArgs: readonly string[],
+  asOf: string
+): string | undefined {
+  const record =
+    typeof input === "object" && input !== null
+      ? (input as Record<string, unknown>)
+      : {};
+  const frozen = new Date(asOf).getTime();
+  for (const name of timeArgs) {
+    const value = record[name];
+    const instant = typeof value === "string" ? parseInstant(value) : undefined;
+    if (instant === undefined) {
+      return (
+        `Time argument "${name}" must be an absolute ISO-8601 instant with ` +
+        `a timezone (e.g. ${asOf}); received ${JSON.stringify(value)}. This ` +
+        `session reads the world as of ${asOf} — supply absolute bounds at ` +
+        `or before that instant and retry.`
+      );
+    }
+    if (instant.getTime() > frozen) {
+      return (
+        `Time argument "${name}" (${JSON.stringify(value)}) is later than ` +
+        `the instant this session reads the world as of (${asOf}). Supply ` +
+        `bounds at or before that instant and retry.`
+      );
+    }
+  }
+  return undefined;
+}

package/src/internal/chat-client.ts

@@ -483,6 +483,25 @@ async function streamTurn(args: StreamTurnArgs): Promise<number> {
         );
         continue;
       }
+      if (event.type === "action.auth_requested") {
+        closeAssistant();
+        write(
+          `    ${c.yellow("⏸")} ${c.bold(event.data.connection)} ${c.dim(
+            "awaiting MCP authorization"
+          )}\n`
+        );
+        continue;
+      }
+      if (event.type === "action.auth_resolved") {
+        const mark =
+          event.data.decision === "approve" ? c.green("✓") : c.red("✗");
+        write(
+          `    ${mark} ${c.bold(event.data.connection)} ${c.dim(
+            event.data.decision === "approve" ? "connected" : "denied"
+          )}\n`
+        );
+        continue;
+      }
       if (event.type === "action.result") {
         if (
           event.data.toolName === "task" &&