framer-dalton 0.0.24 → 0.0.26

package/dist/start-relay-server.js

@@ -2,6 +2,7 @@ import fs4 from 'fs';
 import os from 'os';
 import path from 'path';
 import 'child_process';
+import 'net';
 import { fileURLToPath } from 'url';
 import { createTRPCClient, httpLink } from '@trpc/client';
 import crypto, { randomUUID, timingSafeEqual } from 'crypto';
@@ -13,7 +14,7 @@ import { z } from 'zod';
 import { createRequire } from 'module';
 import * as vm from 'vm';
 
-/* @framer/ai relay server v0.0.24 */
+/* @framer/ai relay server v0.0.26 */
 var __defProp = Object.defineProperty;
 var __knownSymbol = (name2, symbol) => (symbol = Symbol[name2]) ? symbol : /* @__PURE__ */ Symbol.for("Symbol." + name2);
 var __typeError = (msg) => {
@@ -159,7 +160,7 @@ __name(debug, "debug");
 // src/version.ts
 var VERSION = (
   // typeof is used to ensure this can be used just via tsx or node etc. without build
-  "0.0.24" 
+  "0.0.26" 
 );
 
 // src/relay-client.ts
@@ -181,6 +182,35 @@ createTRPCClient({
   ]
 });
 
+// src/agent-thread-context.ts
+var MAX_AGENT_THREAD_ID_LENGTH = 256;
+var MAX_AGENT_PROVIDER_LENGTH = 64;
+var SAFE_VALUE_PATTERN = /^[A-Za-z0-9._:-]+$/;
+function normalizeValue(value, maxLength) {
+  const trimmed = value?.trim();
+  if (!trimmed) return void 0;
+  if (trimmed.length > maxLength) return void 0;
+  if (!SAFE_VALUE_PATTERN.test(trimmed)) return void 0;
+  return trimmed;
+}
+__name(normalizeValue, "normalizeValue");
+function normalizeAgentThreadContext(input) {
+  const agentThreadId = normalizeValue(
+    input.agentThreadId,
+    MAX_AGENT_THREAD_ID_LENGTH
+  );
+  if (!agentThreadId) return {};
+  const agentProvider = normalizeValue(
+    input.agentProvider,
+    MAX_AGENT_PROVIDER_LENGTH
+  );
+  return {
+    agentThreadId,
+    ...agentProvider ? { agentProvider } : {}
+  };
+}
+__name(normalizeAgentThreadContext, "normalizeAgentThreadContext");
+
 // src/connection-errors.ts
 var CONNECTION_ERROR_PATTERNS = [
   "Connection closed",
@@ -197,8 +227,15 @@ var CONNECTION_ERROR_PATTERNS = [
   // Our own check in executor.ts
   "Execution timed out after",
   // Likely dead connection
-  "Session expired"
+  "Session expired",
   // Server-side session expiry
+  // Typed page-death (PROJECT_CLOSED) for the string fallback; isRetryableError is the primary path.
+  "Project session crashed",
+  // PageCrashedError (renderer crash / OOM)
+  "Project was closed",
+  // StaleSessionError (page closed/reaped)
+  "Session was recycled"
+  // SessionRecycledError (destroy->respawn reconnect race)
 ];
 function isConnectionError(errorMessage) {
   return CONNECTION_ERROR_PATTERNS.some(
@@ -206,6 +243,18 @@ function isConnectionError(errorMessage) {
   );
 }
 __name(isConnectionError, "isConnectionError");
+function isRetryableError(err) {
+  if (err && typeof err === "object") {
+    const e = err;
+    if (e.retryable === true) return true;
+    if (e.code === "PROJECT_CLOSED") return true;
+    if (typeof e.message === "string" && isConnectionError(e.message))
+      return true;
+    return false;
+  }
+  return typeof err === "string" && isConnectionError(err);
+}
+__name(isRetryableError, "isRetryableError");
 var AUTH_ERROR_PATTERNS = ["does not have access", "UNAUTHORIZED"];
 function isAuthError(errorMessage) {
   return AUTH_ERROR_PATTERNS.some((p) => errorMessage.includes(p));
@@ -540,20 +589,37 @@ async function execute(session, code, options = {}) {
     return { output };
   } catch (err) {
     const errorMessage = err instanceof Error ? err.message : String(err);
-    if (isConnectionError(errorMessage)) {
+    const retryable = isRetryableError(err);
+    if (retryable || isConnectionError(errorMessage)) {
       session.connection.markDisconnected();
     }
     const errorRef = getErrorRef(err);
     return {
       output,
       error: errorMessage,
-      ...errorRef ? { errorRef } : {}
+      ...errorRef ? { errorRef } : {},
+      ...retryable ? { retryable: true } : {}
     };
   } finally {
     if (timeoutId) clearTimeout(timeoutId);
   }
 }
 __name(execute, "execute");
+function isReconnectable(err) {
+  return isRetryableError(err) || isConnectionError(err instanceof Error ? err.message : String(err));
+}
+__name(isReconnectable, "isReconnectable");
+function connectionFailureResult(prefix, err) {
+  const inner = err instanceof Error ? err.message : String(err);
+  const errorRef = getErrorRef(err);
+  return {
+    output: [],
+    error: `${prefix}: ${inner}`,
+    ...errorRef ? { errorRef } : {},
+    ...isRetryableError(err) ? { retryable: true } : {}
+  };
+}
+__name(connectionFailureResult, "connectionFailureResult");
 async function executeWithReconnect(session, code, options, execId) {
   if (!session.connection.isConnected()) {
     log(
@@ -562,17 +628,27 @@ async function executeWithReconnect(session, code, options, execId) {
     try {
       await session.connection.reconnect();
     } catch (err) {
-      const inner = err instanceof Error ? err.message : String(err);
-      const errorRef = getErrorRef(err);
-      return {
-        output: [],
-        error: `Failed to get connection for session: ${inner}`,
-        ...errorRef ? { errorRef } : {}
-      };
+      if (!isReconnectable(err)) {
+        return connectionFailureResult(
+          "Failed to get connection for session",
+          err
+        );
+      }
+      log(
+        `exec.reconnect.retry exec=${execId} session=${session.id} reason="${err instanceof Error ? err.message : String(err)}"`
+      );
+      try {
+        await session.connection.reconnect();
+      } catch (err2) {
+        return connectionFailureResult(
+          "Failed to get connection for session",
+          err2
+        );
+      }
     }
   }
   const result = await execute(session, code, options);
-  if (!result.error || !isConnectionError(result.error)) {
+  if (!result.error || !(result.retryable || isConnectionError(result.error))) {
     return result;
   }
   log(
@@ -581,16 +657,13 @@ async function executeWithReconnect(session, code, options, execId) {
   try {
     await session.connection.reconnect();
   } catch (err) {
-    const inner = err instanceof Error ? err.message : String(err);
-    const errorRef = getErrorRef(err);
     log(
-      `reconnect.failed exec=${execId} session=${session.id} req=${session.connection.framer.requestId} error="${inner}"`
+      `reconnect.failed exec=${execId} session=${session.id} req=${session.connection.framer.requestId} error="${err instanceof Error ? err.message : String(err)}"`
+    );
+    return connectionFailureResult(
+      "Connection lost and failed to reconnect",
+      err
     );
-    return {
-      output: [],
-      error: `Connection lost and failed to reconnect: ${inner}`,
-      ...errorRef ? { errorRef } : {}
-    };
   }
   log(
     `reconnect.success exec=${execId} session=${session.id} req=${session.connection.framer.requestId}`
@@ -896,10 +969,11 @@ var Connection = class _Connection {
       headlessServerUrl: this.headlessServerUrl
     }));
   }
-  createSession(id) {
+  createSession(id, agentThreadContext) {
     const session = {
       id,
       state: {},
+      agentThreadContext,
       lastActivityAt: Date.now(),
       inflight: 0,
       connection: this
@@ -970,14 +1044,17 @@ var SessionManager = class {
   }
   connections = [];
   idleCheck = null;
-  async create(projectId, userId, apiKey, headlessServerUrl) {
+  async create(projectId, userId, apiKey, headlessServerUrl, agentThreadContext = {}) {
     const connection = await this.findOrCreateConnection(
       projectId,
       userId,
       apiKey,
       headlessServerUrl
     );
-    const session = connection.createSession(this.getNextSessionId());
+    const session = connection.createSession(
+      this.getNextSessionId(),
+      agentThreadContext
+    );
     this.startIdleCheck();
     return session;
   }
@@ -1007,6 +1084,7 @@ var SessionManager = class {
         projectId: session.connection.projectId,
         userId: session.connection.userId,
         sessionId: session.connection.getServerSessionId(),
+        ...session.agentThreadContext,
         durationMs,
         hasError: result.error !== void 0,
         ...result.error ? { errorMessage: result.error } : {}
@@ -1047,7 +1125,8 @@ var SessionManager = class {
     trackSessionDestroy({
       projectId: session.connection.projectId,
       userId: session.connection.userId,
-      sessionId: session.connection.getServerSessionId()
+      sessionId: session.connection.getServerSessionId(),
+      ...session.agentThreadContext
     });
     session.connection.removeSession(id);
     if (!session.connection.hasSessions()) {
@@ -1201,16 +1280,20 @@ var appRouter = t.router({
       projectId: z.string(),
       apiKey: z.string(),
       userId: z.string().optional(),
-      headlessServerUrl: z.string()
+      headlessServerUrl: z.string(),
+      agentThreadId: z.string().optional(),
+      agentProvider: z.string().optional()
     })
   ).mutation(async ({ input }) => {
     const start = performance.now();
+    const agentThreadContext = normalizeAgentThreadContext(input);
     try {
       const session = await sessionManager.create(
         input.projectId,
         input.userId,
         input.apiKey,
-        input.headlessServerUrl
+        input.headlessServerUrl,
+        agentThreadContext
       );
       log(
         `session.new id=${session.id} project=${input.projectId} headlessServerUrl=${input.headlessServerUrl}`
@@ -1219,6 +1302,7 @@ var appRouter = t.router({
         projectId: input.projectId,
         userId: session.connection.userId,
         sessionId: session.connection.getServerSessionId(),
+        ...session.agentThreadContext,
         durationMs: Math.round(performance.now() - start)
       });
       return { id: session.id };
@@ -1228,6 +1312,7 @@ var appRouter = t.router({
         errorType: "session_create_error",
         projectId: input.projectId,
         userId: input.userId,
+        ...agentThreadContext,
         errorMessage: message
       });
       throw new TRPCError({

package/docs/skills/framer-code-components.md

@@ -1,6 +1,6 @@
 ---
 name: framer-code-components
-description: "Framer code component implementation guidance, platform constraints, layout annotations, property controls, and authoring best practices. Use only after loading the framer skill first in the same task; never load this skill directly as the entry point."
+description: "Framer code component implementation guidance, platform constraints, layout annotations, property controls, and authoring best practices. Use only after loading the framer skill and the generated framer-project-<projectId> skill first in the same task; never load this skill directly as the entry point."
 ---
 
 # Framer Code Components