@shawnstack/quickforge 1.7.4 → 1.7.5

package/server/index.mjs

@@ -17,6 +17,7 @@ import { handleToolApi, handleGetTools } from './routes/tools.mjs'
 import { handleInstructionsApi } from './routes/instructions.mjs'
 import { handleMemoryApi } from './routes/memory.mjs'
 import { handleSkillsApi } from './routes/skills.mjs'
+import { ensureDefaultGlobalSkills } from './skills.mjs'
 import { handleAgentApi } from './routes/agent.mjs'
 import { handleAgentProfilesApi } from './routes/agent-profiles.mjs'
 import { handleScheduledTasksApi, startScheduledTaskRunner, stopScheduledTaskRunner } from './routes/scheduled-tasks.mjs'
@@ -33,6 +34,7 @@ import { handleWorkspaceApi, handleGitApi } from './routes/workspace.mjs'
 import { handleTerminalApi, handleTerminalUpgrade } from './routes/terminal.mjs'
 import { handleChannelsApi } from './routes/channels.mjs'
 import { handleModelsApi } from './routes/models.mjs'
+import { handleCloudApi } from './routes/cloud.mjs'
 import { serveStatic } from './routes/static.mjs'
 import { logger, flushLogger } from './utils/logger.mjs'
 import { getPackageInfo, checkForUpdates, checkDesktopRelease } from './utils/package-update.mjs'
@@ -289,12 +291,12 @@ async function handleApi(req, res, url, requestContext = {}) {
 
   // Conversation share routes (management + public LAN access)
   if (pathname === '/api/shares' || pathname.startsWith('/api/shares/')) {
-    await handleSharesApi(req, res, url, { port })
+    await handleSharesApi(req, res, url, { ...requestContext, port })
     return
   }
 
   if (pathname.startsWith('/api/shared/')) {
-    await handleSharedConversationApi(req, res, url)
+    await handleSharedConversationApi(req, res, url, requestContext)
     return
   }
 
@@ -336,13 +338,23 @@ async function handleApi(req, res, url, requestContext = {}) {
 
   // Agent profiles
   if (pathname === '/api/agent-profiles' || pathname.startsWith('/api/agent-profiles/')) {
-    await handleAgentProfilesApi(req, res, url)
+    await handleAgentProfilesApi(req, res, url, requestContext)
+    return
+  }
+
+  // QuickForge Cloud account and managed models (local or authenticated Tailscale requests).
+  if (pathname === '/api/cloud' || pathname.startsWith('/api/cloud/')) {
+    await handleCloudApi(req, res, url, {
+      isLocalRequest: requestContext.isLocalRequest === true,
+      remoteAddress: requestContext.remoteAddress,
+      remoteAuthorized: requestContext.remoteAuthorized === true,
+    })
     return
   }
 
   // Custom model management (connection test)
-  if (pathname === '/api/models/test-connection') {
-    await handleModelsApi(req, res, url)
+  if (pathname === '/api/models/catalog' || pathname === '/api/models/test-connection') {
+    await handleModelsApi(req, res, url, requestContext)
     return
   }
 
@@ -387,7 +399,7 @@ async function handleApi(req, res, url, requestContext = {}) {
   }
 
   if (pathname.startsWith('/api/git/')) {
-    await handleGitApi(req, res, url)
+    await handleGitApi(req, res, url, requestContext)
     return
   }
 
@@ -411,19 +423,19 @@ async function handleApi(req, res, url, requestContext = {}) {
 
   // Agent routes
   if (parts[0] === 'api' && parts[1] === 'agents') {
-    await handleAgentApi(req, res, url)
+    await handleAgentApi(req, res, url, requestContext)
     return
   }
 
   // Scheduled task routes
   if (pathname === '/api/scheduled-tasks' || pathname.startsWith('/api/scheduled-tasks/')) {
-    await handleScheduledTasksApi(req, res, url)
+    await handleScheduledTasksApi(req, res, url, requestContext)
     return
   }
 
   // Backup / import-export routes
   if (pathname === '/api/backup/export' || pathname === '/api/backup/import' || pathname === '/api/backup/inspect' || pathname === '/api/backup/inspect-file') {
-    await handleBackupApi(req, res, url)
+    await handleBackupApi(req, res, url, requestContext)
     return
   }
 
@@ -461,7 +473,7 @@ async function handleApi(req, res, url, requestContext = {}) {
 
   // Storage routes (catch-all)
   if (parts[0] === 'api' && parts[1] === 'storage') {
-    await handleStorageApi(req, res, url)
+    await handleStorageApi(req, res, url, requestContext)
     return
   }
 
@@ -619,7 +631,11 @@ const server = createServer(async (req, res) => {
     }
 
     if (url.pathname.startsWith('/api/')) {
-      await handleApi(req, res, url, { isLocalRequest: !isRemoteRequest })
+      await handleApi(req, res, url, {
+        isLocalRequest: !isRemoteRequest,
+        remoteAddress,
+        remoteAuthorized,
+      })
       return
     }
 
@@ -681,6 +697,7 @@ server.on('upgrade', (req, socket, head) => {
 })
 
 await ensureStorage()
+await ensureDefaultGlobalSkills()
 await initializeNetworkProxy()
 installAiHttpLogger()
 initializeChannels({

package/server/model-catalog.mjs

@@ -0,0 +1,262 @@
+import { getCloudRuntime } from './cloud/runtime.mjs'
+import { isManagedCloudModel } from './cloud/models.mjs'
+import { readStore } from './storage.mjs'
+import { isTailscaleAddress } from './utils/network.mjs'
+
+export const MODEL_REFERENCE_VERSION = 1
+
+function requestError(message, statusCode = 400, code) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  if (code) {
+    error.code = code
+    error.errorCode = code
+  }
+  return error
+}
+
+function normalizedBaseUrl(value) {
+  return String(value || '').trim().replace(/\/$/, '')
+}
+
+function isUsableModel(model) {
+  return Boolean(model && typeof model === 'object' && model.id && model.provider && model.api && model.baseUrl)
+}
+
+function sameModel(left, right) {
+  return Boolean(left && right
+    && left.id === right.id
+    && left.provider === right.provider
+    && left.api === right.api
+    && normalizedBaseUrl(left.baseUrl) === normalizedBaseUrl(right.baseUrl))
+}
+
+function publicModel(model, modelRef) {
+  const result = {
+    ...model,
+    quickforgeModelRef: modelRef,
+  }
+  delete result.apiKey
+  delete result.key
+  delete result.headers
+  return result
+}
+
+async function configuredProviders() {
+  const store = await readStore('custom-providers').catch(() => ({}))
+  return Array.isArray(store) ? store : Object.values(store || {})
+}
+
+function configuredEntries(providers) {
+  return providers.flatMap((provider) => {
+    const providerId = String(provider?.id || '').trim()
+    return (Array.isArray(provider?.models) ? provider.models : [])
+      .filter(isUsableModel)
+      .map((model) => ({ provider, providerId, model }))
+  })
+}
+
+export function cloudAllowedForContext(context = {}) {
+  if (context.allowCloud === false) return false
+  if (context.allowCloud === true || context.source === 'acp' || context.source === 'scheduled') return true
+  if (context.isLocalRequest !== false) return true
+  return context.remoteAuthorized === true && isTailscaleAddress(context.remoteAddress)
+}
+
+export function modelReferenceFromSnapshot(model, providers = []) {
+  if (!model || typeof model !== 'object') return null
+  if (isManagedCloudModel(model)) {
+    const catalogId = String(model.quickforgeCatalogId || model.id || '').trim()
+    return catalogId ? { version: MODEL_REFERENCE_VERSION, source: 'cloud', catalogId } : null
+  }
+
+  const matched = configuredEntries(providers).find((entry) => sameModel(entry.model, model))
+  if (matched?.providerId) {
+    return {
+      version: MODEL_REFERENCE_VERSION,
+      source: 'custom',
+      providerId: matched.providerId,
+      modelId: matched.model.id,
+    }
+  }
+
+  if (model.provider && model.id) {
+    return {
+      version: MODEL_REFERENCE_VERSION,
+      source: 'legacy-custom',
+      provider: String(model.provider),
+      modelId: String(model.id),
+      ...(model.api ? { api: String(model.api) } : {}),
+      ...(model.baseUrl ? { baseUrl: String(model.baseUrl) } : {}),
+    }
+  }
+  return null
+}
+
+export function normalizeModelReference(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const source = String(value.source || '').trim()
+  if (source === 'cloud') {
+    const catalogId = String(value.catalogId || value.quickforgeCatalogId || value.modelId || '').trim()
+    return catalogId ? { version: MODEL_REFERENCE_VERSION, source: 'cloud', catalogId } : null
+  }
+  if (source === 'custom') {
+    const providerId = String(value.providerId || '').trim()
+    const modelId = String(value.modelId || value.id || '').trim()
+    return providerId && modelId
+      ? { version: MODEL_REFERENCE_VERSION, source: 'custom', providerId, modelId }
+      : null
+  }
+  if (source === 'legacy-custom') {
+    const provider = String(value.provider || '').trim()
+    const modelId = String(value.modelId || value.id || '').trim()
+    return provider && modelId
+      ? {
+          version: MODEL_REFERENCE_VERSION,
+          source: 'legacy-custom',
+          provider,
+          modelId,
+          ...(value.api ? { api: String(value.api) } : {}),
+          ...(value.baseUrl ? { baseUrl: String(value.baseUrl) } : {}),
+        }
+      : null
+  }
+  return null
+}
+
+async function listCloudModels(context, { refresh = false } = {}) {
+  if (!cloudAllowedForContext(context)) return []
+  try {
+    const runtime = await getCloudRuntime()
+    if (!runtime?.enabled) return []
+    const models = await runtime.models.list(undefined, { refresh })
+    return models.filter((model) => model?.quickforgeCatalogId)
+  } catch {
+    return []
+  }
+}
+
+export async function listModelCatalog({
+  context = {},
+  includeHidden = false,
+  currentModel = null,
+  refreshCloud = false,
+} = {}) {
+  const providers = await configuredProviders()
+  const custom = configuredEntries(providers)
+    .filter(({ model }) => includeHidden || model.quickforgeHidden !== true || sameModel(model, currentModel))
+    .map(({ providerId, model }) => publicModel(model, {
+      version: MODEL_REFERENCE_VERSION,
+      source: 'custom',
+      providerId,
+      modelId: model.id,
+    }))
+  if (currentModel) {
+    const currentIndex = custom.findIndex((model) => sameModel(model, currentModel))
+    if (currentIndex > 0 && custom[currentIndex].quickforgeHidden === true) {
+      custom.unshift(custom.splice(currentIndex, 1)[0])
+    }
+  }
+  const cloud = (await listCloudModels(context, { refresh: refreshCloud }))
+    .map((model) => publicModel(model, {
+      version: MODEL_REFERENCE_VERSION,
+      source: 'cloud',
+      catalogId: model.quickforgeCatalogId,
+    }))
+
+  if (currentModel && ![...custom, ...cloud].some((model) => sameModel(model, currentModel))) {
+    const ref = modelReferenceFromSnapshot(currentModel, providers)
+    if (ref) return [publicModel(currentModel, ref), ...custom, ...cloud]
+  }
+  return [...custom, ...cloud]
+}
+
+async function resolveCloud(ref, context) {
+  if (!cloudAllowedForContext(context)) {
+    throw requestError('QuickForge Cloud is not available from this client.', 403, 'cloud_access_denied')
+  }
+  const runtime = await getCloudRuntime()
+  if (!runtime?.enabled) throw requestError('QuickForge Cloud is not configured.', 503, 'cloud_not_configured')
+  return (await runtime.models.resolve({
+    provider: 'quickforge-cloud',
+    quickforgeModelSource: 'cloud',
+    quickforgeCatalogId: ref.catalogId,
+  })).publicModel
+}
+
+function findCustomByReference(ref, entries) {
+  if (ref.source === 'custom') {
+    return entries.find(({ providerId, model }) => providerId === ref.providerId && model.id === ref.modelId)?.model
+  }
+  if (ref.source === 'legacy-custom') {
+    return entries.find(({ model }) => model.provider === ref.provider
+      && model.id === ref.modelId
+      && (!ref.api || model.api === ref.api)
+      && (!ref.baseUrl || normalizedBaseUrl(model.baseUrl) === normalizedBaseUrl(ref.baseUrl)))?.model
+  }
+  return null
+}
+
+export async function resolveModelBinding(input, {
+  context = {},
+  currentModel = null,
+  allowCurrentHidden = false,
+  forExecution = false,
+  legacySnapshot = null,
+} = {}) {
+  const providers = await configuredProviders()
+  const entries = configuredEntries(providers)
+  const explicitRef = normalizeModelReference(input?.modelRef || input?.quickforgeModelRef || input)
+  const snapshot = input?.model && typeof input.model === 'object'
+    ? input.model
+    : (!explicitRef && input && typeof input === 'object' && input.id ? input : legacySnapshot)
+  const ref = explicitRef || modelReferenceFromSnapshot(snapshot, providers)
+  if (!ref) throw requestError('A valid model reference is required.', 400, 'invalid_model_reference')
+
+  if (ref.source === 'cloud') {
+    const model = await resolveCloud(ref, context)
+    return { model, modelRef: ref }
+  }
+
+  const configured = findCustomByReference(ref, entries)
+  if (configured) {
+    const hidden = configured.quickforgeHidden === true
+    if (hidden && !forExecution && !(allowCurrentHidden && sameModel(configured, currentModel))) {
+      throw requestError('Selected model is not available for new selection.', 400, 'model_not_selectable')
+    }
+    const canonicalRef = modelReferenceFromSnapshot(configured, providers)
+    return { model: configured, modelRef: canonicalRef }
+  }
+
+  throw requestError('Selected model is not configured in QuickForge.', 400, 'model_not_configured')
+}
+
+export async function resolveImplicitModelPreference(value, context = {}) {
+  let stored = value
+  if (typeof stored === 'string') {
+    try { stored = JSON.parse(stored) } catch { stored = null }
+  }
+  const ref = normalizeModelReference(stored?.modelRef || stored?.quickforgeModelRef)
+  const snapshot = stored?.modelSnapshot || stored?.model || (stored?.id ? stored : null)
+  const catalog = await listModelCatalog({ context })
+  if (ref) {
+    const matched = catalog.find((model) => {
+      const candidate = normalizeModelReference(model.quickforgeModelRef)
+      if (!candidate || candidate.source !== ref.source) return false
+      if (ref.source === 'cloud') return candidate.catalogId === ref.catalogId
+      if (ref.source === 'custom') return candidate.providerId === ref.providerId && candidate.modelId === ref.modelId
+      return false
+    })
+    if (matched) return matched
+  }
+  if (snapshot) {
+    const matched = catalog.find((model) => sameModel(model, snapshot))
+    if (matched) return matched
+  }
+  return catalog[0] || null
+}
+
+export async function modelBindingFromModel(model) {
+  const providers = await configuredProviders()
+  return { model, modelRef: modelReferenceFromSnapshot(model, providers) }
+}

package/server/plugins/registry.mjs

@@ -16,6 +16,12 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const bundledPluginDir = path.resolve(__dirname, '..', '..', 'plugins')
 const globalPluginDir = path.join(dataDir, 'plugins')
 const legacyGlobalPluginDir = path.join(os.homedir(), '.agents', 'plugins')
+const PLUGIN_STORE_SCHEMA_VERSION = 2
+const LEGACY_BUNDLED_PLUGIN_NAMES = {
+  'openai-documents': 'documents',
+  'openai-presentations': 'presentations',
+  'openai-spreadsheets': 'spreadsheets',
+}
 export const DEFAULT_PLUGIN_TOOL_TIMEOUT_MS = 2 * 60 * 1000
 let cachedCatalog = null
 let cachedCatalogKey = null
@@ -108,13 +114,31 @@ async function listPluginDirs(root) {
 function normalizePluginStore(store) {
   const source = isPlainObject(store) ? store : {}
   return {
-    enabled: isPlainObject(source.enabled) ? source.enabled : {},
-    config: isPlainObject(source.config) ? source.config : {},
+    schemaVersion: Number.isInteger(source.schemaVersion) ? source.schemaVersion : 1,
+    enabled: isPlainObject(source.enabled) ? { ...source.enabled } : {},
+    config: isPlainObject(source.config) ? { ...source.config } : {},
+  }
+}
+
+function migratePluginStore(store) {
+  const next = normalizePluginStore(store)
+  if (next.schemaVersion >= PLUGIN_STORE_SCHEMA_VERSION) return { store: next, changed: false }
+
+  for (const [legacyName, name] of Object.entries(LEGACY_BUNDLED_PLUGIN_NAMES)) {
+    if (!(name in next.enabled) && legacyName in next.enabled) next.enabled[name] = next.enabled[legacyName]
+    if (!(name in next.config) && legacyName in next.config) next.config[name] = next.config[legacyName]
+    delete next.enabled[legacyName]
+    delete next.config[legacyName]
   }
+  next.schemaVersion = PLUGIN_STORE_SCHEMA_VERSION
+  return { store: next, changed: true }
 }
 
 async function readPluginStore() {
-  return normalizePluginStore(await readStore('plugins'))
+  const current = await readStore('plugins')
+  const migration = migratePluginStore(current)
+  if (!migration.changed) return migration.store
+  return atomicUpdate('plugins', (store) => migratePluginStore(store).store)
 }
 
 function contributionSummary(contribution) {
@@ -292,7 +316,7 @@ export async function getPluginStatus(projectContext = null) {
 
 export async function setPluginEnabled(name, enabled) {
   await atomicUpdate('plugins', (store) => {
-    const next = normalizePluginStore(store)
+    const next = migratePluginStore(store).store
     next.enabled[name] = enabled === true
     return next
   })
@@ -301,7 +325,7 @@ export async function setPluginEnabled(name, enabled) {
 
 export async function setPluginConfig(name, config) {
   await atomicUpdate('plugins', (store) => {
-    const next = normalizePluginStore(store)
+    const next = migratePluginStore(store).store
     next.config[name] = isPlainObject(config) ? config : {}
     return next
   })

package/server/routes/agent-profiles.mjs

@@ -3,6 +3,36 @@ import { DEFAULT_AI_MAX_RETRIES } from '../ai-provider-options.mjs'
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { logger } from '../utils/logger.mjs'
+import { resolveModelBinding } from '../model-catalog.mjs'
+
+function profileModelReference(model) {
+  if (!model || model.mode !== 'fixed') return null
+  if (model.source === 'cloud') return { version: 1, source: 'cloud', catalogId: model.catalogId || model.modelId }
+  if (model.source === 'custom') return { version: 1, source: 'custom', providerId: model.providerId, modelId: model.modelId }
+  return {
+    version: 1,
+    source: 'legacy-custom',
+    provider: model.provider,
+    modelId: model.modelId,
+    ...(model.api ? { api: model.api } : {}),
+    ...(model.baseUrl ? { baseUrl: model.baseUrl } : {}),
+  }
+}
+
+async function canonicalizeProfileModel(body, current, context) {
+  if (!body || !Object.prototype.hasOwnProperty.call(body, 'model')) return body
+  const model = body.model
+  if (!model || model.mode !== 'fixed') return body
+  if (current?.model && JSON.stringify(current.model) === JSON.stringify(model)) return body
+  const binding = await resolveModelBinding({ modelRef: profileModelReference(model) }, { context })
+  const ref = binding.modelRef
+  return {
+    ...body,
+    model: ref.source === 'cloud'
+      ? { mode: 'fixed', source: 'cloud', catalogId: ref.catalogId }
+      : { mode: 'fixed', source: 'custom', providerId: ref.providerId, modelId: ref.modelId },
+  }
+}
 import {
   agentProfileSnapshot,
   createCustomAgentProfile,
@@ -65,10 +95,14 @@ function normalizeGeneratedAgentProfile(value) {
   return { name, label, description, systemPrompt }
 }
 
-async function generateAgentProfileWithAi(instruction, model, thinkingLevel = 'off') {
+async function generateAgentProfileWithAi(instruction, modelInput, thinkingLevel = 'off', context = {}) {
   const text = String(instruction || '').trim()
   if (!text) throw requestError('Please describe the agent you want to create')
-  if (!model) throw requestError('Please configure a default model first')
+  if (!modelInput) throw requestError('Please configure a default model first')
+  const { model } = await resolveModelBinding(
+    modelInput?.modelRef || modelInput?.model ? modelInput : { model: modelInput },
+    { context, legacySnapshot: modelInput?.model || modelInput },
+  )
 
   const systemPrompt = `You are a QuickForge Agent Profile generator.
 Generate only the basic definition fields for a custom Agent Profile from the user's request.
@@ -120,7 +154,7 @@ Rules:
   }
 }
 
-export async function handleAgentProfilesApi(req, res, url) {
+export async function handleAgentProfilesApi(req, res, url, context = {}) {
   const parts = url.pathname.split('/').filter(Boolean)
 
   if (req.method === 'GET' && url.pathname === '/api/agent-profiles') {
@@ -136,13 +170,13 @@ export async function handleAgentProfilesApi(req, res, url) {
 
   if (req.method === 'POST' && url.pathname === '/api/agent-profiles/ai-fill') {
     const body = await readJsonBody(req)
-    sendJson(res, 200, { agent: await generateAgentProfileWithAi(body?.instruction, body?.model, body?.thinkingLevel) })
+    sendJson(res, 200, { agent: await generateAgentProfileWithAi(body?.instruction, body?.modelRef ? body : body?.model, body?.thinkingLevel, context) })
     return
   }
 
   if (req.method === 'POST' && url.pathname === '/api/agent-profiles') {
     const body = await readJsonBody(req)
-    sendJson(res, 200, { agent: await createCustomAgentProfile(body || {}) })
+    sendJson(res, 200, { agent: await createCustomAgentProfile(await canonicalizeProfileModel(body || {}, null, context)) })
     return
   }
 
@@ -162,11 +196,11 @@ export async function handleAgentProfilesApi(req, res, url) {
       if (current?.builtin) {
         const keys = Object.keys(body || {})
         if (keys.length !== 1 || keys[0] !== 'model') throw requestError('Built-in agents only allow model updates', 403)
-        sendJson(res, 200, { agent: agentProfileSnapshot(await updateBuiltinAgentModelOverride(id, body.model)) })
+        sendJson(res, 200, { agent: agentProfileSnapshot(await updateBuiltinAgentModelOverride(id, (await canonicalizeProfileModel(body, current, context)).model)) })
         return
       }
       if (current?.readonly) throw requestError('Read-only agents cannot be modified from the API', 403)
-      sendJson(res, 200, { agent: await updateCustomAgentProfile(id, body || {}) })
+      sendJson(res, 200, { agent: await updateCustomAgentProfile(id, await canonicalizeProfileModel(body || {}, current, context)) })
       return
     }
 

package/server/routes/agent.mjs

@@ -1,5 +1,6 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { logger } from '../utils/logger.mjs'
+import { resolveModelBinding } from '../model-catalog.mjs'
 import {
   createAgent,
   runPrompt,
@@ -31,7 +32,7 @@ import {
   agentEvents,
 } from '../agent-manager.mjs'
 
-export async function handleAgentApi(req, res, url) {
+export async function handleAgentApi(req, res, url, context = {}) {
   const pathname = url.pathname
   const parts = pathname.split('/').filter(Boolean)
 
@@ -85,7 +86,7 @@ export async function handleAgentApi(req, res, url) {
       error.statusCode = 400
       throw error
     }
-    const result = await runPrompt(sessionId, message, body?.selectedCapabilities, body?.command)
+    const result = await runPrompt(sessionId, message, body?.selectedCapabilities, body?.command, null, context)
     sendJson(res, 200, result)
     return
   }
@@ -160,7 +161,14 @@ export async function handleAgentApi(req, res, url) {
   // POST /api/agents/:sessionId — create/ensure agent
   if (req.method === 'POST' && parts.length === 3) {
     const body = await readJsonBody(req)
-    const session = await createAgent(sessionId, body)
+    let config
+    if (body?.modelRef || body?.model) {
+      const binding = await resolveModelBinding(body, { context, legacySnapshot: body?.model })
+      config = { ...body, model: binding.model, modelRef: binding.modelRef, modelAccessContext: context, resolvePersistedModel: true }
+    } else {
+      config = { ...body, modelAccessContext: context, resolvePersistedModel: true }
+    }
+    const session = await createAgent(sessionId, config)
     sendJson(res, 200, {
       sessionId: session.sessionId,
       status: session.status,
@@ -209,13 +217,14 @@ export async function handleAgentApi(req, res, url) {
   // POST /api/agents/:sessionId/model — update session model
   if (req.method === 'POST' && subPath === 'model') {
     const body = await readJsonBody(req)
-    const model = body?.model
-    if (!model) {
-      const error = new Error('Missing model in request body')
-      error.statusCode = 400
-      throw error
-    }
-    const result = updateSessionModel(sessionId, model)
+    const currentModel = getSessionState(sessionId)?.model
+    const binding = await resolveModelBinding(body, {
+      context,
+      currentModel,
+      allowCurrentHidden: true,
+      legacySnapshot: body?.model,
+    })
+    const result = updateSessionModel(sessionId, binding.model, binding.modelRef)
     sendJson(res, 200, result)
     return
   }
@@ -244,7 +253,7 @@ export async function handleAgentApi(req, res, url) {
 
   // POST /api/agents/:sessionId/continue — continue generation from last message (retry)
   if (req.method === 'POST' && subPath === 'continue') {
-    const result = await continueSession(sessionId)
+    const result = await continueSession(sessionId, context)
     sendJson(res, 200, result)
     return
   }

package/server/routes/backup.mjs

@@ -580,7 +580,13 @@ async function restoreValidatedBackup(backup, mode = 'replace') {
   return summary
 }
 
-export async function handleBackupApi(req, res, url) {
+export async function handleBackupApi(req, res, url, context = {}) {
+  if (context.isLocalRequest === false) {
+    const error = new Error('Backup import and export are available only on this computer.')
+    error.statusCode = 403
+    error.errorCode = 'backup_local_only'
+    throw error
+  }
   if (req.method === 'GET' && url.pathname === '/api/backup/export') {
     await ensureStorage()
     sendJson(res, 200, await buildBackup(url.searchParams.get('scope'), {