@cursor/july 0.1.88 → 0.1.90

package/src/internal/server.ts

@@ -64,9 +64,11 @@ import {
 } from "./cursor/account-mcp.js";
 import { CursorBackendClient } from "./cursor/backend-client.js";
 import {
+  cursorBackendUrl,
   cursorExternalApiUrl,
   type ResolvedApiKey,
   resolveApiKey,
+  resolveApiKeySync,
   SIGN_IN_HINT,
 } from "./cursor/credentials.js";
 import { CursorGithubCredentialProvider } from "./cursor/github-credentials.js";
@@ -281,9 +283,9 @@ export async function startServer(
   const runSchedules = options.schedules ?? !dev;
   const runReminders = options.reminders ?? !dev;
 
-  // Identify this process to the Cursor backend as agentkit (the SDK reads
-  // this when building its client-version header) so the internal-only
-  // agentkit_enabled gate applies to every turn.
+  // CURSOR_AGENTKIT_VERSION is still the env the SDK reads when building
+  // its client-version header (wire prefix remains `agentkit-`). Setting it
+  // here makes the internal-only agentkit_enabled gate apply to every turn.
   process.env.CURSOR_AGENTKIT_VERSION ??= packageVersion();
 
   const authoredOtel = pickAuthoredOtel(
@@ -328,10 +330,18 @@ export async function startServer(
 
   // One resolution for every Cursor credential consumer (SDK runner, account
   // MCP bridge, SCM event relay, GitHub credentials): explicit option →
-  // CURSOR_API_KEY → stored `agent-serve login`.
+  // CURSOR_API_KEY → CURSOR_API_KEY_FILE (or the hosted default path) →
+  // stored `agent-serve login`. SDK / GitHub / account MCP re-read later;
+  // Slack and deployment-event relays capture the key at start.
   const accountKey = await resolveApiKey(
     options.apiKey === undefined ? {} : { apiKey: options.apiKey }
   );
+  // First present source wins (we define the order): option → env → file →
+  // stored login. Re-read so bind can drop env or file onto a listening process.
+  const liveCursorApiKey = (): string | undefined =>
+    resolveApiKeySync(
+      options.apiKey === undefined ? {} : { apiKey: options.apiKey }
+    )?.apiKey;
 
   // The SCM relay reads the event stream as the signed-in user, so
   // `cursorEvents` cannot work signed out. Require the credential before any
@@ -365,15 +375,15 @@ export async function startServer(
     const needsGithubAuth =
       cursorGithubConfig.scope !== undefined || githubProxyRequested;
     if (needsGithubAuth) {
-      const cursorGithubAuth =
-        cursorEventsAuth ??
-        (accountKey?.apiKey !== undefined && accountKey.apiKey.trim() !== ""
-          ? {
-              apiKey: accountKey.apiKey.trim(),
-              baseUrl: cursorExternalApiUrl(),
-            }
-          : undefined);
-      if (cursorGithubAuth === undefined) {
+      const currentGithubApiKey = (): string | undefined => {
+        const fromEvents = cursorEventsAuth?.apiKey.trim();
+        if (fromEvents !== undefined && fromEvents !== "") {
+          return fromEvents;
+        }
+        return liveCursorApiKey();
+      };
+      const githubApiKeyNow = currentGithubApiKey();
+      if (githubApiKeyNow === undefined && options.allowAnonymous !== true) {
         throw new Error(
           "githubChannel({ cursorAccount: true }) could not resolve Cursor event authentication."
         );
@@ -387,20 +397,39 @@ export async function startServer(
         logger(
           "[agent-sdk] warning: --allow-anonymous-cursor-github — every admitted HTTP caller can drive sessions holding the signed-in account's repo-scoped GitHub credential; serve this only behind a trusted boundary (e.g. an SSO proxy)"
         );
+        if (githubApiKeyNow === undefined) {
+          logger(
+            "[agent-sdk] GitHub auth: listening unsigned; credentials bind at task via CURSOR_API_KEY or CURSOR_API_KEY_FILE"
+          );
+        }
       }
       if (cursorGithubConfig.permissions === "contents-write") {
         logger(
           '[agent-sdk] warning: Cursor GitHub credentials include contents:write — the host holds a push-capable token shared with model-driven tools and untrusted webhook content; prefer permissions: "pr-write" unless this agent must push code'
         );
       }
+      const githubAuthBaseUrl = cursorExternalApiUrl();
+      const requireGithubApiKey = async (): Promise<string> => {
+        const apiKey = currentGithubApiKey();
+        if (apiKey === undefined) {
+          throw new Error(
+            `githubChannel({ cursorAccount: true }) has no Cursor credential yet. ${SIGN_IN_HINT}`
+          );
+        }
+        return apiKey;
+      };
       const githubProxyUrl = githubProxyRequested
-        ? resolveCursorGithubProxyUrl(cursorGithubAuth.baseUrl)
+        ? resolveCursorGithubProxyUrl(githubAuthBaseUrl)
         : undefined;
-      if (cursorGithubConfig.scope !== undefined) {
+      if (
+        cursorGithubConfig.scope !== undefined &&
+        githubApiKeyNow !== undefined
+      ) {
         const provider = new CursorGithubCredentialProvider({
           client: new CursorBackendClient({
-            backendUrl: cursorGithubAuth.baseUrl,
-            apiKey: cursorGithubAuth.apiKey,
+            backendUrl: githubAuthBaseUrl,
+            apiKey: githubApiKeyNow,
+            getApiKey: () => currentGithubApiKey() ?? "",
             logger,
           }),
           scope: cursorGithubConfig.scope,
@@ -420,9 +449,7 @@ export async function startServer(
             },
           };
           for (const target of cursorGithubTargets) {
-            target.accountRuntime.credentials.bind(
-              async () => cursorGithubAuth.apiKey
-            );
+            target.accountRuntime.credentials.bind(requireGithubApiKey);
             target.accountRuntime.credentials.bindProxyTransport(
               proxyTransport
             );
@@ -438,8 +465,8 @@ export async function startServer(
       } else if (githubProxyUrl !== undefined) {
         // `cursorAccount: true` with no `--repo`: skip the startup token mint
         // (it requires a repo list) and let github-proxy take the repo from
-        // each Octokit call. Hosted multi-tenant uses this with the
-        // deployment event stream.
+        // each Octokit call. Hosted freeze bakes this flag into the template
+        // so restore is GitHub-ready once Bind drops the key.
         const proxyTransport = {
           apiBaseUrl: githubProxyUrl,
           headers: {
@@ -447,16 +474,14 @@ export async function startServer(
           },
         };
         for (const target of cursorGithubTargets) {
-          target.accountRuntime.credentials.bind(
-            async () => cursorGithubAuth.apiKey
-          );
+          target.accountRuntime.credentials.bind(requireGithubApiKey);
           target.accountRuntime.credentials.bindProxyTransport(proxyTransport);
         }
         // `ctx.host.github` gets the same proxy transport; without this it
         // would fall back to ambient auth (env token / `gh`) or an
         // unauthenticated Octokit, and every host GitHub call would 404.
         hostGithubProxyResolver = createCursorGithubProxyHostResolver({
-          getApiKey: async () => cursorGithubAuth.apiKey,
+          getApiKey: requireGithubApiKey,
           transport: proxyTransport,
         });
         logger(
@@ -496,7 +521,12 @@ export async function startServer(
   }
   const sdkRunner =
     options.runner ??
-    new CursorSdkRunner({ apiKey: accountKey?.apiKey, logger });
+    new CursorSdkRunner({
+      ...(options.apiKey === undefined || options.apiKey.trim() === ""
+        ? {}
+        : { apiKey: options.apiKey }),
+      logger,
+    });
   // Grok Bot turns run on Cursor's hosted Grok Bot (Sand) harness through
   // the /v0/grokbot session API; the SDK side is a thin remote client. The
   // dispatching runner is only interposed when a mount needs it. An
@@ -521,7 +551,16 @@ export async function startServer(
   if (hasGrokBotMounts && options.runner === undefined) {
     runner = new RuntimeDispatchingRunner({
       sdkRunner,
-      grokbot: { apiKey: accountKey?.apiKey },
+      grokbot: {
+        ...(options.apiKey === undefined || options.apiKey.trim() === ""
+          ? {}
+          : { apiKey: options.apiKey }),
+        // `/v0/grokbot` lives on the external API (api.cursor.com), not
+        // api2. Prefer that default over the account key's backendUrl.
+        // Do not pass stored login as apiKey: that would pin it as an
+        // option and beat a later CURSOR_API_KEY_FILE bind.
+        backendUrl: cursorExternalApiUrl(),
+      },
     });
     logger(
       "[agent-sdk] grokbot runtime: remote client (turns run on the hosted Grok Bot harness)"
@@ -559,15 +598,21 @@ export async function startServer(
   }
   let accountBridge: CursorAccountMcpBridge | undefined;
   if (accountRefsBySlug.size > 0) {
-    if (accountKey === undefined) {
+    if (accountKey === undefined && options.allowAnonymous !== true) {
       throw new Error(
         `This project has Cursor account MCP connections (defineConnection({ cursorAccount: true })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`
       );
     }
+    if (accountKey === undefined) {
+      logger(
+        "[agent-sdk] Cursor account MCP: listening unsigned; credentials bind at task via CURSOR_API_KEY or CURSOR_API_KEY_FILE"
+      );
+    }
     accountBridge = new CursorAccountMcpBridge({
       client: new CursorBackendClient({
-        backendUrl: accountKey.backendUrl,
-        apiKey: accountKey.apiKey,
+        backendUrl: accountKey?.backendUrl ?? cursorBackendUrl(),
+        apiKey: accountKey?.apiKey ?? "",
+        getApiKey: () => liveCursorApiKey() ?? "",
         logger,
       }),
       logger,
@@ -1035,8 +1080,13 @@ export async function startServer(
               ? undefined
               : { authorization: `Bearer ${options.authToken}` };
         if (options.cloudToolsUrl !== undefined && headers === undefined) {
-          throw new Error(
-            `Agent "${runtime.project.name}" needs a Cursor API key to authenticate --cloud-tools-url. ${SIGN_IN_HINT}`
+          if (options.allowAnonymous !== true) {
+            throw new Error(
+              `Agent "${runtime.project.name}" needs a Cursor API key to authenticate --cloud-tools-url. ${SIGN_IN_HINT}`
+            );
+          }
+          logger(
+            `[agent-sdk] --cloud-tools-url: listening unsigned; Bearer is taken from the key present at start`
           );
         }
         runtime.engine.setCloudServerToolsConnection({
@@ -2509,6 +2559,12 @@ function startCursorDeploymentRelay(input: {
     return undefined;
   }
   if (accountKey === undefined) {
+    if (input.options.allowAnonymous === true) {
+      logger(
+        "[agent-sdk] deployment-events: skipped while unsigned; long-poll relays need a key at start"
+      );
+      return undefined;
+    }
     throw new Error(
       `This project has channels subscribed to deployment events (deploymentsChannel({ deploySourceUris })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`
     );
@@ -2591,6 +2647,12 @@ async function startCursorSlackRelay(input: {
     return undefined;
   }
   if (accountKey === undefined) {
+    if (options.allowAnonymous === true) {
+      logger(
+        "[agent-sdk] cursor-slack: skipped while unsigned; long-poll relays need a key at start"
+      );
+      return undefined;
+    }
     throw new Error(
       `This project has Slack channels using the Cursor account connection (slackChannel({ cursorAccount: true })) but the host is not signed in to Cursor. ${SIGN_IN_HINT}`
     );

package/src/internal/session-engine.ts

@@ -55,6 +55,7 @@ import {
   isHostOauthConnectionTransport,
   isSymbolicConnectionTransport,
   type JsonValue,
+  type McpToolAnnotations,
   type PendingApproval,
   type ReceiveInput,
   type ResolvedAgent,
@@ -2480,6 +2481,14 @@ export class SessionEngine {
       const decision = decideToolCall({
         dryRun: args.record.dryRun === true,
         effect: args.tool.definition.effect,
+        ...(args.tool.advertised === true
+          ? {
+              mcpTool: {
+                name: args.tool.name,
+                annotations: args.tool.annotations,
+              },
+            }
+          : {}),
         dryRunResult: args.tool.definition.dryRunResult,
         input: validation.value,
       });
@@ -2490,6 +2499,17 @@ export class SessionEngine {
         );
         return normalizeToolResult(decision.result);
       }
+      if (decision.kind === "refuse") {
+        this.logger(
+          `[session] tool ${args.tool.name} refused, effect unclassified (${toolCallId})`
+        );
+        // The coverage signal: a run reports how much of itself was runnable.
+        args.emit({
+          type: "action.effect_unclassified",
+          data: { callId: toolCallId, toolName: args.tool.name },
+        });
+        return toolErrorResult(decision.message);
+      }
       const needsGate = await evaluateNeedsApproval(
         args.tool.definition.needsApproval,
         validation.value
@@ -2778,6 +2798,9 @@ export class SessionEngine {
     const decision = decideToolCall({
       dryRun: record?.dryRun === true,
       effect: tool.definition.effect,
+      ...(tool.advertised === true
+        ? { mcpTool: { name: tool.name, annotations: tool.annotations } }
+        : {}),
       dryRunResult: tool.definition.dryRunResult,
       input: validation.value,
     });
@@ -2798,7 +2821,17 @@ export class SessionEngine {
             }).catch(() => {});
           };
     try {
-      if (decision.kind === "answer") {
+      if (decision.kind === "refuse") {
+        this.logger(
+          `[session] tool ${toolName} refused, effect unclassified (direct ${callId})`
+        );
+        emit?.({
+          type: "action.effect_unclassified",
+          data: { callId, toolName },
+        });
+        result = normalizeToolResult(toolErrorResult(decision.message));
+        isError = true;
+      } else if (decision.kind === "answer") {
         this.logger(
           `[session] tool ${toolName} answered by host (direct ${callId})`
         );
@@ -2896,28 +2929,75 @@ export class SessionEngine {
    * bridged reads too; resolving effects from a server's own listing is the
    * next unit's work.
    */
-  bridgedCallAnswer(args: {
+  async bridgedCallAnswer(args: {
     sessionId: string;
+    connectionName: string;
     toolName: string;
-  }): { answered: true; result: SDKCustomToolResult } | { answered: false } {
+  }): Promise<
+    { answered: true; result: SDKCustomToolResult } | { answered: false }
+  > {
     // Read off the in-flight turn's context rather than the session store:
     // the bridge already refuses a call with no active turn, so the record is
     // in memory. That keeps this free for the sessions that are not dry runs,
-    // which is every session today.
-    const record = this.activeToolContexts.get(args.sessionId)?.record;
+    // which is every session today — the listing below is only paid inside a
+    // dry run.
+    const context = this.activeToolContexts.get(args.sessionId);
+    if (context?.record.dryRun !== true) {
+      return { answered: false };
+    }
+    // A bridged tool carries no `defineTool`, so its effect comes from the
+    // server's own listing annotations; a tool the listing cannot classify
+    // refuses rather than being stubbed. A failed listing classifies nothing,
+    // which lands on the same refusal — never on a run.
+    const annotations = await this.bridgedToolAnnotations(
+      args.connectionName,
+      args.toolName
+    );
     const decision = decideToolCall({
-      dryRun: record?.dryRun === true,
+      dryRun: true,
       effect: undefined,
+      mcpTool: { name: args.toolName, annotations },
     });
     if (decision.kind === "run") {
       return { answered: false };
     }
+    if (decision.kind === "refuse") {
+      this.logger(
+        `[session] bridged tool ${args.toolName} refused, effect unclassified (${args.sessionId})`
+      );
+      context.emit({
+        type: "action.effect_unclassified",
+        data: {
+          callId: newToolCallId(args.toolName),
+          toolName: args.toolName,
+          connection: args.connectionName,
+        },
+      });
+      return { answered: true, result: toolErrorResult(decision.message) };
+    }
     this.logger(
       `[session] bridged tool ${args.toolName} answered by host (${args.sessionId})`
     );
     return { answered: true, result: normalizeToolResult(decision.result) };
   }
 
+  /**
+   * The bounded annotations a connection's listing declares for one tool, or
+   * undefined when the tool is unlisted, unannotated, or the listing fails —
+   * all of which the policy reads as unclassified, the refusing state.
+   */
+  private async bridgedToolAnnotations(
+    connectionName: string,
+    toolName: string
+  ): Promise<McpToolAnnotations | undefined> {
+    try {
+      const listed = await this.host.mcp.listTools(connectionName);
+      return listed.find((tool) => tool.name === toolName)?.annotations;
+    } catch {
+      return undefined;
+    }
+  }
+
   // ==========================================================================
   // Events: append, dispatch to channel handlers + hooks
   // ==========================================================================

package/src/internal/tool-policy.ts

@@ -10,6 +10,7 @@
  */
 
 import type {
+  McpToolAnnotations,
   ToolEffect,
   ToolEffectDeclaration,
   ToolExecuteResult,
@@ -20,7 +21,14 @@ export type ToolDecision =
   /** Run the tool body. */
   | { kind: "run" }
   /** Do not run it; return this to the model instead. */
-  | { kind: "answer"; result: ToolExecuteResult };
+  | { kind: "answer"; result: ToolExecuteResult }
+  /**
+   * Do not run it; fail the call with this message. Only ever produced in a
+   * dry run, for an MCP tool nothing classifies: stubbing it would let the
+   * run reach a confident conclusion from no data, and running it could leak
+   * a real write — refusing is the one failure that is loud.
+   */
+  | { kind: "refuse"; message: string };
 
 /** What a policy decision needs to know about the call. */
 export interface ToolCallFacts {
@@ -28,6 +36,14 @@ export interface ToolCallFacts {
   dryRun: boolean;
   /** The tool's declaration, if it made one. */
   effect: ToolEffectDeclaration<never> | undefined;
+  /**
+   * Present when the call targets a tool nobody authored — an advertised MCP
+   * passthrough or a bridged MCP call. Consulted only when {@link effect} is
+   * undeclared: the server's own annotations classify the call, and a tool
+   * they cannot classify refuses in a dry run instead of being stubbed as a
+   * write the way an undeclared authored tool is.
+   */
+  mcpTool?: { name: string; annotations?: McpToolAnnotations };
   /** What a stubbed write should answer with, if the tool supplied one. */
   dryRunResult?: ToolExecuteResult | ((input: never) => ToolExecuteResult);
   /**
@@ -64,11 +80,74 @@ export function resolveEffect(
   return declared === "read" ? "read" : "write";
 }
 
+/**
+ * The effect an MCP server's own annotations declare, fail-closed.
+ *
+ * `readOnlyHint: true` without `destructiveHint: true` is a read; either
+ * negative signal is a write; anything else — absent annotations, or
+ * annotations that carry no effect signal (a bare `title`) — is `undefined`,
+ * unclassified. Mirrors `@anysphere/mcp-core/mcp-tool-annotations`
+ * (`classifyMcpToolAnnotationRisk`), which this package cannot import (npm
+ * publish, workspace-only dependency); keep the two in sync.
+ */
+export function classifyAnnotationsEffect(
+  annotations: McpToolAnnotations | undefined
+): ToolEffect | undefined {
+  if (annotations === undefined) {
+    return undefined;
+  }
+  if (
+    annotations.destructiveHint !== true &&
+    annotations.readOnlyHint === true
+  ) {
+    return "read";
+  }
+  if (
+    annotations.readOnlyHint === false ||
+    annotations.destructiveHint === true
+  ) {
+    return "write";
+  }
+  return undefined;
+}
+
+/**
+ * What a dry run answers when nothing classifies an MCP tool. Deliberately
+ * reads as a strict API rather than disclosing the session's posture (see
+ * {@link ACKNOWLEDGED}), and names what is missing so the fix — the server
+ * annotating, or a server-side classification entry — is one step away.
+ */
+function unclassifiedRefusal(toolName: string): string {
+  return (
+    `Tool "${toolName}" is not available in this session: its MCP server ` +
+    `does not declare whether it reads or writes (readOnlyHint/` +
+    `destructiveHint), and no server-side classification exists for it, so ` +
+    `this session cannot tell whether calling it would change anything ` +
+    `outside the session. Use a tool that declares its effect.`
+  );
+}
+
 /** Decide what to do with one tool call. Pure; no I/O, no session state. */
 export function decideToolCall(facts: ToolCallFacts): ToolDecision {
   if (!facts.dryRun) {
     return { kind: "run" };
   }
+  if (facts.effect === undefined && facts.mcpTool !== undefined) {
+    const effect = classifyAnnotationsEffect(facts.mcpTool.annotations);
+    if (effect === undefined) {
+      return {
+        kind: "refuse",
+        message: unclassifiedRefusal(facts.mcpTool.name),
+      };
+    }
+    if (effect === "read") {
+      return { kind: "run" };
+    }
+    return {
+      kind: "answer",
+      result: dryRunAnswer(facts.dryRunResult, facts.input),
+    };
+  }
   if (resolveEffect(facts.effect, facts.input) === "read") {
     return { kind: "run" };
   }

package/src/reminders.ts

@@ -2,7 +2,7 @@
  * Runtime reminders — per-session durable wakes.
  *
  * ```ts
- * import type { ReminderCreateInput } from "@anysphere/agent-serve/reminders";
+ * import type { ReminderCreateInput } from "@cursor/july/reminders";
  *
  * // Recurring ≈ setInterval; one-shot ≈ setTimeout.
  * await host.reminders?.create({

package/src/schedules.ts

@@ -6,7 +6,7 @@
  * handler form hands work off to a channel (and can call MCP via `args.host.mcp`):
  *
  * ```ts
- * import { defineSchedule } from "@anysphere/agent-serve/schedules";
+ * import { defineSchedule } from "@cursor/july/schedules";
  *
  * export default defineSchedule({
  *   cron: "0 9 * * 1-5",

package/src/skills.ts

@@ -7,7 +7,7 @@
  * content or inline sibling files:
  *
  * ```ts
- * import { defineSkill } from "@anysphere/agent-serve/skills";
+ * import { defineSkill } from "@cursor/july/skills";
  *
  * export default defineSkill({
  *   description: "Research unfamiliar topics before answering.",

package/src/storage.ts

@@ -16,7 +16,7 @@
  * not as required-or-lose-history hooks:
  *
  * ```ts
- * import { defineStorage } from "@anysphere/agent-serve/storage";
+ * import { defineStorage } from "@cursor/july/storage";
  *
  * export default defineStorage({
  *   put: (key, value) => db.upsert(key, value),

package/src/tools.ts

@@ -5,7 +5,7 @@
  * name the model sees. Export the definition as the module's default export:
  *
  * ```ts
- * import { defineTool } from "@anysphere/agent-serve/tools";
+ * import { defineTool } from "@cursor/july/tools";
  * import { z } from "zod";
  *
  * // Runs in-process on the agent-serve host (default). Authored MCP

package/src/types.ts

@@ -1,5 +1,5 @@
 /**
- * Public types for @anysphere/agent-serve.
+ * Public types for @cursor/july.
  *
  * The framework is filesystem-first: customers author an agent as files under
  * an `agent/` directory (markdown for prose, TypeScript for typed behavior),
@@ -1439,6 +1439,17 @@ export type SessionEventPayload =
         parentCallId?: string;
       };
     }
+  | {
+      /**
+       * A dry-run call was refused because nothing classifies the tool's
+       * effect: the MCP server sent no readOnlyHint/destructiveHint and no
+       * server-side classification exists for it. The per-run count of these
+       * is the coverage signal — how much of a backtest was actually
+       * runnable, reported rather than assumed.
+       */
+      type: "action.effect_unclassified";
+      data: { callId: string; toolName: string; connection?: string };
+    }
   | {
       type: "subagent.called";
       data: { callId: string; name?: string; description?: string };
@@ -2620,6 +2631,14 @@ export interface DiscoveredTool {
    * classification can read them; absent is the fail-closed state.
    */
   annotations?: McpToolAnnotations;
+  /**
+   * True for a 1:1 MCP passthrough synthesized from an advertised
+   * connection's listing. The policy treats these differently from authored
+   * tools when nothing declares an effect: an undeclared authored tool is
+   * stubbed as a write in a dry run, an unclassifiable advertised tool is
+   * refused — see `decideToolCall`.
+   */
+  advertised?: true;
   /**
    * Agent tools: script body materialized under
    * `.agent-serve/tools/<name>.sh`.
@@ -2671,7 +2690,7 @@ export interface DiscoveredHook {
 /** Live A/B metrics experiment (`agent/ab.ts` or `agent/ab/<name>.ts`). */
 export interface DiscoveredAB {
   name: string;
-  /** Branded `defineAB({ ... })` config (see `@anysphere/agent-serve/ab`). */
+  /** Branded `defineAB({ ... })` config (see `@cursor/july/ab`). */
   definition: BrandedDefinition<"ab">;
 }