nolo-cli 0.1.18 → 0.1.20

package/agent-runtime/openAiCompatibleProvider.ts

@@ -0,0 +1,70 @@
+import type {
+  AgentRuntimeChatMessage,
+  AgentRuntimeResult,
+} from "./types";
+
+export type OpenAiCompatibleProviderConfig = {
+  model: string;
+  endpoint: string;
+  apiKey: string;
+  provider: string;
+  requestOptions: Record<string, number | string>;
+};
+
+type OpenAiCompatibleTool = Record<string, unknown>;
+
+function toOpenAiCompatibleMessages(messages: AgentRuntimeChatMessage[]) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: message.content ?? "",
+    ...(message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}),
+    ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
+    ...(message.reasoning_content ? { reasoning_content: message.reasoning_content } : {}),
+  }));
+}
+
+export function buildOpenAiCompatibleChatCompletionRequest(args: {
+  providerConfig: OpenAiCompatibleProviderConfig;
+  messages: AgentRuntimeChatMessage[];
+  tools?: OpenAiCompatibleTool[];
+}) {
+  const body = {
+    model: args.providerConfig.model,
+    messages: toOpenAiCompatibleMessages(args.messages),
+    stream: false,
+    ...args.providerConfig.requestOptions,
+    ...(args.tools && args.tools.length > 0 ? { tools: args.tools } : {}),
+  };
+  return {
+    url: args.providerConfig.endpoint,
+    init: {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...(args.providerConfig.apiKey
+          ? { Authorization: `Bearer ${args.providerConfig.apiKey}` }
+          : {}),
+      },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+export function parseOpenAiCompatibleChatCompletionResponse(args: {
+  providerConfig: OpenAiCompatibleProviderConfig;
+  data: any;
+  trace: AgentRuntimeChatMessage[];
+}): AgentRuntimeResult {
+  const choiceMessage = args.data?.choices?.[0]?.message ?? {};
+  return {
+    content: String(choiceMessage?.content ?? ""),
+    model: args.providerConfig.model,
+    provider: args.providerConfig.provider,
+    ...(Array.isArray(choiceMessage?.tool_calls) ? { tool_calls: choiceMessage.tool_calls } : {}),
+    ...(typeof choiceMessage?.reasoning_content === "string" && choiceMessage.reasoning_content
+      ? { reasoning_content: choiceMessage.reasoning_content }
+      : {}),
+    usage: args.data?.usage,
+    trace: args.trace,
+  };
+}

package/agent-runtime/openAiCompatibleProviderConfig.ts

@@ -0,0 +1,38 @@
+import type { AgentRuntimeAgentConfig } from "./hostAdapter";
+import type { OpenAiCompatibleProviderConfig } from "./openAiCompatibleProvider";
+import { pickAgentRuntimeInferenceOptions } from "./agentConfigOptions";
+
+type EnvLike = Record<string, string | undefined>;
+
+function trimTrailingSlash(value: string) {
+  return value.replace(/\/+$/, "");
+}
+
+function resolveChatCompletionsEndpoint(value: string) {
+  const trimmed = trimTrailingSlash(value.trim());
+  return trimmed.endsWith("/chat/completions")
+    ? trimmed
+    : `${trimmed}/chat/completions`;
+}
+
+function resolveOpenAiCompatibleBaseUrl(env: EnvLike) {
+  return env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+}
+
+function resolveOpenAiCompatibleApiKey(env: EnvLike) {
+  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
+}
+
+export function resolveOpenAiCompatibleProviderConfig(args: {
+  agentConfig: AgentRuntimeAgentConfig;
+  env: EnvLike;
+}): OpenAiCompatibleProviderConfig {
+  const customProviderUrl = args.agentConfig.customProviderUrl?.trim();
+  return {
+    model: args.agentConfig.model || "gpt-4.1-mini",
+    endpoint: resolveChatCompletionsEndpoint(customProviderUrl || resolveOpenAiCompatibleBaseUrl(args.env)),
+    apiKey: resolveOpenAiCompatibleApiKey(args.env),
+    provider: args.agentConfig.provider || "openai-compatible",
+    requestOptions: pickAgentRuntimeInferenceOptions(args.agentConfig),
+  };
+}

package/agent-runtime/platformChatProvider.ts

@@ -0,0 +1,241 @@
+import type { AgentRuntimeAgentConfig } from "./hostAdapter";
+import type {
+  AgentRuntimeChatMessage,
+  AgentRuntimeResult,
+} from "./types";
+import { pickAgentRuntimeInferenceOptions } from "./agentConfigOptions";
+
+type EnvLike = Record<string, string | undefined>;
+
+const CHAT_PROXY_PATH = "/api/v1/chat";
+
+const PROVIDER_ENDPOINTS: Record<string, string> = {
+  deepinfra: "https://api.deepinfra.com/v1/openai/chat/completions",
+  deepseek: "https://api.deepseek.com/chat/completions",
+  fireworks: "https://api.fireworks.ai/inference/v1/chat/completions",
+  google: "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+  mistral: "https://api.mistral.ai/v1/chat/completions",
+  mimo: "https://token-plan-cn.xiaomimimo.com/v1/chat/completions",
+  openai: "https://api.openai.com/v1/chat/completions",
+  openrouter: "https://openrouter.ai/api/v1/chat/completions",
+};
+
+export type PlatformChatProviderConfig = {
+  serverUrl: string;
+  authToken: string;
+  model: string;
+  provider: string;
+  endpoint: string;
+  requestOptions: Record<string, number | string>;
+  apiKey?: string;
+  apiSource?: string;
+};
+
+type PlatformChatTool = Record<string, unknown>;
+
+function trimTrailingSlash(value: string) {
+  return value.trim().replace(/\/+$/, "");
+}
+
+function resolveChatCompletionsEndpoint(value: string) {
+  const trimmed = trimTrailingSlash(value);
+  return trimmed.endsWith("/chat/completions")
+    ? trimmed
+    : `${trimmed}/chat/completions`;
+}
+
+function resolvePlatformServerUrl(env: EnvLike) {
+  return trimTrailingSlash(env.NOLO_SERVER || env.BASE_URL || "https://nolo.chat");
+}
+
+function resolvePlatformAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
+
+function resolveProviderEndpoint(agentConfig: AgentRuntimeAgentConfig) {
+  const customProviderUrl = agentConfig.customProviderUrl?.trim();
+  if (customProviderUrl) return resolveChatCompletionsEndpoint(customProviderUrl);
+
+  const provider = agentConfig.provider?.trim().toLowerCase();
+  if (!provider) {
+    throw new Error("Platform chat provider requires agentConfig.provider.");
+  }
+
+  const endpoint = PROVIDER_ENDPOINTS[provider];
+  if (!endpoint) {
+    throw new Error(`Platform chat provider does not support provider "${provider}".`);
+  }
+  return endpoint;
+}
+
+function shouldDisableThinking(providerConfig: PlatformChatProviderConfig) {
+  return (
+    providerConfig.provider.toLowerCase() === "mimo" ||
+    /xiaomimimo\.com/i.test(providerConfig.endpoint)
+  );
+}
+
+function toOpenAiCompatibleMessages(messages: AgentRuntimeChatMessage[]) {
+  return messages.map((message) => ({
+    role: message.role,
+    content: message.content ?? "",
+    ...(message.tool_call_id ? { tool_call_id: message.tool_call_id } : {}),
+    ...(Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {}),
+    ...(message.reasoning_content ? { reasoning_content: message.reasoning_content } : {}),
+  }));
+}
+
+export function resolvePlatformChatProviderConfig(args: {
+  agentConfig: AgentRuntimeAgentConfig;
+  env: EnvLike;
+}): PlatformChatProviderConfig {
+  const provider = args.agentConfig.provider || args.agentConfig.apiSource || "openai";
+  return {
+    serverUrl: resolvePlatformServerUrl(args.env),
+    authToken: resolvePlatformAuthToken(args.env),
+    model: args.agentConfig.model || "gpt-4.1-mini",
+    provider,
+    endpoint: resolveProviderEndpoint(args.agentConfig),
+    requestOptions: pickAgentRuntimeInferenceOptions(args.agentConfig),
+    ...(typeof args.agentConfig.rawRecord?.apiKey === "string"
+      ? { apiKey: args.agentConfig.rawRecord.apiKey.trim() }
+      : {}),
+    ...(args.agentConfig.apiSource ? { apiSource: args.agentConfig.apiSource } : {}),
+  };
+}
+
+export function buildPlatformChatCompletionRequest(args: {
+  providerConfig: PlatformChatProviderConfig;
+  messages: AgentRuntimeChatMessage[];
+  tools?: PlatformChatTool[];
+}) {
+  const body = {
+    model: args.providerConfig.model,
+    messages: toOpenAiCompatibleMessages(args.messages),
+    stream: false,
+    ...args.providerConfig.requestOptions,
+    ...(args.tools && args.tools.length > 0 ? { tools: args.tools, tool_choice: "auto" } : {}),
+    ...(shouldDisableThinking(args.providerConfig) ? { thinking: { type: "disabled" } } : {}),
+    url: args.providerConfig.endpoint,
+    provider: args.providerConfig.provider,
+    ...(args.providerConfig.apiSource ? { apiSource: args.providerConfig.apiSource } : {}),
+    ...(args.providerConfig.apiKey ? { KEY: args.providerConfig.apiKey } : {}),
+  };
+
+  return {
+    url: `${args.providerConfig.serverUrl}${CHAT_PROXY_PATH}`,
+    init: {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${args.providerConfig.authToken}`,
+      },
+      body: JSON.stringify(body),
+    },
+  };
+}
+
+function tryParseJson(raw: string) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+function extractJsonObjects(raw: string) {
+  const objects: any[] = [];
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+
+  for (let index = 0; index < raw.length; index += 1) {
+    const char = raw[index];
+    if (inString) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === "\"") {
+        inString = false;
+      }
+      continue;
+    }
+
+    if (char === "\"") {
+      inString = true;
+      continue;
+    }
+    if (char === "{") {
+      if (depth === 0) start = index;
+      depth += 1;
+      continue;
+    }
+    if (char !== "}" || depth === 0) continue;
+
+    depth -= 1;
+    if (depth === 0 && start >= 0) {
+      const parsed = tryParseJson(raw.slice(start, index + 1));
+      if (parsed) objects.push(parsed);
+      start = -1;
+    }
+  }
+
+  return objects;
+}
+
+export function parsePlatformChatCompletionData(raw: string) {
+  const direct = tryParseJson(raw.trim());
+  if (direct) return direct;
+
+  const objects = extractJsonObjects(raw);
+  return objects.find((object) => Array.isArray(object?.choices)) ?? objects[0] ?? {};
+}
+
+export function parsePlatformChatCompletionResponse(args: {
+  providerConfig: PlatformChatProviderConfig;
+  data: any;
+  trace: AgentRuntimeChatMessage[];
+}): AgentRuntimeResult {
+  const choiceMessage = args.data?.choices?.[0]?.message ?? {};
+  return {
+    content: String(choiceMessage?.content ?? ""),
+    model: args.providerConfig.model,
+    provider: args.providerConfig.provider,
+    ...(Array.isArray(choiceMessage?.tool_calls) ? { tool_calls: choiceMessage.tool_calls } : {}),
+    ...(typeof choiceMessage?.reasoning_content === "string" && choiceMessage.reasoning_content
+      ? { reasoning_content: choiceMessage.reasoning_content }
+      : {}),
+    usage: args.data?.usage,
+    trace: args.trace,
+  };
+}
+
+export function canUsePlatformChatProvider(env: EnvLike) {
+  return Boolean(resolvePlatformAuthToken(env));
+}
+
+export function hasDirectOpenAiCompatibleProvider(env: EnvLike) {
+  return Boolean(
+    env.NOLO_LOCAL_OPENAI_API_KEY ||
+      env.OPENAI_API_KEY ||
+      env.NOLO_LOCAL_OPENAI_BASE_URL ||
+      env.OPENAI_BASE_URL ||
+      env.OLLAMA_BASE_URL
+  );
+}
+
+function agentRequiresPlatformChatProvider(agentConfig?: AgentRuntimeAgentConfig) {
+  return agentConfig?.apiSource === "platform" || agentConfig?.rawRecord?.useServerProxy === true;
+}
+
+export function shouldUsePlatformChatProvider(
+  env: EnvLike,
+  agentConfig?: AgentRuntimeAgentConfig
+) {
+  if (agentRequiresPlatformChatProvider(agentConfig)) return true;
+  if (env.NOLO_LOCAL_LLM === "platform") return true;
+  if (env.NOLO_LOCAL_LLM === "direct") return false;
+  return !hasDirectOpenAiCompatibleProvider(env) && canUsePlatformChatProvider(env);
+}

package/agent-runtime/taskWorkspace.ts

@@ -0,0 +1,193 @@
+import {
+  lstat,
+  mkdir,
+  readdir,
+  readFile,
+  readlink,
+  rm,
+  symlink,
+} from "node:fs/promises";
+import { dirname, join, resolve, sep } from "node:path";
+
+type EnvLike = Record<string, string | undefined>;
+
+export type PreparedGitTaskWorkspace = {
+  path: string;
+  branchName?: string;
+};
+
+export type WorkspacePackageLink = {
+  name: string;
+  target: string;
+  linkPath: string;
+};
+
+function safeTaskWorkspacePathSegment(input: string) {
+  return input.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "agent";
+}
+
+function createTaskWorkspaceId() {
+  return Date.now().toString(36).toUpperCase();
+}
+
+async function runGitForTaskWorkspace(args: string[], cwd: string) {
+  const proc = Bun.spawn(["git", ...args], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "ignore",
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    throw new Error(stderr.trim() || stdout.trim() || `git ${args.join(" ")} failed`);
+  }
+  return stdout.trim();
+}
+
+function packageLinkPath(nodeModulesPath: string, packageName: string) {
+  if (!packageName.startsWith("@")) {
+    return join(nodeModulesPath, packageName);
+  }
+  const [scope, name] = packageName.split("/");
+  if (!scope || !name) {
+    throw new Error(`Invalid scoped package name: ${packageName}`);
+  }
+  return join(nodeModulesPath, scope, name);
+}
+
+async function readPackageName(packageJsonPath: string) {
+  const text = await readFile(packageJsonPath, "utf8");
+  const parsed = JSON.parse(text) as { name?: unknown };
+  return typeof parsed.name === "string" && parsed.name.trim()
+    ? parsed.name.trim()
+    : null;
+}
+
+export async function collectWorkspacePackageLinks(workspacePath: string) {
+  const packagesRoot = join(workspacePath, "packages");
+  const packageDirs = await readdir(packagesRoot, { withFileTypes: true }).catch(
+    () => []
+  );
+  const nodeModulesPath = join(workspacePath, "node_modules");
+  const links: WorkspacePackageLink[] = [];
+
+  for (const entry of packageDirs) {
+    if (!entry.isDirectory()) continue;
+    const target = join(packagesRoot, entry.name);
+    const name = await readPackageName(join(target, "package.json")).catch(
+      () => null
+    );
+    if (!name) continue;
+    links.push({
+      name,
+      target,
+      linkPath: packageLinkPath(nodeModulesPath, name),
+    });
+  }
+
+  return links;
+}
+
+async function ensureWorkspacePackageLink(link: WorkspacePackageLink) {
+  await mkdir(dirname(link.linkPath), { recursive: true });
+  const existing = await Bun.file(link.linkPath).stat().catch(() => null);
+  if (existing) {
+    const existingTarget = await readlinkIfSymlink(link.linkPath);
+    if (
+      existingTarget &&
+      resolve(dirname(link.linkPath), existingTarget) === resolve(link.target)
+    ) {
+      return false;
+    }
+    if (!existingTarget) {
+      throw new Error(`Cannot replace non-symlink workspace package path: ${link.linkPath}`);
+    }
+    await rm(link.linkPath, { force: true });
+  }
+  await symlink(link.target, link.linkPath, "dir");
+  return true;
+}
+
+async function readlinkIfSymlink(path: string) {
+  const stat = await lstat(path).catch(() => null);
+  if (!stat?.isSymbolicLink()) return null;
+  return readlink(path);
+}
+
+function isInsideWorkspace(workspacePath: string, path: string) {
+  const workspaceRoot = resolve(workspacePath);
+  const resolvedPath = resolve(path);
+  return resolvedPath === workspaceRoot || resolvedPath.startsWith(`${workspaceRoot}${sep}`);
+}
+
+function isFormalTaskWorkspacePath(path: string) {
+  return resolve(path).split(/[\\/]+/).includes(".worktrees");
+}
+
+async function ensureWorkspaceNodeModulesDirectory(workspacePath: string) {
+  const nodeModulesPath = join(workspacePath, "node_modules");
+  const symlinkTarget = await readlinkIfSymlink(nodeModulesPath);
+  if (symlinkTarget) {
+    const resolvedTarget = resolve(dirname(nodeModulesPath), symlinkTarget);
+    if (!isInsideWorkspace(workspacePath, resolvedTarget)) {
+      await rm(nodeModulesPath, { force: true });
+    }
+  }
+  await mkdir(nodeModulesPath, { recursive: true });
+}
+
+export async function ensureWorkspacePackageLinks(workspacePath: string) {
+  const links = await collectWorkspacePackageLinks(workspacePath);
+  if (links.length === 0) {
+    return {
+      workspacePath,
+      links,
+      createdOrUpdated: 0,
+    };
+  }
+  await ensureWorkspaceNodeModulesDirectory(workspacePath);
+  let createdOrUpdated = 0;
+  for (const link of links) {
+    if (await ensureWorkspacePackageLink(link)) {
+      createdOrUpdated += 1;
+    }
+  }
+  return {
+    workspacePath,
+    links,
+    createdOrUpdated,
+  };
+}
+
+export async function prepareGitTaskWorkspace(args: {
+  agentKey: string;
+  cwd?: string;
+  env?: EnvLike;
+}): Promise<PreparedGitTaskWorkspace> {
+  if (args.env?.NOLO_LOCAL_WORKTREE) {
+    await ensureWorkspacePackageLinks(args.env.NOLO_LOCAL_WORKTREE);
+    return { path: args.env.NOLO_LOCAL_WORKTREE };
+  }
+  const cwd = args.cwd ?? process.cwd();
+  const root = await runGitForTaskWorkspace(["rev-parse", "--show-toplevel"], cwd);
+  if (isFormalTaskWorkspacePath(root)) {
+    await ensureWorkspacePackageLinks(root);
+    return { path: root };
+  }
+  const parent = join(root, ".worktrees");
+  const safeAgent = safeTaskWorkspacePathSegment(args.agentKey);
+  const taskId = createTaskWorkspaceId();
+  const workspacePath = join(parent, `nolo-agent-${safeAgent}-${taskId}`);
+  const branchName = `nolo-agent-${safeAgent}-${taskId}`;
+  await runGitForTaskWorkspace(["worktree", "add", workspacePath, "-b", branchName, "HEAD"], root);
+  await ensureWorkspacePackageLinks(workspacePath);
+  return { path: workspacePath, branchName };
+}
+
+export function formatPreparedGitTaskWorkspace(workspace: PreparedGitTaskWorkspace) {
+  return `[nolo] task worktree: ${workspace.path}${workspace.branchName ? ` (branch ${workspace.branchName})` : ""}\n`;
+}

package/agent-runtime/types.ts

@@ -33,6 +33,7 @@ export interface AgentRuntimeChatMessage {
   content: AgentRuntimeMessageContent;
   tool_call_id?: string;
   tool_calls?: AgentRuntimeToolCall[];
+  tool_result_metadata?: Record<string, unknown>;
   reasoning_content?: string;
   cybotKey?: string;
   agentKey?: string;
@@ -52,6 +53,7 @@ export interface AgentRuntimeResult {
   usage?: Record<string, any>;
   trace?: AgentRuntimeChatMessage[];
   tool_calls?: AgentRuntimeToolCall[];
+  reasoning_content?: string;
   runtimeToolNames?: string[];
   toolCallCount?: number;
   policyState?: unknown;

package/agent-runtime/workspaceSession.ts

@@ -0,0 +1,76 @@
+// Runtime workspace sessions describe where code tools execute.
+// They are intentionally separate from product Spaces (`spaceId`, shared content, membership).
+export type WorkspaceSessionMode = "current" | "task-worktree";
+
+export type PreparedTaskWorkspace = {
+  path: string;
+  branchName?: string;
+};
+
+export type PrepareTaskWorkspace = (args: {
+  agentKey: string;
+  env?: Record<string, string | undefined>;
+}) => Promise<PreparedTaskWorkspace>;
+
+export type WorkspaceSession =
+  | {
+      kind: "current";
+      workspaceRoot: string;
+      explicitCwd: boolean;
+    }
+  | {
+      kind: "task-worktree";
+      workspaceRoot: string;
+      explicitCwd: false;
+      branchName?: string;
+    };
+
+export function createWorkspaceSession(args: {
+  cwd?: string;
+  defaultCwd?: string;
+}): WorkspaceSession {
+  return {
+    kind: "current",
+    workspaceRoot: args.cwd ?? args.defaultCwd ?? process.cwd(),
+    explicitCwd: Boolean(args.cwd),
+  };
+}
+
+export async function activateWorkspaceSession(
+  session: WorkspaceSession,
+  args: {
+    agentKey: string;
+    mode: WorkspaceSessionMode;
+    env?: Record<string, string | undefined>;
+    prepareTaskWorkspace?: PrepareTaskWorkspace;
+  }
+): Promise<WorkspaceSession> {
+  if (args.mode !== "task-worktree") return session;
+  if (session.kind === "task-worktree" || session.explicitCwd) return session;
+  if (!args.prepareTaskWorkspace) {
+    throw new Error("task-worktree workspace sessions require a prepareTaskWorkspace implementation.");
+  }
+  const prepared = await args.prepareTaskWorkspace({
+    agentKey: args.agentKey,
+    env: args.env,
+  });
+  return workspaceSessionFromTaskWorkspace(prepared);
+}
+
+function workspaceSessionFromTaskWorkspace(
+  workspace: PreparedTaskWorkspace
+): WorkspaceSession {
+  return {
+    kind: "task-worktree",
+    workspaceRoot: workspace.path,
+    explicitCwd: false,
+    ...(workspace.branchName ? { branchName: workspace.branchName } : {}),
+  };
+}
+
+export function formatWorkspaceSessionActivation(session: WorkspaceSession) {
+  if (session.kind !== "task-worktree") return "";
+  return `[nolo] workspace session: task-worktree ${session.workspaceRoot}${
+    session.branchName ? ` (branch ${session.branchName})` : ""
+  }\n`;
+}

package/agentAliases.ts

@@ -2,14 +2,51 @@ export const PLATFORM_DEMO_USER_ID = "b2e06f801f";
 export const FRONTEND_IMPLEMENTER_AGENT_ID = "01FRONTENDAG0000000115N4E1";
 export const FRONTEND_IMPLEMENTER_AGENT_KEY =
   `agent-${PLATFORM_DEMO_USER_ID}-${FRONTEND_IMPLEMENTER_AGENT_ID}`;
+export const NOLO_FRONTEND_AGENT_ID = FRONTEND_IMPLEMENTER_AGENT_ID;
+export const NOLO_FRONTEND_AGENT_KEY = FRONTEND_IMPLEMENTER_AGENT_KEY;
+export const NOLO_PROJECT_MANAGER_AGENT_ID = "01NOLOPROJMGR00000000MSVGG";
+export const NOLO_PROJECT_MANAGER_AGENT_KEY =
+  `agent-${PLATFORM_DEMO_USER_ID}-${NOLO_PROJECT_MANAGER_AGENT_ID}`;
+export const NOLO_FULLSTACK_AGENT_ID = "01NOLOFULLSTK00000001J740Q";
+export const NOLO_FULLSTACK_AGENT_KEY =
+  `agent-${PLATFORM_DEMO_USER_ID}-${NOLO_FULLSTACK_AGENT_ID}`;
+export const NOLO_SENIOR_FULLSTACK_AGENT_ID = "01NOLOFULLSTK00000000T3XR4";
+export const NOLO_SENIOR_FULLSTACK_AGENT_KEY =
+  `agent-${PLATFORM_DEMO_USER_ID}-${NOLO_SENIOR_FULLSTACK_AGENT_ID}`;
+export const NOLO_REVIEW_AGENT_ID = "01NOLOREVIEW0000000000R8V1";
+export const NOLO_REVIEW_AGENT_KEY =
+  `agent-${PLATFORM_DEMO_USER_ID}-${NOLO_REVIEW_AGENT_ID}`;
 
 const AGENT_ALIAS_TO_KEY: Record<string, string> = {
+  "nolo-frontend": FRONTEND_IMPLEMENTER_AGENT_KEY,
   "frontend-implementer": FRONTEND_IMPLEMENTER_AGENT_KEY,
   "frontend-agent": FRONTEND_IMPLEMENTER_AGENT_KEY,
   frontend: FRONTEND_IMPLEMENTER_AGENT_KEY,
   "front-end": FRONTEND_IMPLEMENTER_AGENT_KEY,
   "前端": FRONTEND_IMPLEMENTER_AGENT_KEY,
   "前端实现员": FRONTEND_IMPLEMENTER_AGENT_KEY,
+  "nolo-project-manager": NOLO_PROJECT_MANAGER_AGENT_KEY,
+  "project-manager": NOLO_PROJECT_MANAGER_AGENT_KEY,
+  "nolo-pm": NOLO_PROJECT_MANAGER_AGENT_KEY,
+  pm: NOLO_PROJECT_MANAGER_AGENT_KEY,
+  "项目经理": NOLO_PROJECT_MANAGER_AGENT_KEY,
+  "nolo 项目经理": NOLO_PROJECT_MANAGER_AGENT_KEY,
+  "nolo-fullstack": NOLO_FULLSTACK_AGENT_KEY,
+  fullstack: NOLO_FULLSTACK_AGENT_KEY,
+  "full-stack": NOLO_FULLSTACK_AGENT_KEY,
+  "全栈": NOLO_FULLSTACK_AGENT_KEY,
+  "nolo 全栈工程师": NOLO_FULLSTACK_AGENT_KEY,
+  "senior-fullstack": NOLO_SENIOR_FULLSTACK_AGENT_KEY,
+  "nolo-senior-fullstack": NOLO_SENIOR_FULLSTACK_AGENT_KEY,
+  "高级全栈": NOLO_SENIOR_FULLSTACK_AGENT_KEY,
+  "nolo 高级全栈工程师": NOLO_SENIOR_FULLSTACK_AGENT_KEY,
+  "nolo-reviewer": NOLO_REVIEW_AGENT_KEY,
+  reviewer: NOLO_REVIEW_AGENT_KEY,
+  "nolo-code-review": NOLO_REVIEW_AGENT_KEY,
+  "code-review": NOLO_REVIEW_AGENT_KEY,
+  review: NOLO_REVIEW_AGENT_KEY,
+  "代码审查": NOLO_REVIEW_AGENT_KEY,
+  "nolo 代码审查": NOLO_REVIEW_AGENT_KEY,
 };
 
 function parseAgentKeyFromInput(raw: string): string {

package/agentPullCommand.ts

@@ -56,7 +56,7 @@ function extractToolNames(record: any) {
   if (Array.isArray(record?.toolNames)) return record.toolNames.filter((tool: unknown) => typeof tool === "string");
   if (!Array.isArray(record?.tools)) return [];
   return record.tools
-    .map((tool: any) => typeof tool === "string" ? tool : tool?.name)
+    .map((tool: any) => typeof tool === "string" ? tool : tool?.name || tool?.function?.name)
     .filter((tool: unknown): tool is string => typeof tool === "string" && tool.length > 0);
 }