veryfront 0.1.128 → 0.1.129

package/src/src/html/styles-builder/css-pregeneration.ts

@@ -7,14 +7,23 @@
  */
 
 import { serverLogger } from "../../utils/index.js";
+import { join } from "../../platform/compat/path/index.js";
+import { createFileSystem, type FileSystem } from "../../platform/compat/fs.js";
 import { extractCandidatesFromFiles, getProjectCSS } from "./tailwind-compiler.js";
 import {
   createPreparedProjectCSSContext,
   storePreparedProjectCSS,
+  tryGetPreparedProjectCSS,
 } from "./prepared-project-css-cache.js";
-import type { StyleScopeProfile } from "./style-scope-profile.js";
+import {
+  shouldIncludeStylePath,
+  shouldTraverseStyleDirectory,
+  type StyleScopeProfile,
+} from "./style-scope-profile.js";
 
 const logger = serverLogger.component("css-pregeneration");
+const inFlightPreparedCSSBuilds = new Map<string, Promise<void>>();
+const SOURCE_EXTENSIONS = [".tsx", ".jsx", ".mdx", ".ts", ".js"];
 
 interface CSSPregenerationOptions {
   /** Project slug for cache keying */
@@ -47,6 +56,12 @@ export interface PreparedCSSArtifactBuildResult {
   context: ReturnType<typeof createPreparedProjectCSSContext>;
 }
 
+interface LocalProjectSourceFilesOptions {
+  projectDir: string;
+  styleProfile: StyleScopeProfile;
+  fs?: FileSystem;
+}
+
 export async function buildPreparedCSSArtifactFromFiles(
   options: CSSPregenerationOptions,
 ): Promise<PreparedCSSArtifactBuildResult> {
@@ -93,6 +108,123 @@ export async function buildPreparedCSSArtifactFromFiles(
   };
 }
 
+export async function collectLocalProjectSourceFiles(
+  options: LocalProjectSourceFilesOptions,
+): Promise<Array<{ path: string; content?: string }>> {
+  const fs = options.fs ?? createFileSystem();
+  const files: Array<{ path: string; content?: string }> = [];
+
+  const scanDir = async (directoryPath: string): Promise<void> => {
+    let entries: AsyncIterable<{ name: string; isFile: boolean; isDirectory: boolean }>;
+    try {
+      entries = fs.readDir(directoryPath);
+    } catch {
+      return;
+    }
+
+    for await (const entry of entries) {
+      const fullPath = join(directoryPath, entry.name);
+
+      if (entry.isDirectory) {
+        if (shouldTraverseStyleDirectory(options.styleProfile, fullPath, options.projectDir)) {
+          await scanDir(fullPath);
+        }
+        continue;
+      }
+
+      if (!entry.isFile) continue;
+      if (!shouldIncludeStylePath(options.styleProfile, fullPath, options.projectDir)) continue;
+      if (!SOURCE_EXTENSIONS.some((extension) => entry.name.endsWith(extension))) continue;
+
+      try {
+        files.push({
+          path: fullPath,
+          content: await fs.readTextFile(fullPath),
+        });
+      } catch {
+        // ignore unreadable files during warmup
+      }
+    }
+  };
+
+  await scanDir(options.projectDir);
+  return files;
+}
+
+export async function readLocalProjectStylesheet(
+  projectDir: string,
+  stylesheetPath?: string,
+  fs: FileSystem = createFileSystem(),
+): Promise<string | undefined> {
+  const candidatePaths = stylesheetPath ? [stylesheetPath.replace(/^\/+/, "")] : [
+    "globals.css",
+    "global.css",
+    "styles/globals.css",
+    "app/globals.css",
+    "src/globals.css",
+    "src/styles/globals.css",
+  ];
+
+  for (const relativePath of candidatePaths) {
+    const absolutePath = join(projectDir, relativePath);
+    try {
+      return await fs.readTextFile(absolutePath);
+    } catch {
+      // keep searching
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Trigger prepared CSS generation in the background when the artifact is not
+ * already cached or currently being built.
+ */
+export async function warmPreparedCSSArtifactFromFiles(
+  options: CSSPregenerationOptions,
+): Promise<boolean> {
+  const stylesheet = options.stylesheet ??
+    findStylesheetFromFiles(options.files, options.stylesheetPath);
+  const context = createPreparedProjectCSSContext(
+    options.projectSlug,
+    options.projectVersion,
+    stylesheet,
+    options.styleProfile.hash,
+    {
+      minify: options.minify ?? true,
+      environment: options.environment ?? "preview",
+      buildMode: options.buildMode ?? "production",
+    },
+  );
+
+  if (await tryGetPreparedProjectCSS(context)) return false;
+  if (inFlightPreparedCSSBuilds.has(context.cacheKey)) return false;
+
+  const task = buildPreparedCSSArtifactFromFiles({
+    ...options,
+    stylesheet,
+  }).then(() => {
+    logger.debug("Warm prepared CSS complete", {
+      projectSlug: options.projectSlug,
+      projectVersion: options.projectVersion,
+      cacheKey: context.cacheKey,
+    });
+  }).catch((error) => {
+    logger.debug("Warm prepared CSS failed", {
+      projectSlug: options.projectSlug,
+      projectVersion: options.projectVersion,
+      cacheKey: context.cacheKey,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }).finally(() => {
+    inFlightPreparedCSSBuilds.delete(context.cacheKey);
+  });
+
+  inFlightPreparedCSSBuilds.set(context.cacheKey, task);
+  return true;
+}
+
 /**
  * Pre-generate and cache CSS from file list.
  *

package/src/src/html/styles-builder/dev-styles.ts

@@ -1,8 +1,8 @@
 import { Z_INDEX_ERROR_OVERLAY } from "../../utils/index.js";
-import { escapeHtml } from "../html-escape.js";
+import { buildNonceAttribute } from "../html-escape.js";
 
 export function getDevStyles(nonce?: string): string {
-  const nonceAttr = nonce ? ` nonce="${escapeHtml(nonce)}"` : "";
+  const nonceAttr = buildNonceAttribute(nonce);
 
   return `
   <style${nonceAttr}>

package/src/src/html/utils.ts

@@ -4,6 +4,7 @@ import { VERYFRONT_VERSION } from "../utils/constants/cdn.js";
 import {
   DEFAULT_REACT_VERSION,
   esmShReact,
+  readProjectDependencyVersions,
   resolveProjectReactVersion,
   stripSemverRange,
 } from "../transforms/esm/package-registry.js";
@@ -32,21 +33,30 @@ interface DetectedVersions {
   veryfront: string;
 }
 
+interface CachedImportMapEntry {
+  cacheKey: string;
+  json: string;
+}
+
 const DEFAULT_VERSIONS: DetectedVersions = {
   react: DEFAULT_REACT_VERSION,
   veryfront: VERYFRONT_VERSION,
 };
 
+const importMapJsonCache = new Map<string, CachedImportMapEntry>();
+
 type CdnProvider = "esm.sh" | "unpkg" | "jsdelivr";
 
 // Platform utilities served from local module server to match SSR behavior.
 // This ensures hydration matches (same code on server and client).
 // CRITICAL: veryfront/context must use local module to share React context with SSR.
 // Using esm.sh creates a separate context instance causing usePageContext to return undefined.
+const CORE_REACT_RUNTIME_PATH = "/_vf_modules/_veryfront/react/runtime/core.js";
+
 const PLATFORM_UTILITY_PATHS = {
-  head: "/_vf_modules/_veryfront/react/components/Head.js",
-  router: "/_vf_modules/_veryfront/react/router/index.js",
-  context: "/_vf_modules/_veryfront/react/context/index.js",
+  head: CORE_REACT_RUNTIME_PATH,
+  router: CORE_REACT_RUNTIME_PATH,
+  context: CORE_REACT_RUNTIME_PATH,
   fonts: "/_vf_modules/_veryfront/react/fonts/index.js",
   // Client-side AI/chat modules - use local module server in dev for faster iteration
   // NOTE: These are NOT available in compiled binaries, so we use CDN URLs there instead
@@ -201,58 +211,63 @@ async function resolveVersions(
   config?: VeryfrontConfig,
 ): Promise<DetectedVersions> {
   // Use shared resolver for React (handles config override + package.json + fallback)
-  const reactVersion = await resolveProjectReactVersion({ projectDir, config });
+  const versionsConfig = config?.client?.cdn?.versions;
+  const configuredReactVersion = versionsConfig && versionsConfig !== "auto"
+    ? versionsConfig.react
+    : undefined;
+  const configuredVeryfrontVersion = versionsConfig && versionsConfig !== "auto"
+    ? versionsConfig.veryfront
+    : undefined;
+  const detected = await readProjectDependencyVersions(projectDir);
+  const reactVersion = configuredReactVersion
+    ? resolveProjectReactVersion({ config })
+    : Promise.resolve(detected.react ?? DEFAULT_VERSIONS.react);
 
   // Resolve veryfront version separately (config override or detection)
-  const versionsConfig = config?.client?.cdn?.versions;
   let veryfrontVersion = DEFAULT_VERSIONS.veryfront;
 
-  if (versionsConfig && versionsConfig !== "auto" && versionsConfig.veryfront) {
-    veryfrontVersion = versionsConfig.veryfront;
-  } else {
-    try {
-      const { createFileSystem } = await import("../platform/compat/fs.js");
-      const fs = createFileSystem();
-      const content = await fs.readTextFile(`${projectDir}/package.json`);
-      const pkg = JSON.parse(content) as {
-        dependencies?: Record<string, string>;
-        devDependencies?: Record<string, string>;
-      };
-      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-      if (deps.veryfront) {
-        veryfrontVersion = stripSemverRange(deps.veryfront);
-      }
-    } catch (_) {
-      /* expected: package.json may not exist or be unreadable */
-    }
+  if (configuredVeryfrontVersion) {
+    veryfrontVersion = stripSemverRange(configuredVeryfrontVersion);
+  } else if (detected.veryfront) {
+    veryfrontVersion = detected.veryfront;
   }
 
-  return { react: reactVersion, veryfront: veryfrontVersion };
+  return { react: await reactVersion, veryfront: veryfrontVersion };
 }
 
 interface BuildImportMapOptions {
   projectDir?: string;
   config?: VeryfrontConfig;
   customImports?: Record<string, string>;
+  pretty?: boolean;
 }
 
 function isImportMapOnlyOptions(
   options: BuildImportMapOptions | Record<string, string>,
 ): options is Record<string, string> {
-  return !("projectDir" in options) && !("config" in options) && !("customImports" in options);
+  return !("projectDir" in options) &&
+    !("config" in options) &&
+    !("customImports" in options) &&
+    !("pretty" in options);
 }
 
 export async function buildImportMapJson(
   options?: BuildImportMapOptions | Record<string, string>,
 ): Promise<string> {
+  const stringifyImportMap = (imports: Record<string, string>, pretty = true) =>
+    JSON.stringify({ imports }, null, pretty ? 2 : undefined);
+  const stableMapKey = (imports?: Record<string, string>) =>
+    imports ? JSON.stringify(Object.entries(imports).sort(([a], [b]) => a.localeCompare(b))) : "";
+
   if (options && isImportMapOnlyOptions(options)) {
     const imports = options;
     if (Object.keys(imports).length > 0) {
-      return JSON.stringify({ imports }, null, 2);
+      return stringifyImportMap(imports);
     }
   }
 
-  const { projectDir, config, customImports } = (options ?? {}) as BuildImportMapOptions;
+  const { projectDir, config, customImports, pretty = true } =
+    (options ?? {}) as BuildImportMapOptions;
   const mode = config?.client?.moduleResolution ?? "cdn";
   const versions = projectDir ? await resolveVersions(projectDir, config) : DEFAULT_VERSIONS;
 
@@ -267,7 +282,7 @@ export async function buildImportMapJson(
       ...customImports,
     };
 
-    return JSON.stringify({ imports }, null, 2);
+    return stringifyImportMap(imports, pretty);
   }
 
   let imports: Record<string, string>;
@@ -283,7 +298,25 @@ export async function buildImportMapJson(
     imports = { ...imports, ...customImports };
   }
 
-  return JSON.stringify({ imports }, null, 2);
+  const cacheKey = JSON.stringify({
+    projectDir: projectDir ?? "",
+    mode,
+    provider: config?.client?.cdn?.provider ?? "esm.sh",
+    react: versions.react,
+    veryfront: versions.veryfront,
+    pretty,
+    customImports: stableMapKey(customImports),
+  });
+  const cached = importMapJsonCache.get(cacheKey);
+  if (cached) return cached.json;
+
+  const json = stringifyImportMap(imports, pretty);
+  importMapJsonCache.set(cacheKey, { cacheKey, json });
+  return json;
+}
+
+export function clearImportMapCache(): void {
+  importMapJsonCache.clear();
 }
 
 export function shouldDisableLayout(frontmatter?: Record<string, unknown>): boolean {

package/src/src/integrations/remote-tools.ts

@@ -26,6 +26,10 @@ interface RemoteToolDefinition {
   inputSchema: Record<string, unknown>;
 }
 
+interface CallToolTextContent {
+  text?: string;
+}
+
 // ---------------------------------------------------------------------------
 // Per-request token resolution
 // ---------------------------------------------------------------------------
@@ -50,19 +54,27 @@ function resolveRequestToken(): string | undefined {
   return getApiTokenEnv();
 }
 
-function resolveApiBaseUrl(): string | undefined {
-  return getApiBaseUrlEnv();
-}
-
 // ---------------------------------------------------------------------------
 // API communication
 // ---------------------------------------------------------------------------
 
+function joinCallToolText(content: CallToolTextContent[]): string {
+  return content.map((item) => item.text).join("\n");
+}
+
+function parseJsonText(text: string): unknown | undefined {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return undefined;
+  }
+}
+
 async function fetchToolList(
   baseUrl: string,
   token: string,
 ): Promise<RemoteToolDefinition[]> {
-  const res = await dntShim.fetch(`${baseUrl}/integrations/tools/list`, {
+  const response = await dntShim.fetch(`${baseUrl}/integrations/tools/list`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
@@ -70,14 +82,14 @@ async function fetchToolList(
     },
   });
 
-  if (!res.ok) {
+  if (!response.ok) {
     logger.warn("Failed to fetch integration tools from API", {
-      status: res.status,
+      status: response.status,
     });
     return [];
   }
 
-  const data = (await res.json()) as { tools: RemoteToolDefinition[] };
+  const data = (await response.json()) as { tools: RemoteToolDefinition[] };
   return data.tools ?? [];
 }
 
@@ -88,7 +100,7 @@ async function callRemoteTool(
   args: Record<string, unknown>,
   endUserId?: string,
 ): Promise<unknown> {
-  const res = await dntShim.fetch(`${baseUrl}/integrations/tools/call`, {
+  const response = await dntShim.fetch(`${baseUrl}/integrations/tools/call`, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
@@ -101,37 +113,27 @@ async function callRemoteTool(
     }),
   });
 
-  if (!res.ok) {
-    const text = await res.text();
-    return { error: "api_error", status: res.status, message: text };
+  if (!response.ok) {
+    const text = await response.text();
+    return { error: "api_error", status: response.status, message: text };
   }
 
-  const result = await res.json();
+  const result = await response.json();
 
   // If MCP CallToolResult format, extract content
   if (result?.content && Array.isArray(result.content)) {
+    const text = joinCallToolText(result.content as CallToolTextContent[]);
+
     if (result.isError) {
-      const errorText = result.content
-        .map((c: { text?: string }) => c.text)
-        .join("\n");
       // Try to preserve structured error data (e.g., authentication_required with connectUrl)
-      try {
-        const parsed = JSON.parse(errorText);
-        if (parsed && typeof parsed === "object") return parsed;
-      } catch {
-        // Not JSON
-      }
-      return { error: "tool_error", message: errorText };
+      const parsed = parseJsonText(text);
+      if (parsed && typeof parsed === "object") return parsed;
+      return { error: "tool_error", message: text };
     }
+
     if (result.structuredContent) return result.structuredContent;
-    const text = result.content
-      .map((c: { text?: string }) => c.text)
-      .join("\n");
-    try {
-      return JSON.parse(text);
-    } catch {
-      return text;
-    }
+
+    return parseJsonText(text) ?? text;
   }
 
   return result;
@@ -152,7 +154,7 @@ async function callRemoteTool(
 export async function getRemoteIntegrationToolDefinitions(): Promise<
   ToolDefinition[]
 > {
-  const baseUrl = resolveApiBaseUrl();
+  const baseUrl = getApiBaseUrlEnv();
   const token = resolveRequestToken();
   if (!baseUrl || !token) return [];
 
@@ -190,7 +192,7 @@ export async function executeRemoteIntegrationTool(
   args: Record<string, unknown>,
   endUserId?: string,
 ): Promise<unknown> {
-  const baseUrl = resolveApiBaseUrl();
+  const baseUrl = getApiBaseUrlEnv();
   const token = resolveRequestToken();
   if (!baseUrl || !token) {
     return { error: "no_api_token", message: "No API token available" };
@@ -210,7 +212,7 @@ export async function syncIntegrationConfig(
   integrations: Record<string, { scope?: string; tools?: string[] }>,
 ): Promise<void> {
   try {
-    const res = await dntShim.fetch(`${apiBaseUrl}/integrations/config`, {
+    const response = await dntShim.fetch(`${apiBaseUrl}/integrations/config`, {
       method: "POST",
       headers: {
         Authorization: `Bearer ${apiToken}`,
@@ -219,12 +221,12 @@ export async function syncIntegrationConfig(
       body: JSON.stringify({ integrations }),
     });
 
-    if (!res.ok) {
+    if (!response.ok) {
       logger.warn("Failed to sync integration config to API", {
-        status: res.status,
+        status: response.status,
       });
     } else {
-      const data = (await res.json()) as { synced: number };
+      const data = (await response.json()) as { synced: number };
       logger.info("Synced integration config to API", { synced: data.synced });
     }
   } catch (err) {

package/src/src/internal-agents/ag-ui-sse.ts

@@ -20,7 +20,6 @@ export interface RunFinishedMetadata {
 export interface StreamTransformState {
   messageId: string | null;
   textOpen: boolean;
-  stepIndex: number;
   sawTerminalError: boolean;
   metadata: RunFinishedMetadata;
 }
@@ -29,7 +28,6 @@ export function createStreamTransformState(): StreamTransformState {
   return {
     messageId: null,
     textOpen: false,
-    stepIndex: 0,
     sawTerminalError: false,
     metadata: {},
   };
@@ -68,12 +66,6 @@ const agUiEventPayloadSchemas = {
     result: z.unknown(),
     isError: z.boolean().optional(),
   }),
-  StepStarted: z.object({
-    stepIndex: z.number().int().positive(),
-  }),
-  StepFinished: z.object({
-    stepIndex: z.number().int().positive(),
-  }),
   RunError: z.object({
     code: z.string().min(1).optional(),
     message: z.string().min(1),
@@ -267,17 +259,10 @@ export function mapRuntimeEventToAgUi(
       }];
 
     case "step-start":
-      state.stepIndex += 1;
-      return [{
-        event: "StepStarted",
-        payload: { stepIndex: state.stepIndex },
-      }];
+      return [];
 
     case "step-end":
-      return [{
-        event: "StepFinished",
-        payload: { stepIndex: state.stepIndex },
-      }];
+      return [];
 
     case "data":
       applyDataMetadata(state, event);

package/src/src/internal-agents/control-plane-auth.ts

@@ -27,6 +27,13 @@ export function getControlPlaneVerificationPublicKey(ctx: HandlerContext): strin
     getHostEnv("CHANNEL_DISPATCH_SIGNING_PUBLIC_KEY");
 }
 
+function isControlPlaneVerificationError(error: unknown): boolean {
+  return error instanceof Error && (
+    error.message.includes("Control-plane") ||
+    error.message.includes("Unsupported")
+  );
+}
+
 export async function verifyControlPlaneRequest(
   req: dntShim.Request,
   ctx: HandlerContext,
@@ -64,12 +71,7 @@ export async function verifyControlPlaneRequest(
       maxAgeSeconds: MAX_CONTROL_PLANE_SIGNATURE_AGE_SECONDS,
     });
   } catch (error) {
-    const isAuthError = error instanceof Error && (
-      error.message.includes("Control-plane") ||
-      error.message.includes("Unsupported")
-    );
-
-    if (isAuthError) {
+    if (isControlPlaneVerificationError(error)) {
       logger.warn("Invalid control-plane signature", {
         error,
         projectSlug,

package/src/src/internal-agents/request-body.ts

@@ -18,6 +18,12 @@ export class InternalAgentRequestBodyTooLargeError extends Error {
   }
 }
 
+function isRequestBodyTooLargeError(error: unknown): error is VeryfrontError {
+  return error instanceof VeryfrontError &&
+    error.slug === "input-validation-failed" &&
+    error.detail === "Request body exceeds size limit";
+}
+
 export async function readInternalAgentRequestBody(
   request: dntShim.Request,
   maxBodyBytes = INTERNAL_AGENT_STREAM_MAX_BODY_BYTES,
@@ -29,11 +35,7 @@ export async function readInternalAgentRequestBody(
   try {
     return await readBodyWithLimit(request, maxBodyBytes);
   } catch (error) {
-    if (
-      error instanceof VeryfrontError &&
-      error.slug === "input-validation-failed" &&
-      error.detail === "Request body exceeds size limit"
-    ) {
+    if (isRequestBodyTooLargeError(error)) {
       throw new InternalAgentRequestBodyTooLargeError();
     }
 

package/src/src/internal-agents/session-manager.ts

@@ -66,7 +66,6 @@ const AGENT_RUN_SESSION_MANAGER_GLOBAL_KEY = "__veryfrontAgentRunSessionManager"
 type SessionStatus = "running" | "waiting" | "completed" | "cancelled" | "failed";
 
 interface SubmittedToolResult {
-  toolCallId: string;
   result: unknown;
   isError: boolean;
   key: string;
@@ -80,7 +79,6 @@ interface WaitingToolState {
 
 interface AgentRunSession {
   runId: string;
-  threadId: string;
   status: SessionStatus;
   abortController: AbortController;
   waitingTool: WaitingToolState | null;
@@ -167,6 +165,17 @@ export class AgentRunSessionManager {
     }
   }
 
+  private finalizeSession(
+    session: AgentRunSession,
+    status: Exclude<SessionStatus, "running" | "waiting">,
+  ): void {
+    session.status = status;
+    this.clearWaitingTimeout(session);
+    this.clearSessionTimeout(session);
+    session.waitingTool = null;
+    this.sessions.delete(session.runId);
+  }
+
   private get maxConcurrentSessions(): number {
     return this.options.maxConcurrentSessions ?? DEFAULT_MAX_CONCURRENT_SESSIONS;
   }
@@ -185,7 +194,6 @@ export class AgentRunSessionManager {
 
     const session: AgentRunSession = {
       runId: input.runId,
-      threadId: input.threadId,
       status: "running",
       abortController: new AbortController(),
       waitingTool: null,
@@ -266,7 +274,6 @@ export class AgentRunSessionManager {
     }
 
     const normalized: SubmittedToolResult = {
-      toolCallId: input.toolCallId,
       result: input.result,
       isError: Boolean(input.isError),
       key: createToolResultKey(input.result, Boolean(input.isError)),
@@ -311,34 +318,23 @@ export class AgentRunSessionManager {
       return false;
     }
 
-    session.status = "cancelled";
-    this.clearWaitingTimeout(session);
-    this.clearSessionTimeout(session);
+    const waitingTool = session.waitingTool;
     session.abortController.abort(new AgentRunCancelledError());
-    session.waitingTool?.reject(new AgentRunCancelledError());
-    session.waitingTool = null;
-    this.sessions.delete(runId);
+    waitingTool?.reject(new AgentRunCancelledError());
+    this.finalizeSession(session, "cancelled");
     return true;
   }
 
   completeRun(runId: string): void {
     const session = this.sessions.get(runId);
     if (!session) return;
-    session.status = "completed";
-    this.clearWaitingTimeout(session);
-    this.clearSessionTimeout(session);
-    session.waitingTool = null;
-    this.sessions.delete(runId);
+    this.finalizeSession(session, "completed");
   }
 
   failRun(runId: string): void {
     const session = this.sessions.get(runId);
     if (!session) return;
-    session.status = "failed";
-    this.clearWaitingTimeout(session);
-    this.clearSessionTimeout(session);
-    session.waitingTool = null;
-    this.sessions.delete(runId);
+    this.finalizeSession(session, "failed");
   }
 
   getRunStatus(runId: string): SessionStatus | null {