@inneranimalmedia/agentsam-sdk 2.6.3 → 2.6.4

package/src/local-fs/paths.js

@@ -0,0 +1,100 @@
+/**
+ * Path containment for local machine filesystem authority.
+ * Rejects NUL, traversal, and symlink escapes outside the approved root.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+/**
+ * @param {string} root
+ * @param {string} relativeOrAbs
+ * @returns {{ ok: true, abs: string, rel: string } | { ok: false, error: string, code: string }}
+ */
+export function resolveContainedPath(root, relativeOrAbs) {
+  if (typeof root !== 'string' || !root.trim()) {
+    return { ok: false, error: 'workspace_root_required', code: 'invalid_root' };
+  }
+  if (typeof relativeOrAbs !== 'string') {
+    return { ok: false, error: 'path_required', code: 'invalid_path' };
+  }
+  if (relativeOrAbs.includes('\0')) {
+    return { ok: false, error: 'nul_in_path', code: 'invalid_path' };
+  }
+
+  let rootReal;
+  try {
+    rootReal = fs.realpathSync(path.resolve(root));
+  } catch (err) {
+    return {
+      ok: false,
+      error: err instanceof Error ? err.message : String(err),
+      code: 'root_unresolvable',
+    };
+  }
+
+  const joined = path.isAbsolute(relativeOrAbs)
+    ? path.normalize(relativeOrAbs)
+    : path.resolve(rootReal, relativeOrAbs);
+
+  // Reject obvious escapes before realpath (missing parents still checked via prefix).
+  const relToRoot = path.relative(rootReal, joined);
+  if (relToRoot.startsWith('..') || path.isAbsolute(relToRoot)) {
+    return { ok: false, error: 'path_escape', code: 'path_escape' };
+  }
+
+  let absReal = joined;
+  try {
+    absReal = fs.realpathSync(joined);
+  } catch (err) {
+    // File may not exist yet (create/write) — ensure parent is inside root.
+    if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+      const parent = path.dirname(joined);
+      let parentReal;
+      try {
+        parentReal = fs.realpathSync(parent);
+      } catch (parentErr) {
+        // Walk up until an existing ancestor within root.
+        let cursor = parent;
+        let found = null;
+        while (cursor.startsWith(rootReal)) {
+          if (fs.existsSync(cursor)) {
+            try {
+              found = fs.realpathSync(cursor);
+              break;
+            } catch {
+              break;
+            }
+          }
+          const next = path.dirname(cursor);
+          if (next === cursor) break;
+          cursor = next;
+        }
+        if (!found || (found !== rootReal && !found.startsWith(rootReal + path.sep))) {
+          return {
+            ok: false,
+            error: parentErr instanceof Error ? parentErr.message : String(parentErr),
+            code: 'path_escape',
+          };
+        }
+        parentReal = found;
+      }
+      if (parentReal !== rootReal && !parentReal.startsWith(rootReal + path.sep)) {
+        return { ok: false, error: 'path_escape', code: 'path_escape' };
+      }
+      absReal = joined;
+    } else {
+      return {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+        code: 'path_unresolvable',
+      };
+    }
+  }
+
+  if (absReal !== rootReal && !absReal.startsWith(rootReal + path.sep)) {
+    return { ok: false, error: 'symlink_escape', code: 'path_escape' };
+  }
+
+  const rel = absReal === rootReal ? '.' : path.relative(rootReal, absReal).split(path.sep).join('/');
+  return { ok: true, abs: absReal, rel: rel || '.' };
+}

package/src/local-pty/server.js

@@ -1,12 +1,23 @@
 /**
- * Agent Sam local PTY — localhost WebSocket shell, no tunnel, no IAM.
- * Compatible with iam-pty wire format (raw bytes + JSON resize/slash).
+ * Agent Sam local PTY + filesystem — localhost WebSocket shell + /v1/fs HTTP.
+ * No tunnel, no IAM. Compatible with iam-pty wire format (raw bytes + JSON resize/slash).
  */
 import fs from 'node:fs';
 import http from 'node:http';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { WebSocketServer } from 'ws';
+import { createLocalFilesystem } from '../local-fs/index.js';
+import { resolveContainedPath } from '../local-fs/paths.js';
+import { getRepositoryFreshness } from '../local-fs/freshness.js';
+import {
+  mintWorkspaceCapability,
+  writeLocalRuntimeRecord,
+  extractCapability,
+  isAllowedStudioOrigin,
+  isLoopbackRemote,
+  WORKSPACE_CAPABILITY_HEADER,
+} from '../local-fs/capability.js';
 
 const DEFAULT_PORT = 3099;
 
@@ -20,6 +31,49 @@ function shellForPlatform() {
   return process.env.SHELL || '/bin/zsh';
 }
 
+function readJsonBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    req.on('data', (c) => chunks.push(c));
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8');
+      if (!raw) return resolve({});
+      try {
+        resolve(JSON.parse(raw));
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+/**
+ * @param {import('http').IncomingMessage} req
+ * @param {import('http').ServerResponse} res
+ * @param {number} status
+ * @param {object} body
+ * @param {{ allowOrigin?: string|null }} [opts]
+ */
+function sendJson(req, res, status, body, opts = {}) {
+  const origin = typeof req.headers.origin === 'string' ? req.headers.origin : '';
+  const allowOrigin = opts.allowOrigin !== undefined
+    ? opts.allowOrigin
+    : (isAllowedStudioOrigin(origin) ? (origin || null) : null);
+  /** @type {Record<string, string>} */
+  const headers = {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
+    'Access-Control-Allow-Headers': `Content-Type, Authorization, ${WORKSPACE_CAPABILITY_HEADER}`,
+  };
+  if (allowOrigin) {
+    headers['Access-Control-Allow-Origin'] = allowOrigin;
+    headers.Vary = 'Origin';
+  }
+  res.writeHead(status, headers);
+  res.end(JSON.stringify(body));
+}
+
 export function ensureNodePtySpawnHelperExecutable(options = {}) {
   const platform = options.platform || process.platform;
   const arch = options.arch || process.arch;
@@ -130,26 +184,165 @@ export function attachLocalPtySession({ ws, pty, shell, cwd, cols = 80, rows = 2
  */
 export async function startLocalPtyServer(opts = {}) {
   const pty = await loadPty(opts.pty);
-  const cwd = opts.cwd || process.cwd();
+  const cwd = path.resolve(opts.cwd || process.cwd());
   const requestedPort = opts.port === 0 ? 0 : parsePort(opts.port ?? process.env.PTY_PORT, DEFAULT_PORT);
   const host = opts.host || '127.0.0.1';
-  const shell = shellForPlatform();
-
-  const httpServer = http.createServer((req, res) => {
-    const path = (req.url || '/').split('?')[0];
-    if (path === '/health') {
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(
-        JSON.stringify({
-          ok: true,
-          service: 'agentsam-local-pty',
-          cwd,
-          port: Number(httpServer.address()?.port || requestedPort),
-          shell,
-        }),
-      );
+  if (host !== '127.0.0.1' && host !== 'localhost' && host !== '::1') {
+    throw new Error('local PTY/FS must bind loopback only (127.0.0.1)');
+  }
+  const shell = opts.shell || shellForPlatform();
+  const filesystem = createLocalFilesystem(cwd);
+  // Capability minted after bind so port is known; provisional id first.
+  /** @type {ReturnType<typeof mintWorkspaceCapability>|null} */
+  let capability = null;
+
+  const httpServer = http.createServer(async (req, res) => {
+    const url = new URL(req.url || '/', `http://${host}`);
+    const pathname = url.pathname;
+    const origin = typeof req.headers.origin === 'string' ? req.headers.origin : '';
+
+    if (req.method === 'OPTIONS') {
+      if (!isAllowedStudioOrigin(origin)) {
+        res.writeHead(403);
+        res.end();
+        return;
+      }
+      res.writeHead(204, {
+        'Access-Control-Allow-Origin': origin || 'http://127.0.0.1:8080',
+        'Access-Control-Allow-Methods': 'GET,POST,PUT,DELETE,OPTIONS',
+        'Access-Control-Allow-Headers': `Content-Type, Authorization, ${WORKSPACE_CAPABILITY_HEADER}`,
+        Vary: 'Origin',
+      });
+      res.end();
+      return;
+    }
+
+    if (pathname === '/health') {
+      sendJson(req, res, 200, {
+        ok: true,
+        service: 'agentsam-local-pty',
+        cwd,
+        root: cwd,
+        port: Number(httpServer.address()?.port || requestedPort),
+        shell,
+        filesystem: true,
+        filesystem_engine: filesystem.engine,
+        workspace_id: capability?.workspace_id || null,
+        capability_required: true,
+        binding: host,
+      });
       return;
     }
+
+    // Bootstrap: loopback-only claim of the authorized workspace capability.
+    // Does NOT accept an arbitrary root — root is always the process-bound cwd.
+    if (pathname === '/v1/workspace/bootstrap' && req.method === 'GET') {
+      if (!isLoopbackRemote(req)) {
+        return sendJson(req, res, 403, {
+          ok: false,
+          error: 'loopback_required',
+          code: 'WORKSPACE_BOOTSTRAP_DENIED',
+        });
+      }
+      if (origin && !isAllowedStudioOrigin(origin)) {
+        return sendJson(req, res, 403, {
+          ok: false,
+          error: 'origin_not_allowed',
+          code: 'WORKSPACE_BOOTSTRAP_DENIED',
+        }, { allowOrigin: null });
+      }
+      const requestedRoot = url.searchParams.get('root');
+      if (requestedRoot) {
+        const resolved = path.resolve(requestedRoot);
+        if (resolved !== cwd) {
+          return sendJson(req, res, 403, {
+            ok: false,
+            error: 'root_not_authorized',
+            code: 'WORKSPACE_ROOT_MISMATCH',
+            message: 'Cannot claim an arbitrary path. Start the runtime from the desired workspace root.',
+            authorized_root: cwd,
+            requested_root: resolved,
+          });
+        }
+      }
+      return sendJson(req, res, 200, {
+        ok: true,
+        ...capability,
+        freshness: getRepositoryFreshness(cwd),
+      });
+    }
+
+    if (pathname === '/v1/freshness' && req.method === 'GET') {
+      const gate = requireCapability(req, res, capability);
+      if (!gate) return;
+      return sendJson(req, res, 200, getRepositoryFreshness(cwd));
+    }
+
+    if (pathname === '/v1/fs' || pathname === '/v1/fs/') {
+      const gate = requireCapability(req, res, capability);
+      if (!gate) return;
+      return sendJson(req, res, 200, {
+        ok: true,
+        root: filesystem.root,
+        workspace_id: capability.workspace_id,
+        engine: filesystem.engine,
+        endpoints: ['list', 'stat', 'read', 'write', 'create', 'rename', 'remove', 'mkdir'],
+      });
+    }
+
+    if (pathname.startsWith('/v1/fs/')) {
+      const gate = requireCapability(req, res, capability);
+      if (!gate) return;
+      try {
+        const action = pathname.slice('/v1/fs/'.length).replace(/\/$/, '');
+        const qPath = url.searchParams.get('path') || '.';
+        if (req.method === 'GET' && action === 'list') {
+          const recursive = url.searchParams.get('recursive') === '1' || url.searchParams.get('recursive') === 'true';
+          return sendJson(req, res, 200, filesystem.list(qPath, { recursive, maxDepth: 5 }));
+        }
+        if (req.method === 'GET' && action === 'stat') {
+          return sendJson(req, res, 200, filesystem.stat(qPath));
+        }
+        if (req.method === 'GET' && action === 'read') {
+          return sendJson(req, res, 200, filesystem.read(qPath));
+        }
+        if (req.method === 'POST' || req.method === 'PUT' || req.method === 'DELETE') {
+          const body = await readJsonBody(req);
+          if (action === 'write') {
+            return sendJson(req, res, 200, filesystem.write(body.path || qPath, body.content ?? '', {
+              expectedVersion: body.expectedVersion ?? body.expected_version,
+              overwrite: Boolean(body.overwrite),
+            }));
+          }
+          if (action === 'create') {
+            return sendJson(req, res, 200, filesystem.create(body.path || qPath, body.content ?? ''));
+          }
+          if (action === 'rename') {
+            return sendJson(req, res, 200, filesystem.rename(body.from || qPath, body.to, {
+              expectedVersion: body.expectedVersion ?? body.expected_version,
+            }));
+          }
+          if (action === 'remove' || action === 'delete') {
+            return sendJson(req, res, 200, filesystem.remove(body.path || qPath, {
+              expectedVersion: body.expectedVersion ?? body.expected_version,
+              recursive: Boolean(body.recursive),
+            }));
+          }
+          if (action === 'mkdir') {
+            return sendJson(req, res, 200, filesystem.mkdir(body.path || qPath));
+          }
+        }
+        sendJson(req, res, 404, { ok: false, error: 'unknown_fs_action', action });
+      } catch (err) {
+        sendJson(req, res, 400, {
+          ok: false,
+          error: err instanceof Error ? err.message : String(err),
+          code: 'fs_request_failed',
+        });
+      }
+      return;
+    }
+
     res.writeHead(404);
     res.end('not found');
   });
@@ -158,9 +351,47 @@ export async function startLocalPtyServer(opts = {}) {
 
   wss.on('connection', (ws, req) => {
     const url = new URL(req.url || '/', `http://${host}`);
-    const sessionCwd = url.searchParams.get('cwd')?.trim() || cwd;
+    const cap = extractCapability(req, capability?.capability);
+    const qCap = url.searchParams.get('capability') || '';
+    const okCap = (capability && qCap && qCap === capability.capability) || cap.ok;
+    if (!okCap) {
+      ws.send(JSON.stringify({
+        type: 'error',
+        code: 'WORKSPACE_CAPABILITY_REQUIRED',
+        message: 'PTY attach requires workspace capability from /v1/workspace/bootstrap',
+      }));
+      ws.close();
+      return;
+    }
+
+    // Session cwd must stay inside the authorized filesystem root — never escape.
+    let sessionCwd = cwd;
+    const requestedCwd = url.searchParams.get('cwd')?.trim();
+    if (requestedCwd) {
+      const abs = path.isAbsolute(requestedCwd) ? path.resolve(requestedCwd) : path.resolve(cwd, requestedCwd);
+      if (abs !== cwd) {
+        const rel = path.relative(cwd, abs);
+        const contained = resolveContainedPath(cwd, rel || '.');
+        if (!contained.ok) {
+          ws.send(JSON.stringify({
+            type: 'error',
+            code: 'WORKSPACE_ROOT_MISMATCH',
+            message: 'PTY cwd must equal the authorized workspace root (or a contained path).',
+            authorized_root: cwd,
+            requested: abs,
+          }));
+          ws.close();
+          return;
+        }
+        sessionCwd = contained.abs;
+      } else {
+        sessionCwd = cwd;
+      }
+    }
+
     const cols = parsePort(url.searchParams.get('cols'), 80);
     const rows = parsePort(url.searchParams.get('rows'), 24);
+    const sessionId = `pty_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
 
     attachLocalPtySession({
       ws,
@@ -170,7 +401,17 @@ export async function startLocalPtyServer(opts = {}) {
       cols,
       rows,
       env: process.env,
+      sessionId,
     });
+
+    ws.send(JSON.stringify({
+      type: 'workspace_identity',
+      workspace_id: capability.workspace_id,
+      root: cwd,
+      session_cwd: sessionCwd,
+      session_id: sessionId,
+      runtimeBaseUrl: capability.runtimeBaseUrl,
+    }));
   });
 
   await new Promise((resolve) => {
@@ -178,13 +419,22 @@ export async function startLocalPtyServer(opts = {}) {
   });
   const boundPort = Number(httpServer.address()?.port || requestedPort);
 
+  capability = mintWorkspaceCapability({ root: cwd, port: boundPort, host });
+  const runtimeFile = writeLocalRuntimeRecord(capability);
+
   return {
     port: boundPort,
     host,
     cwd,
     shell,
+    filesystem,
+    capability,
+    runtimeFile,
+    workspace_id: capability.workspace_id,
     url: `ws://${host}:${boundPort}`,
     healthUrl: `http://${host}:${boundPort}/health`,
+    fsBaseUrl: `http://${host}:${boundPort}/v1/fs`,
+    bootstrapUrl: `http://${host}:${boundPort}/v1/workspace/bootstrap`,
     close: () =>
       new Promise((resolve, reject) => {
         wss.close(() => {
@@ -193,3 +443,29 @@ export async function startLocalPtyServer(opts = {}) {
       }),
   };
 }
+
+/**
+ * @param {import('http').IncomingMessage} req
+ * @param {import('http').ServerResponse} res
+ * @param {ReturnType<typeof mintWorkspaceCapability>|null} capability
+ */
+function requireCapability(req, res, capability) {
+  if (!capability) {
+    sendJson(req, res, 503, { ok: false, error: 'capability_not_ready', code: 'WORKSPACE_CAPABILITY_REQUIRED' });
+    return false;
+  }
+  const gate = extractCapability(req, capability.capability);
+  if (!gate.ok) {
+    sendJson(req, res, 401, {
+      ok: false,
+      error: 'workspace_capability_required',
+      code: 'WORKSPACE_CAPABILITY_REQUIRED',
+      authorization: {
+        required: ['workspace.capability'],
+        bootstrap: '/v1/workspace/bootstrap',
+      },
+    });
+    return false;
+  }
+  return true;
+}

package/src/mcp/client.js

@@ -8,7 +8,7 @@ function clean(value) {
 export function buildHeaders(serverConfig = {}) {
   const headers = {
     'Accept': 'application/json, text/event-stream',
-    'User-Agent': 'AgentSam-SDK/2.6.2 (MCP Client)',
+    'User-Agent': 'AgentSam-SDK/2.6.3 (MCP Client)',
   };
   const token = clean(serverConfig.auth?.token);
   if (token) {
@@ -103,7 +103,7 @@ export async function listMcpTools(serverConfig = {}, options = {}) {
     const transport = new SSEClientTransport(new URL(url), {
       requestInit: { headers },
     });
-    const client = new Client({ name: 'agentsam-sdk', version: '2.6.2' }, { capabilities: {} });
+    const client = new Client({ name: 'agentsam-sdk', version: '2.6.3' }, { capabilities: {} });
     await client.connect(transport);
     const toolsResult = await client.listTools();
     await transport.close();

package/src/models/ai-access-onboarding.js

@@ -0,0 +1,112 @@
+/**
+ * Onboarding guidance when a user has no usable AI path yet.
+ *
+ * Paths (any one unlocks AgentSam model options):
+ *   1. Local Ollama + at least one model
+ *   2. Provider API key (OpenAI / Anthropic / Gemini / …) → their allotted models
+ *   3. Signed-in Local Studio identity + Cloudflare OAuth (Workers AI / account tools)
+ */
+
+export const LOCAL_STUDIO_ORIGIN = 'https://agentsam.inneranimalmedia.com';
+
+/** Identity login (Sign in with Cloudflare) — PKCE public client. */
+export const CF_OAUTH_LOGIN_START = `${LOCAL_STUDIO_ORIGIN}/api/oauth/cloudflare/start?next=/agentsam`;
+
+/** Resource connector (MCP / Workers / D1) — same CF OAuth client, different callback. */
+export const CF_OAUTH_CONNECT_START = `${LOCAL_STUDIO_ORIGIN}/api/connections/cloudflare/start`;
+
+/** Login portal with explicit next (desktop / CLI). */
+export const LOCAL_STUDIO_LOGIN = `${LOCAL_STUDIO_ORIGIN}/auth/login?next=/agentsam`;
+
+/**
+ * Redirect URIs that must be registered on the Cloudflare OAuth client
+ * "AgentSam Local Studio" (PKCE, Token Authentication Method = None).
+ */
+export const CF_OAUTH_REQUIRED_REDIRECTS = Object.freeze([
+  `${LOCAL_STUDIO_ORIGIN}/api/oauth/cloudflare/callback`,
+  `${LOCAL_STUDIO_ORIGIN}/api/connections/cloudflare/callback`,
+  'http://localhost:3000/api/connections/cloudflare/callback',
+  'http://localhost:3000/api/oauth/cloudflare/callback',
+]);
+
+/**
+ * @param {{ inventory?: object, ollama?: object, providers?: object[] }} discovered
+ *   Shape compatible with discoverIngestModelOptions() / collectModelsStatus().
+ */
+export function assessAiAccess(discovered = {}) {
+  const providers = discovered.inventory?.providers
+    || discovered.providers
+    || [];
+  const configuredProviders = providers.filter((p) => p?.configured === true);
+  const ollamaOnline = Boolean(discovered.ollama?.online || discovered.inventory?.local?.online);
+  const ollamaModels = discovered.ollama?.models || discovered.inventory?.local?.models || [];
+  const hasOllamaModels = ollamaOnline && Array.isArray(ollamaModels) && ollamaModels.length > 0;
+  const hasProviderKeys = configuredProviders.length > 0;
+  const embedOptions = Array.isArray(discovered.options)
+    ? discovered.options.filter((o) => o.value && o.value !== 'none')
+    : [];
+
+  const ready = hasOllamaModels || hasProviderKeys || embedOptions.length > 0;
+
+  return {
+    ready,
+    hasOllamaModels,
+    hasProviderKeys,
+    configuredProviders: configuredProviders.map((p) => p.id),
+    ollamaOnline,
+    ollamaModelCount: hasOllamaModels ? ollamaModels.length : 0,
+    embedOptionCount: embedOptions.length,
+  };
+}
+
+/**
+ * Human-readable onboarding block for CLI notes / stderr.
+ * @param {ReturnType<typeof assessAiAccess>} access
+ * @param {{ wantCloudAi?: boolean }} [opts]
+ */
+export function formatAiAccessOnboarding(access, opts = {}) {
+  const lines = [];
+  if (access.ready) {
+    lines.push('AI access: ready');
+    if (access.hasProviderKeys) {
+      lines.push(`  providers  ${access.configuredProviders.join(', ')}`);
+    }
+    if (access.hasOllamaModels) {
+      lines.push(`  ollama     online · ${access.ollamaModelCount} model(s)`);
+    }
+    if (access.embedOptionCount) {
+      lines.push(`  embed menu ${access.embedOptionCount} option(s)`);
+    }
+    return lines.join('\n');
+  }
+
+  lines.push('AI access: not configured yet');
+  lines.push('');
+  lines.push('Pick ONE path to unlock AgentSam model options:');
+  lines.push('');
+  lines.push('  1) Local models (Ollama) — free, offline');
+  lines.push('       https://ollama.com/download');
+  lines.push('       ollama pull mxbai-embed-large');
+  lines.push('       ollama pull qwen2.5-coder');
+  lines.push('       agentsam ollama status');
+  lines.push('');
+  lines.push('  2) Provider API key — use models your key is allotted');
+  lines.push('       agentsam providers');
+  lines.push('       (OpenAI · Anthropic · Gemini · Cursor · xAI · Cloudflare token)');
+  lines.push('');
+  lines.push('  3) Local Studio identity + Cloudflare OAuth');
+  lines.push('       (Workers AI / account tools / MCP connector)');
+  lines.push(`       Login:  ${LOCAL_STUDIO_LOGIN}`);
+  lines.push(`       CF sign-in: ${CF_OAUTH_LOGIN_START}`);
+  lines.push(`       CF connect: ${CF_OAUTH_CONNECT_START}`);
+  if (opts.wantCloudAi) {
+    lines.push('');
+    lines.push('  Cloudflare OAuth client must allow these redirect URIs:');
+    for (const uri of CF_OAUTH_REQUIRED_REDIRECTS) {
+      lines.push(`       • ${uri}`);
+    }
+  }
+  lines.push('');
+  lines.push('AST/text-only indexing still works with embedding: none ($0).');
+  return lines.join('\n');
+}

package/src/models/discovery.js

@@ -315,11 +315,19 @@ export async function discoverCloudflareModels(apiToken, accountId, fetchImpl =
       .map((row) => {
         const id = clean(row?.name);
         const task = cloudflareTaskName(row?.task);
-        if (!id || task.toLowerCase() !== 'text generation') return null;
+        const taskLower = task.toLowerCase();
+        // Text Generation = chat/agent pool. Text Embeddings = Vectorize / Workers AI embed pool.
+        // Never drop embeddings here — chat allowlisting happens in inventory curation only.
+        if (!id || (taskLower !== 'text generation' && taskLower !== 'text embeddings')) return null;
+        const isEmbed = taskLower === 'text embeddings';
         return baseRecord('cloudflare', id, {
           label: id,
           source_url: url,
-          capabilities: { workers_ai: true },
+          capabilities: {
+            workers_ai: true,
+            embeddings: isEmbed,
+            agent_runtime: !isEmbed,
+          },
           metadata: {
             task,
             author: clean(row?.author) || null,

package/src/models/inventory-core.js

@@ -42,7 +42,15 @@ export function providerIdForService(serviceName) {
 
 export function filterWorkersAiCurated(models = [], options = {}) {
   if (options.curated === false) return [...models];
-  return models.filter((row) => CURATED.has(String(row?.provider_model_id || row?.model_id || '')));
+  // Chat/agent pool: curated allowlist. Embedding models always pass —
+  // Vectorize / Workers AI embed lanes must not be limited by the chat allowlist.
+  return models.filter((row) => {
+    const id = String(row?.provider_model_id || row?.model_id || '');
+    const caps = row?.capabilities || {};
+    const task = String(row?.metadata?.task || '').toLowerCase();
+    if (caps.embeddings === true || task === 'text embeddings' || /embed/i.test(id)) return true;
+    return CURATED.has(id);
+  });
 }
 
 /**