@decocms/mesh-sdk 1.2.1 → 1.2.3

package/src/lib/constants.ts

@@ -5,7 +5,10 @@
  * This module provides constants and factory functions for creating standard MCP connections.
  */
 
-import type { ConnectionCreateData } from "../types/connection";
+import type {
+  ConnectionCreateData,
+  ConnectionEntity,
+} from "../types/connection";
 import type { VirtualMCPEntity } from "../types/virtual-mcp";
 
 /**
@@ -21,6 +24,10 @@ export const WellKnownOrgMCPId = {
   REGISTRY: (org: string) => `${org}_registry`,
   /** Community MCP registry */
   COMMUNITY_REGISTRY: (org: string) => `${org}_community-registry`,
+  /** Dev Assets MCP - local file storage for development */
+  DEV_ASSETS: (org: string) => `${org}_dev-assets`,
+  /** Site Diagnostics agent (note: prefix-first format, not org-first) */
+  SITE_DIAGNOSTICS: (org: string) => `site-diagnostics_${org}`,
 };
 
 /**
@@ -30,6 +37,13 @@ export const WellKnownOrgMCPId = {
  */
 export const SELF_MCP_ALIAS_ID = "self";
 
+/**
+ * Frontend connection ID for the dev-assets MCP endpoint.
+ * Use this constant when calling object storage tools from the frontend in dev mode.
+ * The endpoint is exposed at /mcp/dev-assets.
+ */
+export const DEV_ASSETS_MCP_ALIAS_ID = "dev-assets";
+
 /**
  * Get well-known connection definition for the Deco Store registry.
  * This can be used by both frontend and backend to create registry connections.
@@ -44,7 +58,7 @@ export function getWellKnownRegistryConnection(
     title: "Deco Store",
     description: "Official deco MCP registry with curated integrations",
     connection_type: "HTTP",
-    connection_url: "https://api.decocms.com/mcp/registry",
+    connection_url: "https://studio.decocms.com/org/deco/registry/mcp",
     icon: "https://assets.decocache.com/decocms/00ccf6c3-9e13-4517-83b0-75ab84554bb9/596364c63320075ca58483660156b6d9de9b526e.png",
     app_name: "deco-registry",
     app_id: null,
@@ -72,7 +86,7 @@ export function getWellKnownCommunityRegistryConnection(): ConnectionCreateData
     title: "MCP Registry",
     description: "Community MCP registry with thousands of handy MCPs",
     connection_type: "HTTP",
-    connection_url: "https://sites-registry.decocache.com/mcp",
+    connection_url: "https://sites-registry.deco.site/mcp",
     icon: "https://assets.decocache.com/decocms/cd7ca472-0f72-463a-b0de-6e44bdd0f9b4/mcp.png",
     app_name: "mcp-registry",
     app_id: null,
@@ -101,8 +115,8 @@ export function getWellKnownSelfConnection(
 ): ConnectionCreateData {
   return {
     id: WellKnownOrgMCPId.SELF(orgId),
-    title: "Mesh MCP",
-    description: "The MCP for the mesh API",
+    title: "Deco CMS",
+    description: "The MCP for the CMS API",
     connection_type: "HTTP",
     // Custom url for targeting this mcp. It's a standalone endpoint that exposes all management tools.
     connection_url: `${baseUrl}/mcp/${SELF_MCP_ALIAS_ID}`,
@@ -121,33 +135,38 @@ export function getWellKnownSelfConnection(
 }
 
 /**
- * Get well-known connection definition for OpenRouter.
- * Used by the chat UI to offer a one-click install when no model provider is connected.
+ * Get well-known connection definition for Dev Assets MCP.
+ * This is a dev-only MCP that provides local file storage at /data/assets/<org_id>/.
+ * It implements the OBJECT_STORAGE_BINDING interface.
+ *
+ * @param baseUrl - The base URL for the MCP server (e.g., "http://localhost:3000")
+ * @param orgId - The organization ID
+ * @returns ConnectionCreateData for the Dev Assets MCP
  */
-export function getWellKnownOpenRouterConnection(
-  opts: { id?: string } = {},
+export function getWellKnownDevAssetsConnection(
+  baseUrl: string,
+  orgId: string,
 ): ConnectionCreateData {
   return {
-    id: opts.id,
-    title: "OpenRouter",
-    description: "Access hundreds of LLM models from a single API",
-    icon: "https://openrouter.ai/favicon.ico",
-    app_name: "openrouter",
-    app_id: "openrouter",
+    id: WellKnownOrgMCPId.DEV_ASSETS(orgId),
+    title: "Local Files",
+    description:
+      "Local file storage for development. Files are stored in /data/assets/.",
     connection_type: "HTTP",
-    connection_url: "https://sites-openrouter.decocache.com/mcp",
+    connection_url: `${baseUrl}/mcp/${DEV_ASSETS_MCP_ALIAS_ID}`,
+    // Folder icon
+    icon: "https://api.iconify.design/lucide:folder.svg?color=%23888",
+    app_name: "@deco/dev-assets-mcp",
+    app_id: null,
     connection_token: null,
     connection_headers: null,
     oauth_config: null,
     configuration_state: null,
     configuration_scopes: null,
     metadata: {
-      source: "chat",
-      verified: false,
-      scopeName: "deco",
-      toolsCount: 0,
-      publishedAt: null,
-      repository: null,
+      isFixed: true,
+      devOnly: true,
+      type: "dev-assets",
     },
   };
 }
@@ -178,27 +197,165 @@ export function getWellKnownMcpStudioConnection(): ConnectionCreateData {
 }
 
 /**
- * Get well-known Decopilot Agent virtual MCP entity.
- * This is the default agent that aggregates ALL org connections.
+ * Build a paired `{ is, get }` helper for an org-scoped well-known agent id
+ * of shape `${prefix}${orgId}`. Centralizes the trivial check/slice/format
+ * logic that every well-known agent used to hand-roll.
  *
- * @param organizationId - Organization ID
- * @returns VirtualMCPEntity representing the Decopilot agent
+ * `is(id)` returns the orgId when `id` matches the prefix; `null` otherwise.
+ * `get(orgId)` mints the well-known id.
  */
-export function getWellKnownDecopilotAgent(
-  organizationId: string,
-): VirtualMCPEntity {
+function createWellKnownAgentPrefix(prefix: string): {
+  is: (id: string | null | undefined) => string | null;
+  get: (organizationId: string) => string;
+} {
   return {
-    id: `decopilot-${organizationId}`,
-    organization_id: organizationId,
-    title: "Decopilot",
-    description: "Default agent that aggregates all organization connections",
-    icon: "https://assets.decocache.com/decocms/fd07a578-6b1c-40f1-bc05-88a3b981695d/f7fc4ffa81aec04e37ae670c3cd4936643a7b269.png",
-    tool_selection_mode: "exclusion",
+    is(id) {
+      if (!id) return null;
+      if (!id.startsWith(prefix)) return null;
+      return id.slice(prefix.length) || null;
+    },
+    get(organizationId) {
+      return `${prefix}${organizationId}`;
+    },
+  };
+}
+
+/**
+ * Build a well-known agent VirtualMCPEntity with sensible defaults
+ * (status active, system creator, empty connections, etc.). Only the
+ * id/title/description/icon and optional instructions vary across agents.
+ */
+function defineWellKnownAgentVMCP(opts: {
+  id: string;
+  organizationId: string;
+  title: string;
+  description: string;
+  icon: string;
+  instructions?: string | null;
+}): VirtualMCPEntity {
+  return {
+    id: opts.id,
+    organization_id: opts.organizationId,
+    title: opts.title,
+    description: opts.description,
+    icon: opts.icon,
     status: "active",
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
     created_by: "system",
     updated_by: undefined,
-    connections: [], // Empty = no exclusions, include all connections
+    metadata: { instructions: opts.instructions ?? null },
+    pinned: false,
+    connections: [],
+  };
+}
+
+// ---- Decopilot ----
+// Default agent that aggregates ALL org connections. Gateway populates
+// the connections array at lookup time.
+const decopilotPrefix = createWellKnownAgentPrefix("decopilot_");
+export const isDecopilot = decopilotPrefix.is;
+export const getDecopilotId = decopilotPrefix.get;
+
+export function getWellKnownDecopilotVirtualMCP(
+  organizationId: string,
+): VirtualMCPEntity {
+  return defineWellKnownAgentVMCP({
+    id: getDecopilotId(organizationId),
+    organizationId,
+    title: "Decopilot",
+    description: "Default agent that aggregates all organization connections",
+    icon: "https://assets.decocache.com/decocms/fd07a578-6b1c-40f1-bc05-88a3b981695d/f7fc4ffa81aec04e37ae670c3cd4936643a7b269.png",
+  });
+}
+
+// ---- Brand-Context Setup ----
+// Guided-onboarding agent for the brand-context preset task. The
+// `brand_context_setup` built-in is injected by `dispatchRun` when this
+// id is seen; the system prompt lives in `metadata.instructions`.
+const brandContextSetupPrefix = createWellKnownAgentPrefix(
+  "brand-context-setup_",
+);
+export const isBrandContextSetup = brandContextSetupPrefix.is;
+export const getBrandContextSetupId = brandContextSetupPrefix.get;
+
+const BRAND_CONTEXT_SETUP_INSTRUCTIONS = `
+You are running the brand-context onboarding for the user's organization. Your only job in this thread is to set up the organization's brand context:
+
+1. If the user hasn't already given you a website URL, ask for it in one short message. Accept whatever URL they give — don't quibble about format.
+2. As soon as you have a URL, call the \`brand_context_setup\` tool exactly once with that URL.
+3. After the tool returns success, briefly confirm to the user what was captured (brand name + domain) in one or two sentences. Do not list every color or font.
+4. Do NOT call any other tools in this thread. Do NOT call \`brand_context_setup\` more than once.
+
+If the tool returns an error, surface the error message to the user and ask whether they want to try a different URL.
+`.trim();
+
+export function getWellKnownBrandContextSetupVirtualMCP(
+  organizationId: string,
+): VirtualMCPEntity {
+  return defineWellKnownAgentVMCP({
+    id: getBrandContextSetupId(organizationId),
+    organizationId,
+    title: "Brand context setup",
+    description:
+      "Guided onboarding agent that extracts brand context from a website URL.",
+    icon: "https://assets.decocache.com/decocms/fd07a578-6b1c-40f1-bc05-88a3b981695d/f7fc4ffa81aec04e37ae670c3cd4936643a7b269.png",
+    instructions: BRAND_CONTEXT_SETUP_INSTRUCTIONS,
+  });
+}
+
+// ---- Site Diagnostics ----
+const siteDiagnosticsPrefix = createWellKnownAgentPrefix("site-diagnostics_");
+export const isSiteDiagnostics = siteDiagnosticsPrefix.is;
+export const getSiteDiagnosticsId = siteDiagnosticsPrefix.get;
+
+/**
+ * Studio Pack agent ID generators (org-scoped)
+ */
+export const StudioPackAgentId = {
+  AGENT_MANAGER: (orgId: string) => `studio-agent-manager_${orgId}`,
+  AUTOMATION_MANAGER: (orgId: string) => `studio-automation-manager_${orgId}`,
+  CONNECTION_MANAGER: (orgId: string) => `studio-connection-manager_${orgId}`,
+  STORE_MANAGER: (orgId: string) => `studio-store-manager_${orgId}`,
+  BRAND_MANAGER: (orgId: string) => `studio-brand-manager_${orgId}`,
+} as const;
+
+/**
+ * Check if a connection or virtual MCP ID is a Studio Pack agent.
+ */
+export function isStudioPackAgent(id: string | null | undefined): boolean {
+  if (!id) return false;
+  return (
+    id.startsWith("studio-agent-manager_") ||
+    id.startsWith("studio-automation-manager_") ||
+    id.startsWith("studio-connection-manager_") ||
+    id.startsWith("studio-store-manager_") ||
+    id.startsWith("studio-brand-manager_")
+  );
+}
+
+export function getWellKnownDecopilotConnection(
+  organizationId: string,
+): ConnectionEntity {
+  const virtual = getWellKnownDecopilotVirtualMCP(organizationId);
+
+  return {
+    ...virtual,
+    id: virtual.id!,
+    connection_type: "VIRTUAL",
+    connection_url: `virtual://${virtual.id}`,
+    app_name: "decopilot",
+    app_id: "decopilot",
+    connection_token: null,
+    connection_headers: null,
+    oauth_config: null,
+    configuration_state: null,
+    configuration_scopes: null,
+    metadata: {
+      isDefault: true,
+      type: "decopilot",
+    },
+    tools: [],
+    bindings: [],
   };
 }

package/src/lib/default-model.ts

@@ -0,0 +1,281 @@
+import type {
+  AiProviderModel,
+  AiProviderKey,
+  ProviderId,
+} from "../types/ai-providers";
+
+/**
+ * Preferred default models for each well-known provider.
+ *
+ * Each entry is an ordered list of candidate model ID strings — lower indexes
+ * have higher priority. The selector first tries exact matches across the full
+ * list, then falls back to substring matches in the same priority order.
+ */
+export const DEFAULT_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> =
+  {
+    anthropic: ["claude-sonnet-4-6", "claude-sonnet", "claude"],
+    openrouter: [
+      "anthropic/claude-opus-4.8",
+      "anthropic/claude-sonnet-4-6",
+      "anthropic/claude-sonnet",
+      "anthropic/claude",
+    ],
+    deco: [
+      "anthropic/claude-haiku-4-5",
+      "anthropic/claude-haiku",
+      "anthropic/claude",
+    ],
+    google: ["gemini-3-flash"],
+    "claude-code": [
+      "claude-code:sonnet",
+      "claude-code:opus",
+      "claude-code:haiku",
+    ],
+    codex: ["codex:gpt-5.4"],
+  };
+
+/**
+ * Preferred fast/cheap models per provider — used for lightweight tasks
+ * like title generation where latency and cost matter more than capability.
+ */
+export const FAST_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> = {
+  anthropic: ["claude-haiku-4-5", "claude-haiku"],
+  openrouter: [
+    "qwen/qwen3.5-flash",
+    "anthropic/claude-haiku-4.5",
+    "anthropic/claude-haiku",
+    "google/gemini-3-flash",
+  ],
+  deco: ["qwen/qwen3.5-flash", "anthropic/claude-haiku"],
+  google: ["gemini-2.5-flash", "gemini-3-flash"],
+  "claude-code": ["claude-code:haiku", "claude-code:sonnet"],
+  codex: ["codex:gpt-5.4-mini"],
+};
+
+/**
+ * Return the preferred fast model ID for a given provider.
+ * Returns the first candidate or `null` if no preference is configured.
+ */
+export function getFastModel(providerId: ProviderId): string | null {
+  const candidates = FAST_MODEL_PREFERENCES[providerId];
+  return candidates?.[0] ?? null;
+}
+
+/**
+ * Preferred smart (balanced) models per provider — used as the "Smart" tier
+ * in Simple Model Mode.
+ */
+export const SMART_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> = {
+  anthropic: ["claude-sonnet-4-6", "claude-sonnet"],
+  openrouter: [
+    "anthropic/claude-sonnet-4.6",
+    "anthropic/claude-sonnet",
+    "anthropic/claude-opus-4.8",
+    "google/gemini-3-pro",
+  ],
+  deco: [
+    "anthropic/claude-sonnet-4.6",
+    "anthropic/claude-sonnet",
+    "anthropic/claude",
+  ],
+  google: ["gemini-3-pro", "gemini-3-flash"],
+  "claude-code": ["claude-code:sonnet"],
+  codex: ["codex:gpt-5.4"],
+};
+
+/**
+ * Preferred thinking/reasoning models per provider — used as the "Thinking" tier
+ * in Simple Model Mode.
+ */
+export const THINKING_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> =
+  {
+    anthropic: ["claude-opus-4-8", "claude-sonnet-4-6", "claude-sonnet"],
+    openrouter: [
+      "anthropic/claude-opus-4.8",
+      "anthropic/claude-sonnet-4.6:extended",
+      "anthropic/claude-sonnet-4.6",
+      "google/gemini-3-pro",
+    ],
+    deco: [
+      "anthropic/claude-opus",
+      "anthropic/claude-sonnet-4.6",
+      "anthropic/claude-sonnet",
+    ],
+    google: ["gemini-3-pro"],
+    "claude-code": ["claude-code:opus", "claude-code:sonnet"],
+    codex: ["codex:gpt-5.5"],
+  };
+
+/**
+ * Preferred image generation models per provider.
+ * Falls back to first model with "image" capability.
+ */
+export const IMAGE_MODEL_PREFERENCES: Partial<Record<ProviderId, string[]>> = {
+  openrouter: ["openai/gpt-image-1", "google/gemini-2.0-flash-image"],
+  deco: ["openai/gpt-image-1", "google/gemini-2.0-flash-image"],
+  google: ["gemini-2.0-flash-image"],
+};
+
+/**
+ * Preferred web research models per provider.
+ * Falls back to first model whose id includes "sonar" or "deepresearch".
+ */
+export const WEB_RESEARCH_MODEL_PREFERENCES: Partial<
+  Record<ProviderId, string[]>
+> = {
+  openrouter: [
+    "perplexity/sonar",
+    "perplexity/sonar-pro",
+    "perplexity/deep-research",
+  ],
+  deco: [
+    "perplexity/sonar",
+    "perplexity/sonar-pro",
+    "perplexity/deep-research",
+  ],
+};
+
+export interface SimpleModeModelSlot {
+  keyId: string;
+  modelId: string;
+  title?: string;
+}
+
+export interface SimpleModeDefaults {
+  chat: {
+    fast: SimpleModeModelSlot | null;
+    smart: SimpleModeModelSlot | null;
+    thinking: SimpleModeModelSlot | null;
+  };
+  image: SimpleModeModelSlot | null;
+  webResearch: SimpleModeModelSlot | null;
+}
+
+function resolveSlot(
+  models: AiProviderModel[],
+  keyId: string,
+  preferences: string[],
+  fallback?: (m: AiProviderModel) => boolean,
+): SimpleModeModelSlot | null {
+  for (const candidate of preferences) {
+    const exact = models.find((m) => m.modelId === candidate);
+    if (exact) return { keyId, modelId: exact.modelId, title: exact.title };
+  }
+  for (const candidate of preferences) {
+    const partial = models.find((m) => m.modelId.includes(candidate));
+    if (partial)
+      return { keyId, modelId: partial.modelId, title: partial.title };
+  }
+  if (fallback) {
+    const found = models.find(fallback);
+    if (found) return { keyId, modelId: found.modelId, title: found.title };
+  }
+  return null;
+}
+
+/**
+ * Compute sensible Simple Mode defaults from the currently-connected keys and
+ * their available models. Each slot picks the best candidate per the tier
+ * preference lists, falling back to capability-based detection for image/web.
+ *
+ * @param keys       The org's connected AI provider keys.
+ * @param modelsByKeyId  Map of keyId → available model list.
+ */
+export function pickSimpleModeDefaults(
+  keys: AiProviderKey[],
+  modelsByKeyId: Record<string, AiProviderModel[]>,
+): SimpleModeDefaults {
+  const result: SimpleModeDefaults = {
+    chat: { fast: null, smart: null, thinking: null },
+    image: null,
+    webResearch: null,
+  };
+
+  for (const key of keys) {
+    const models = modelsByKeyId[key.id] ?? [];
+    const providerId = key.providerId as ProviderId;
+
+    if (!result.chat.fast) {
+      result.chat.fast = resolveSlot(
+        models,
+        key.id,
+        FAST_MODEL_PREFERENCES[providerId] ?? [],
+      );
+    }
+    if (!result.chat.smart) {
+      result.chat.smart = resolveSlot(
+        models,
+        key.id,
+        SMART_MODEL_PREFERENCES[providerId] ?? [],
+      );
+    }
+    if (!result.chat.thinking) {
+      result.chat.thinking = resolveSlot(
+        models,
+        key.id,
+        THINKING_MODEL_PREFERENCES[providerId] ?? [],
+      );
+    }
+    if (!result.image) {
+      result.image = resolveSlot(
+        models,
+        key.id,
+        IMAGE_MODEL_PREFERENCES[providerId] ?? [],
+        (m) => m.capabilities?.includes("image") === true,
+      );
+    }
+    if (!result.webResearch) {
+      result.webResearch = resolveSlot(
+        models,
+        key.id,
+        WEB_RESEARCH_MODEL_PREFERENCES[providerId] ?? [],
+        (m) => {
+          const n = m.modelId.toLowerCase().replace(/[^a-z0-9]/g, "");
+          return n.includes("sonar") || n.includes("deepresearch");
+        },
+      );
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Select the best default model from a loaded list for a given provider.
+ *
+ * Resolution order:
+ *   1. Exact `modelId` match — walk candidates in priority order.
+ *   2. Substring match — walk candidates in priority order, return the first
+ *      model whose `modelId` contains the candidate string.
+ *   3. First model in the list.
+ *   4. `null` if the list is empty.
+ *
+ * @param models      Full model list returned by the provider for this key.
+ * @param providerId  The provider that owns the key.
+ * @param keyId       Credential key ID to attach — mirrors what
+ *                    `handleModelSelect` does on explicit user selection.
+ */
+export function selectDefaultModel(
+  models: AiProviderModel[],
+  providerId: ProviderId,
+  keyId?: string,
+): AiProviderModel | null {
+  if (models.length === 0) return null;
+
+  const candidates = DEFAULT_MODEL_PREFERENCES[providerId] ?? [];
+
+  const withKey = (model: AiProviderModel): AiProviderModel =>
+    keyId !== undefined ? { ...model, keyId } : model;
+
+  for (const candidate of candidates) {
+    const exact = models.find((m) => m.modelId === candidate);
+    if (exact) return withKey(exact);
+  }
+
+  for (const candidate of candidates) {
+    const partial = models.find((m) => m.modelId.includes(candidate));
+    if (partial) return withKey(partial);
+  }
+
+  return withKey(models[0] as AiProviderModel);
+}