@frankieai/server 0.2.2 → 0.2.3

package/dist/{chunk-JOADNB5J.js → chunk-MKN5663J.js}

@@ -482,8 +482,9 @@ async function buildApiTools(options) {
 }
 async function buildOne(source, options) {
   const doc = await loadSpec(source.spec, options.fetchImpl);
+  const clientMode = source.execution === "client";
   const baseUrl = (source.baseUrl ?? specBaseUrl(doc))?.replace(/\/+$/, "");
-  if (!baseUrl) {
+  if (!baseUrl && !clientMode) {
     throw new OpenApiError(
       `API "${source.name}" needs a baseUrl: its spec declares no \`servers\` entry to fall back to.`
     );
@@ -508,7 +509,7 @@ async function buildOne(source, options) {
       const body = collectRequestBody(doc, operation);
       const { headers: securedHeaders, query: securityQuery } = applySecurity(doc, source, operation, schemes);
       const headers = buildForwardedHeaders({ ...source, headers: securedHeaders }, options.session);
-      const opBaseUrl = resolveOperationBaseUrl(source, doc, item, operation, baseUrl);
+      const opBaseUrl = resolveOperationBaseUrl(source, doc, item, operation, baseUrl ?? "");
       tools.push({
         name,
         label: describeTool(name, {}),
@@ -517,6 +518,27 @@ async function buildOne(source, options) {
 ${retrySafetyNote(method, doc, item, operation)}`,
         parameters: Type.Unsafe(toolSchema(params, body)),
         async execute(_id, args, signal) {
+          if (clientMode && options.clientBridge?.available) {
+            const clientInput = isRecord(args) ? args : {};
+            const relPath = buildRelativePath(path, params, clientInput);
+            const clientBody = body ? clientInput["body"] : void 0;
+            const result = await options.clientBridge.execute(
+              name,
+              {
+                source: source.name,
+                method: method.toUpperCase(),
+                path: relPath,
+                ...clientBody !== void 0 ? { body: clientBody } : {}
+              },
+              signal ?? AbortSignal.timeout(source.timeoutMs)
+            );
+            return formatClientResult(operationId, result, source, options.session);
+          }
+          if (!opBaseUrl) {
+            throw new Error(
+              `"${operationId}" runs in the user's browser and has no server base URL, so it can't run over the hosted MCP endpoint or a headless caller. Set a baseUrl (and a user-token forwarding header) to expose it that way too. Report this to the user.`
+            );
+          }
           const input = enforceIdentityParams(params, isRecord(args) ? args : {}, options.session);
           const url = buildUrl(opBaseUrl, path, params, input, securityQuery);
           const rawBody = body ? input["body"] : void 0;
@@ -531,7 +553,7 @@ ${retrySafetyNote(method, doc, item, operation)}`,
             ...requestBody !== void 0 ? { body: JSON.stringify(requestBody) } : {},
             signal: signal ?? AbortSignal.timeout(source.timeoutMs)
           });
-          const text = redactSecrets(truncate(await response.text().catch(() => ""), source.maxResponseChars), source, options.session);
+          const text = truncate(redactSecrets(await response.text().catch(() => ""), source, options.session), source.maxResponseChars);
           if (!response.ok) {
             const detail = `${operationId} failed with HTTP ${response.status}: ${truncate(text, 400)}`;
             throw new Error(
@@ -691,6 +713,42 @@ function buildUrl(baseUrl, path, params, input, extraQuery = {}) {
   }
   return url.toString();
 }
+function buildRelativePath(path, params, input) {
+  let resolved = path;
+  for (const param of params) {
+    if (param.location !== "path") continue;
+    resolved = resolved.replace(`{${param.name}}`, encodeURIComponent(String(input[param.name] ?? "")));
+  }
+  const query = new URLSearchParams();
+  for (const param of params) {
+    if (param.location !== "query") continue;
+    const value = input[param.name];
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      for (const entry of value) query.append(param.name, String(entry));
+    } else {
+      query.set(param.name, String(value));
+    }
+  }
+  const rel = resolved.startsWith("/") ? resolved.slice(1) : resolved;
+  const qs = query.toString();
+  return qs ? `${rel}?${qs}` : rel;
+}
+function formatClientResult(operationId, result, source, session) {
+  if (result.error) {
+    throw new Error(
+      `${operationId} could not be reached from the browser: ${truncate(result.error, 300)}. Report this to the user.`
+    );
+  }
+  const text = truncate(redactSecrets(result.body ?? "", source, session), source.maxResponseChars);
+  if (result.status < 200 || result.status >= 300) {
+    const detail = `${operationId} failed with HTTP ${result.status}: ${truncate(text, 400)}`;
+    throw new Error(
+      result.status === 401 || result.status === 403 ? `${detail} (authentication/authorization failure). Do not retry by guessing or supplying a different resource ID, header, or credential \u2014 that will not fix an authentication failure. Report the exact error to the user.` : detail
+    );
+  }
+  return { content: [{ type: "text", text: text || "(empty response)" }], details: null };
+}
 function describeOperation(operation, method, path) {
   const summary = typeof operation["summary"] === "string" ? operation["summary"] : "";
   const description = typeof operation["description"] === "string" ? operation["description"] : "";
@@ -766,7 +824,11 @@ function asArray(value) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var IDENTITY_FIELD_PATTERN = /^(user|owner|account|customer|author|created_?by)[_-]?id$/i;
+var IDENTITY_ACTOR = "user|owner|account|customer|author|member|assignee|principal|editor|creator|created_?by|updated_?by|modified_?by";
+var IDENTITY_FIELD_PATTERN = new RegExp(
+  `^(?:(?:${IDENTITY_ACTOR})[_-]?id|owner|author|assignee|actor|principal|creator|created_?by|on[_-]?behalf[_-]?of)$`,
+  "i"
+);
 function enforceServerDerivedIdentity(body, session) {
   return enforceIdentityDeep(body, session);
 }
@@ -775,7 +837,7 @@ function enforceIdentityDeep(value, session) {
   if (!isRecord(value)) return value;
   const next = {};
   for (const [key, inner] of Object.entries(value)) {
-    if (IDENTITY_FIELD_PATTERN.test(key)) {
+    if (IDENTITY_FIELD_PATTERN.test(key) && !isRecord(inner) && !Array.isArray(inner)) {
       if (session.user.anonymous) continue;
       next[key] = session.user.id;
     } else {
@@ -830,7 +892,7 @@ async function connectMcpTools(options) {
         if (result.server.selectedTools && !result.server.selectedTools.includes(tool.name)) continue;
         const name = `${MCP_TOOL_PREFIX}${result.server.name}__${tool.name}`;
         if (!evaluateToolPolicy2(name, options.policy).allowed) continue;
-        tools.push(adaptTool(name, tool, result.client, options.callTimeoutMs));
+        tools.push(adaptTool(name, tool, result.client, result.server, options.session, options.callTimeoutMs));
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
@@ -863,7 +925,34 @@ async function connectOne(server, options) {
   }
   return client;
 }
-function adaptTool(name, tool, client, callTimeoutMs = 6e4) {
+function mcpSecrets(server, session) {
+  const secrets = [];
+  for (const value of Object.values(server.headers ?? {})) {
+    if (!value) continue;
+    secrets.push(value);
+    secrets.push(Buffer.from(value, "utf8").toString("base64"));
+  }
+  if (session?.userToken) secrets.push(session.userToken);
+  return secrets.sort((a, b) => b.length - a.length);
+}
+function redactString(text, secrets) {
+  let out = text;
+  for (const value of secrets) out = out.split(value).join("[redacted]");
+  return out;
+}
+function redactDeep(value, secrets) {
+  if (typeof value === "string") return redactString(value, secrets);
+  if (Array.isArray(value)) return value.map((entry) => redactDeep(entry, secrets));
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, redactDeep(v, secrets)]));
+  }
+  return value;
+}
+function redactContent(content, secrets) {
+  return content.map((block) => block.type === "text" ? { ...block, text: redactString(block.text, secrets) } : block);
+}
+function adaptTool(name, tool, client, server, session, callTimeoutMs = 6e4) {
+  const secrets = mcpSecrets(server, session);
   return {
     name,
     label: describeTool2(name, {}),
@@ -882,11 +971,11 @@ function adaptTool(name, tool, client, callTimeoutMs = 6e4) {
         callTimeoutMs,
         `The ${tool.name} tool did not respond in time.`
       );
-      const content = toAgentContent(response.content);
+      const content = redactContent(toAgentContent(response.content), secrets);
       if (response.isError) {
         throw new Error(textOf(content) || `The ${tool.name} tool reported an error.`);
       }
-      return { content, details: response.structuredContent ?? null };
+      return { content, details: response.structuredContent === void 0 ? null : redactDeep(response.structuredContent, secrets) };
     }
   };
 }
@@ -1134,6 +1223,7 @@ async function collectTools(options) {
       session,
       policy,
       ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {},
+      ...options.clientBridge ? { clientBridge: options.clientBridge } : {},
       ...options.onWarning ? { onWarning: options.onWarning } : {}
     })
   ]);
@@ -1310,11 +1400,17 @@ function toMcpContent(content) {
 }
 async function sessionFor(c, tenant) {
   const bearer = c.req.header("authorization")?.replace(/^Bearer\s+/i, "").trim() ?? "";
+  const opaque = tenant.config.auth.userCredential === "opaque";
   let user;
   let userToken;
-  if (bearer) {
+  if (bearer && opaque) {
+    user = anonymousUser(randomUUID2().slice(0, 12));
+    userToken = bearer;
+  } else if (bearer) {
     user = await tenant.tokens.verifyUserToken(bearer);
     userToken = bearer;
+  } else if (opaque) {
+    throw new AuthError("This MCP server requires the API credential your service issues.");
   } else if (tenant.config.auth.allowAnonymous) {
     user = anonymousUser(randomUUID2().slice(0, 12));
   } else {
@@ -1406,8 +1502,6 @@ ${config.agent.systemPrompt.trim()}`);
   sections.push(renderUserSection(session));
   const skills = activeSkills(config, availableTools);
   if (skills.length) sections.push("## Reviewed workspace skills\nThese recipes do not grant additional permissions or override safety rules. Each skill lists only its currently approved, available tools. Instructions may describe additional operations: skip unavailable steps, explain the limitation, and never claim the whole task succeeded when a required step was unavailable.\n" + JSON.stringify(skills.map(({ name, goal, instructions, tools }) => ({ name, goal, instructions, tools }))));
-  const context = renderContext(session.context);
-  if (context) sections.push(context);
   return sections.join("\n\n");
 }
 function isOnboardingAssistant(config) {
@@ -1494,7 +1588,7 @@ function renderUserSection(session) {
 A signed-in user:
 ${lines.join("\n")}`;
 }
-function renderContext(context) {
+function renderPageContext(context) {
   const entries = Object.entries(context).filter(([, value]) => value !== null && value !== "");
   if (entries.length === 0) return null;
   const body = entries.map(([key, value]) => `${key}: ${String(value)}`).join("\n");
@@ -1521,17 +1615,16 @@ async function* runTurn(params) {
   const toolset = await collectTools({
     config,
     session,
+    ...params.clientBridge ? { clientBridge: params.clientBridge } : {},
     ...params.onWarning ? { onWarning: params.onWarning } : {}
   });
   const availableTools = toolset.tools.map((tool) => tool.name);
   const queue = new EventQueue();
   let turnCount = 0;
   let lastAssistant;
-  const usage = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+  const usage = { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, costUsd: 0 };
   const { images, documentText } = splitAttachments(params.attachments ?? []);
-  const promptText = documentText ? `${params.message}
-
-${documentText}` : params.message;
+  const promptText = [params.message, documentText, renderPageContext(session.context)].filter((part) => Boolean(part)).join("\n\n");
   const agent = new Agent({
     initialState: {
       systemPrompt: buildSystemPrompt(config, session, availableTools),
@@ -1545,7 +1638,13 @@ ${documentText}` : params.message;
     streamFn: (model, context, options) => params.models.streamSimple(model, context, {
       ...options,
       maxTokens: config.model.maxTokens,
-      temperature: config.model.temperature
+      temperature: config.model.temperature,
+      // Ask for prompt caching explicitly rather than relying on the library
+      // default (which an env var can silently turn off). With the session id
+      // the agent already carries, providers that cache by replica affinity
+      // route every turn of a conversation to the same warm replica, and
+      // Anthropic-style providers get cache_control markers on the prefix.
+      cacheRetention: "short"
     }),
     getApiKey: () => params.apiKey,
     sessionId: session.id,
@@ -1576,10 +1675,18 @@ ${documentText}` : params.message;
       usage.inputTokens += event.message.usage.input;
       usage.outputTokens += event.message.usage.output;
       usage.costUsd += event.message.usage.cost?.total ?? 0;
+      usage.cacheReadTokens += event.message.usage.cacheRead ?? 0;
+      usage.cacheWriteTokens += event.message.usage.cacheWrite ?? 0;
     }
   });
   const onAbort = () => agent.abort();
   params.signal.addEventListener("abort", onAbort, { once: true });
+  let transcriptSaved = false;
+  const saveTranscript = () => {
+    if (transcriptSaved) return;
+    transcriptSaved = true;
+    params.onTranscript?.(stripReasoningFromMessages(agent.state.messages));
+  };
   const run = agent.prompt(promptText, images.length ? images : void 0).then(() => void 0).catch((error) => {
     queue.push({
       type: "error",
@@ -1593,13 +1700,16 @@ ${documentText}` : params.message;
     yield { type: "tools_active", apis: toolset.apis };
     for await (const event of queue) yield event;
     await run;
-    params.onTranscript?.(stripReasoningFromMessages(agent.state.messages));
+    saveTranscript();
     yield {
       type: "turn_end",
       stopReason: stopReasonFor(params.signal, turnCount, config, lastAssistant),
       ...lastAssistant ? { usage } : {}
     };
   } finally {
+    if (!params.signal.aborted) agent.abort();
+    await run;
+    saveTranscript();
     params.signal.removeEventListener("abort", onAbort);
     unsubscribe();
     await toolset.close();
@@ -1810,7 +1920,7 @@ var EventQueue = class {
 };
 
 // src/app.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { Hono as Hono3 } from "hono";
 
 // src/guide.ts
@@ -1904,6 +2014,91 @@ function createGuideApp() {
   return app;
 }
 
+// src/agent/client-tools.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var ClientToolChannel = class {
+  emitters = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  /** Bind the SSE emitter for a session at the start of its turn. */
+  bindSession(sessionId, emit) {
+    this.emitters.set(sessionId, emit);
+  }
+  /**
+   * Drop a session's emitter at turn end and fail any calls still waiting on the
+   * browser — the stream that would deliver their answer is gone.
+   */
+  releaseSession(sessionId) {
+    this.emitters.delete(sessionId);
+    for (const [key, entry] of this.pending) {
+      if (!key.startsWith(`${sessionId}::`)) continue;
+      this.pending.delete(key);
+      entry.timer && clearTimeout(entry.timer);
+      entry.cleanup();
+      entry.reject(new Error("The chat stream closed before the browser returned a tool result."));
+    }
+  }
+  /** A bridge scoped to one session and turn timeout, handed to the tool builder. */
+  bridge(sessionId, defaultTimeoutMs) {
+    const channel = this;
+    return {
+      get available() {
+        return channel.emitters.has(sessionId);
+      },
+      execute(name, request, signal) {
+        return channel.request(sessionId, name, request, defaultTimeoutMs, signal);
+      }
+    };
+  }
+  request(sessionId, name, request, timeoutMs, signal) {
+    const emit = this.emitters.get(sessionId);
+    if (!emit) {
+      return Promise.reject(
+        new Error(
+          `"${name}" runs in the user's browser, but this session has no live browser channel (for example the hosted MCP endpoint or a headless caller). Report this to the user.`
+        )
+      );
+    }
+    const callId = randomUUID3();
+    const key = `${sessionId}::${callId}`;
+    return new Promise((resolve2, reject) => {
+      const onAbort = () => {
+        this.pending.delete(key);
+        clearTimeout(timer);
+        cleanup();
+        reject(new Error("The turn was aborted before the browser returned a tool result."));
+      };
+      const cleanup = () => signal?.removeEventListener("abort", onAbort);
+      const timer = setTimeout(() => {
+        this.pending.delete(key);
+        cleanup();
+        reject(new Error("The browser did not return a tool result in time."));
+      }, timeoutMs);
+      if (signal?.aborted) {
+        clearTimeout(timer);
+        reject(new Error("The turn was already aborted."));
+        return;
+      }
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.pending.set(key, { resolve: resolve2, reject, timer, cleanup });
+      emit({ type: "tool_call_request", callId, toolUseId: callId, name, request });
+    });
+  }
+  /**
+   * Deliver a browser's outcome to the waiting call. Returns false when no call
+   * is pending for this (session, callId) — a duplicate, late, or forged result.
+   */
+  resolve(sessionId, callId, result) {
+    const key = `${sessionId}::${callId}`;
+    const entry = this.pending.get(key);
+    if (!entry) return false;
+    this.pending.delete(key);
+    clearTimeout(entry.timer);
+    entry.cleanup();
+    entry.resolve(result);
+    return true;
+  }
+};
+
 // src/app.ts
 var HEARTBEAT_MS = 15e3;
 function createFrankieApp(options) {
@@ -1913,6 +2108,7 @@ function createFrankieApp(options) {
   const registry = options.resolved ? TenantRegistry.single(options.resolved) : options.tenants instanceof TenantRegistry ? options.tenants : new TenantRegistry(options.tenants);
   const sessions = options.sessions ?? new MemorySessionStore();
   const limiter = options.rateLimiter ?? new MemoryRateLimiter();
+  const clientTools = new ClientToolChannel();
   const log = options.logger ?? ((event) => console.log(JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...event })));
   const app = new Hono3();
   app.get("/healthz", (c) => c.json({ ok: true }));
@@ -1924,6 +2120,7 @@ function createFrankieApp(options) {
       if (origin) setCors(c, origin);
       return c.body(null, 204);
     }
+    if (origin) setCors(c, origin);
     const key = c.req.header("x-frankie-key") ?? "";
     let tenant;
     try {
@@ -1942,7 +2139,6 @@ function createFrankieApp(options) {
     if (origin && !isOriginAllowed(origin, tenant.config.auth.allowedOrigins)) {
       return jsonError(c, 403, "forbidden_origin", `Origin ${origin} is not allowed for this tenant.`);
     }
-    if (origin) setCors(c, origin);
     c.set("tenant", tenant);
     await next();
     return;
@@ -1971,7 +2167,10 @@ function createFrankieApp(options) {
         },
         modelPicker: {
           enabled: config.features.modelPicker.enabled,
-          models: config.features.modelPicker.models.map((entry) => ({ id: entry.id, label: entry.label }))
+          // The workspace default is always selectable, so enabling the picker
+          // shows a working selector even before any extra models are curated —
+          // otherwise an enabled picker with an empty list renders nothing.
+          models: publicPickerModels(config)
         }
       }
     };
@@ -1990,7 +2189,7 @@ function createFrankieApp(options) {
       if (body.userToken) {
         user = await tokens.verifyUserToken(body.userToken);
       } else if (config.auth.allowAnonymous) {
-        user = anonymousUser(randomUUID3().slice(0, 12));
+        user = anonymousUser(randomUUID4().slice(0, 12));
       } else {
         return jsonError(c, 401, "unauthorized", "This assistant requires a signed-in user.");
       }
@@ -2177,19 +2376,21 @@ function createFrankieApp(options) {
     if (config.agent.maxBudgetUsd && session.costUsd >= config.agent.maxBudgetUsd) {
       return jsonError(c, 402, "budget_exceeded", "This conversation has reached its limit.");
     }
-    if (body.context) {
-      await sessions.update(session.id, { context: { ...session.context, ...sanitizeContext(body.context) } });
-    }
-    await sessions.update(session.id, {
+    const patch = {
       busy: true,
       messageCount: session.messageCount + 1,
+      ...body.context ? { context: { ...session.context, ...sanitizeContext(body.context) } } : {},
       ...!session.title ? { title: titleFromText(body.message) } : {}
-    });
+    };
+    await sessions.update(session.id, patch);
+    const current = { ...session, ...patch };
     const abort = new AbortController();
     const timeout = setTimeout(() => abort.abort(), config.limits.turnTimeoutMs);
     c.req.raw.signal?.addEventListener("abort", () => abort.abort());
     const modelOverride = body.model && body.model !== config.model.model && config.features.modelPicker.enabled ? resolveModelChoice(models, config, body.model) ?? void 0 : void 0;
-    const current = await sessions.get(session.id) ?? session;
+    let finalMessages;
+    let turnCostUsd = 0;
+    const clientBridge = clientTools.bridge(session.id, config.limits.turnTimeoutMs);
     const events = runTurn({
       config,
       session: current,
@@ -2197,11 +2398,12 @@ function createFrankieApp(options) {
       apiKey: secrets.providerApiKey,
       model,
       models,
+      clientBridge,
       ...modelOverride ? { modelOverride } : {},
       ...attachments.length ? { attachments } : {},
       signal: abort.signal,
       onTranscript: (messages) => {
-        void sessions.update(session.id, { messages });
+        finalMessages = messages;
       },
       onWarning: (event, detail) => log({ level: "warn", event, sessionId: session.id, ...detail })
     });
@@ -2214,14 +2416,13 @@ function createFrankieApp(options) {
 `));
         };
         const heartbeat = setInterval(() => send({ type: "ping" }), HEARTBEAT_MS);
+        clientTools.bindSession(session.id, send);
         send({ type: "session", sessionId: session.id, resumed: current.messages.length > 0 });
         try {
           for await (const event of events) {
-            if (event.type === "turn_end" && event.usage?.costUsd !== void 0) {
-              const latest = await sessions.get(session.id);
-              await sessions.update(session.id, {
-                costUsd: (latest?.costUsd ?? current.costUsd) + event.usage.costUsd
-              });
+            if (event.type === "turn_end" && event.usage) {
+              if (event.usage.costUsd !== void 0) turnCostUsd += event.usage.costUsd;
+              log({ level: "info", event: "turn_usage", sessionId: session.id, ...event.usage });
             }
             send(event);
           }
@@ -2236,14 +2437,18 @@ function createFrankieApp(options) {
         } finally {
           clearInterval(heartbeat);
           clearTimeout(timeout);
-          await sessions.update(session.id, { busy: false });
+          clientTools.releaseSession(session.id);
+          await sessions.update(session.id, {
+            busy: false,
+            ...finalMessages ? { messages: finalMessages } : {},
+            ...turnCostUsd ? { costUsd: current.costUsd + turnCostUsd } : {}
+          });
           controller.close();
         }
       },
       cancel() {
         clearTimeout(timeout);
         abort.abort();
-        void sessions.update(session.id, { busy: false });
       }
     });
     const origin = c.req.header("origin");
@@ -2257,13 +2462,46 @@ function createFrankieApp(options) {
       }
     });
   });
+  app.post("/v1/chat/tool-result", async (c) => {
+    const { tokens } = c.get("tenant");
+    const bearer = c.req.header("authorization")?.replace(/^Bearer\s+/i, "") ?? "";
+    let claims;
+    try {
+      claims = await tokens.verifySessionToken(bearer);
+    } catch (error) {
+      return jsonError(c, 401, "unauthorized", error instanceof AuthError ? error.message : "Unauthorized.");
+    }
+    const body = await readJson(c);
+    if (!body || typeof body.callId !== "string" || !isHostToolResult(body.result)) {
+      return jsonError(c, 400, "internal", "A tool result needs a `callId` and a `result`.");
+    }
+    const delivered = clientTools.resolve(claims.sessionId, body.callId, body.result);
+    if (!delivered) {
+      return jsonError(c, 404, "session_not_found", "No tool call is awaiting this result.");
+    }
+    return c.json({ ok: true });
+  });
   return app;
 }
+function isHostToolResult(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const result = value;
+  if (typeof result["status"] !== "number") return false;
+  if (result["body"] !== void 0 && typeof result["body"] !== "string") return false;
+  if (result["error"] !== void 0 && typeof result["error"] !== "string") return false;
+  return true;
+}
 function mimeAccepted(mimeType, accept) {
   return accept.some(
     (pattern) => pattern.endsWith("/*") ? mimeType.startsWith(pattern.slice(0, -1)) : pattern === mimeType
   );
 }
+function publicPickerModels(config) {
+  const curated = config.features.modelPicker.models.map((entry) => ({ id: entry.id, label: entry.label }));
+  if (!config.features.modelPicker.enabled) return curated;
+  if (curated.some((model) => model.id === config.model.model)) return curated;
+  return [{ id: config.model.model, label: "Default" }, ...curated];
+}
 function base64Bytes(data) {
   const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
   return Math.floor(data.length * 3 / 4) - padding;
@@ -2354,10 +2592,14 @@ function titleFromClientMessages(messages) {
 
 // src/control/store.ts
 import { mkdir, readFile as readFile2, readdir, rename, rm, writeFile } from "fs/promises";
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { join, resolve } from "path";
 import { parseFrankieConfig } from "@frankieai/core";
 var MEMBERS_FILE = "__members.json";
+function publicVercelLink(link) {
+  const { accessToken: _token, ...rest } = link;
+  return rest;
+}
 function toPublicTenant(record) {
   const { config } = record;
   return {
@@ -2371,6 +2613,7 @@ function toPublicTenant(record) {
     publishableKey: config.auth.publishableKey,
     allowedOrigins: config.auth.allowedOrigins,
     allowAnonymous: config.auth.allowAnonymous,
+    userCredential: config.auth.userCredential,
     connection: config.apis.length > 0 ? "openapi" : config.mcpServers.length > 0 ? "mcp" : "knowledge",
     mcpServers: config.mcpServers.map((s) => s.name),
     apis: config.apis.map((a) => a.name),
@@ -2378,6 +2621,7 @@ function toPublicTenant(record) {
       ...config.mcpServers.map((s) => ({
         kind: "mcp",
         name: s.name,
+        ...s.displayName ? { displayName: s.displayName } : {},
         url: s.url,
         discoveredTools: s.discoveredTools,
         ...s.selectedTools ? { selectedTools: s.selectedTools } : {},
@@ -2388,13 +2632,16 @@ function toPublicTenant(record) {
       ...config.apis.map((a) => ({
         kind: "openapi",
         name: a.name,
+        ...a.displayName ? { displayName: a.displayName } : {},
         spec: a.spec,
         ...a.baseUrl ? { baseUrl: a.baseUrl } : {},
         methods: a.methods,
         ...a.selectedTools ? { selectedTools: a.selectedTools } : {},
         exposeAsMcp: a.exposeAsMcp,
+        execution: a.execution,
         capabilities: a.capabilities.map((capability) => ({ ...capability })),
         forwardsToken: Boolean(a.forwardUserTokenAs),
+        ...a.forwardUserTokenAs ? { forwardTokenAs: a.forwardUserTokenAs } : {},
         securedSchemes: Object.keys(a.security ?? {}),
         enabled: a.enabled && config.agent.tools.allow.some((entry) => entry === `api__${a.name}` || entry.startsWith(`api__${a.name}__`)),
         status: a.capabilities.length ? "ready" : "needs_attention"
@@ -2402,6 +2649,7 @@ function toPublicTenant(record) {
     ],
     locked: record.locked ?? false,
     ...record.repositoryInstall ? { repositoryInstall: record.repositoryInstall } : {},
+    ...record.vercel ? { vercel: publicVercelLink(record.vercel) } : {},
     theme: config.theme,
     features: config.features,
     createdAt: record.createdAt,
@@ -2436,7 +2684,7 @@ var FileTenantStore = class _FileTenantStore {
   async putPlatformAdmin(admin) {
     const path = this.adminPath(admin.ownerId);
     await mkdir(join(this.dir, "platform-admins"), { recursive: true });
-    const temporary = path + "." + randomUUID4() + ".tmp";
+    const temporary = path + "." + randomUUID5() + ".tmp";
     await writeFile(temporary, JSON.stringify(admin), { mode: 384 });
     await rename(temporary, path);
   }
@@ -2915,4 +3163,4 @@ export {
   resolveStores,
   resolveTenantStore
 };
-//# sourceMappingURL=chunk-JOADNB5J.js.map
+//# sourceMappingURL=chunk-MKN5663J.js.map