nolo-cli 0.1.45 → 0.1.46

package/agent-runtime/localLoop.ts

@@ -1,334 +0,0 @@
-import type {
-  AgentRuntimeHostAdapter,
-} from "./hostAdapter";
-import type {
-  AgentRuntimeChatMessage,
-  AgentRuntimeMessageContent,
-  AgentRuntimeResult,
-} from "./types";
-
-export type LocalAgentTurnInput = {
-  adapter: AgentRuntimeHostAdapter;
-  agentRef: string;
-  input: AgentRuntimeMessageContent;
-  continueDialogId?: string;
-  spaceId?: string;
-  category?: string;
-  inheritedFromDialogKey?: string;
-  parentDialogId?: string;
-  runtimeContext?: Record<string, any> | null;
-  timeoutMs?: number;
-  onToolEvent?: (event: LocalAgentToolEvent) => void;
-};
-
-export type LocalAgentTurnResult = AgentRuntimeResult & {
-  dialogId: string;
-  turnMessages?: AgentRuntimeChatMessage[];
-};
-
-export type LocalAgentToolEvent = {
-  type: "tool-call" | "tool-result" | "tool-error";
-  round: number;
-  toolCallId: string;
-  toolName: string;
-  argumentsPreview?: string;
-  elapsedMs?: number;
-  summary?: string;
-  message?: string;
-  metadata?: Record<string, unknown>;
-};
-
-export const LOCAL_AGENT_CONFIG_MISSING_CODE = "LOCAL_AGENT_CONFIG_MISSING";
-
-function formatToolExecutionError(args: {
-  toolName: string;
-  error: unknown;
-}) {
-  const message = args.error instanceof Error ? args.error.message : String(args.error);
-  return `${args.toolName} failed: ${message}`;
-}
-
-function formatStructuredToolExecutionError(args: {
-  toolName: string;
-  error: unknown;
-}) {
-  if (!args.error || typeof args.error !== "object") return null;
-  const error = args.error as {
-    code?: unknown;
-    message?: unknown;
-    policy?: unknown;
-  };
-  if (typeof error.code !== "string") return null;
-  return JSON.stringify({
-    error: error.code,
-    message:
-      typeof error.message === "string"
-        ? error.message
-        : formatToolExecutionError(args),
-    ...(error.policy && typeof error.policy === "object"
-      ? { policy: error.policy }
-      : {}),
-  });
-}
-
-function shouldReturnToolExecutionErrors(adapter: AgentRuntimeHostAdapter) {
-  return adapter.capabilities.includes("local-tools");
-}
-
-function emitToolEvent(
-  input: LocalAgentTurnInput,
-  event: LocalAgentToolEvent
-) {
-  input.onToolEvent?.(event);
-}
-
-function compactWhitespace(value: string) {
-  return value.replace(/\s+/g, " ").trim();
-}
-
-function clip(value: string, max = 240) {
-  const compact = compactWhitespace(value);
-  return compact.length > max ? `${compact.slice(0, max - 3)}...` : compact;
-}
-
-function parseToolArguments(raw: string | undefined) {
-  if (!raw?.trim()) return {};
-  try {
-    const parsed = JSON.parse(raw);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-      ? parsed as Record<string, unknown>
-      : {};
-  } catch {
-    return {};
-  }
-}
-
-function summarizeToolArguments(toolName: string, rawArgs: string | undefined) {
-  const args = parseToolArguments(rawArgs);
-  const pick = (...keys: string[]) => {
-    for (const key of keys) {
-      const value = args[key];
-      if (typeof value === "string" && value.trim()) return value.trim();
-    }
-    return "";
-  };
-  const command = pick("command", "cmd", "runCommand", "executeCommand", "bash");
-  if (command) return clip(command);
-  const filePath = pick("filePath", "path", "filename", "file");
-  if (filePath) return clip(filePath);
-  const query = pick("query", "pattern", "search", "q");
-  if (query) return clip(query);
-  const keys = Object.keys(args);
-  if (keys.length === 0) return "";
-  return clip(keys.slice(0, 6).map((key) => {
-    const value = args[key];
-    if (typeof value === "string") return `${key}=${clip(value, 80)}`;
-    if (typeof value === "number" || typeof value === "boolean") return `${key}=${String(value)}`;
-    if (Array.isArray(value)) return `${key}[${value.length}]`;
-    return `${key}=${value === null ? "null" : typeof value}`;
-  }).join(" "));
-}
-
-function summarizeToolResult(content: unknown, metadata?: Record<string, unknown>) {
-  const parts: string[] = [];
-  const exitCode = metadata?.exitCode;
-  if (typeof exitCode === "number") parts.push(`exit=${exitCode}`);
-  if (typeof content === "string") {
-    const trimmed = content.trim();
-    if (trimmed) {
-      const lines = trimmed.split(/\r?\n/).length;
-      parts.push(`${lines} line${lines === 1 ? "" : "s"}`);
-      parts.push(`${trimmed.length} chars`);
-      const tail = clip(trimmed.slice(-160), 160);
-      if (tail) parts.push(`tail="${tail}"`);
-    } else {
-      parts.push("empty");
-    }
-  }
-  return parts.join(" ");
-}
-
-function formatToolMessageContent(args: {
-  toolName: string;
-  content: string;
-  metadata?: Record<string, unknown>;
-}) {
-  if (
-    (
-      args.toolName !== "listFiles" &&
-      args.toolName !== "globFiles" &&
-      args.toolName !== "searchFiles" &&
-      args.toolName !== "readFile"
-    ) ||
-    !args.metadata ||
-    Object.keys(args.metadata).length === 0
-  ) {
-    return args.content;
-  }
-  return `${args.content}\n\n[tool metadata]\n${JSON.stringify(args.metadata)}`;
-}
-
-function buildMessages(args: {
-  prompt?: string;
-  history: AgentRuntimeChatMessage[];
-  input: AgentRuntimeMessageContent;
-}): AgentRuntimeChatMessage[] {
-  const systemContent = args.prompt?.trim();
-  return [
-    ...(systemContent
-      ? [{ role: "system" as const, content: systemContent }]
-      : []),
-    ...args.history,
-    { role: "user" as const, content: args.input },
-  ];
-}
-
-function extractUserInputText(content: AgentRuntimeMessageContent): string {
-  if (typeof content === "string") return content;
-  if (!Array.isArray(content)) return "";
-  return content
-    .flatMap((part) => (part?.type === "text" && part.text ? [part.text] : []))
-    .join("\n")
-    .trim();
-}
-
-export async function runLocalAgentTurn(
-  input: LocalAgentTurnInput
-): Promise<LocalAgentTurnResult> {
-  const agentConfig = await input.adapter.loadAgentConfig(input.agentRef);
-  if (!agentConfig) {
-    const error = new Error(`Local agent config not found: ${input.agentRef}`) as Error & {
-      code?: string;
-      agentRef?: string;
-    };
-    error.code = LOCAL_AGENT_CONFIG_MISSING_CODE;
-    error.agentRef = input.agentRef;
-    throw error;
-  }
-
-  const history = input.continueDialogId
-    ? await input.adapter.loadDialogHistory(input.continueDialogId)
-    : [];
-  const promptMessageCount = agentConfig.prompt?.trim() ? 1 : 0;
-  const turnStartIndex = promptMessageCount + history.length;
-  const messages = buildMessages({
-    prompt: agentConfig.prompt,
-    history,
-    input: input.input,
-  });
-  const provider = await input.adapter.resolveProvider(agentConfig);
-  const userInputText = extractUserInputText(input.input);
-  let toolCallCount = 0;
-  let result: AgentRuntimeResult;
-  let round = 0;
-  while (true) {
-    result = await provider.complete(messages, {
-      ...(typeof input.timeoutMs === "number" ? { timeoutMs: input.timeoutMs } : {}),
-    });
-    const toolCalls = result.tool_calls ?? [];
-    if (toolCalls.length === 0) break;
-    toolCallCount += toolCalls.length;
-    messages.push({
-      role: "assistant",
-      content: result.content || null,
-      ...(result.reasoning_content ? { reasoning_content: result.reasoning_content } : {}),
-      tool_calls: toolCalls,
-    });
-    for (const toolCall of toolCalls) {
-      const toolName = toolCall.function.name;
-      let toolResult;
-      const startedAt = Date.now();
-      emitToolEvent(input, {
-        type: "tool-call",
-        round,
-        toolCallId: toolCall.id,
-        toolName,
-        argumentsPreview: summarizeToolArguments(toolName, toolCall.function.arguments),
-      });
-      try {
-        toolResult = await input.adapter.executeTool({
-          id: toolCall.id,
-          name: toolName,
-          arguments: toolCall.function.arguments,
-          ...(userInputText ? { userInput: userInputText } : {}),
-        });
-        emitToolEvent(input, {
-          type: "tool-result",
-          round,
-          toolCallId: toolCall.id,
-          toolName,
-          elapsedMs: Math.max(0, Date.now() - startedAt),
-          summary: summarizeToolResult(toolResult.content, toolResult.metadata),
-          metadata: toolResult.metadata,
-        });
-      } catch (error) {
-        if (!shouldReturnToolExecutionErrors(input.adapter)) throw error;
-        emitToolEvent(input, {
-          type: "tool-error",
-          round,
-          toolCallId: toolCall.id,
-          toolName,
-          elapsedMs: Math.max(0, Date.now() - startedAt),
-          message: error instanceof Error ? error.message : String(error),
-        });
-        toolResult = {
-          content:
-            formatStructuredToolExecutionError({ toolName, error }) ??
-            formatToolExecutionError({ toolName, error }),
-          metadata: {
-            error: true,
-            toolName,
-            message: error instanceof Error ? error.message : String(error),
-            ...(
-              error &&
-              typeof error === "object" &&
-              typeof (error as { code?: unknown }).code === "string"
-                ? { code: (error as { code: string }).code }
-                : {}
-            ),
-          },
-        };
-      }
-      messages.push({
-        role: "tool",
-        content: formatToolMessageContent({
-          toolName,
-          content: toolResult.content,
-          metadata: toolResult.metadata,
-        }),
-        tool_call_id: toolCall.id,
-        ...(toolResult.metadata ? { tool_result_metadata: toolResult.metadata } : {}),
-      });
-    }
-    round += 1;
-  }
-  result = result!;
-  messages.push({
-    role: "assistant",
-    content: result.content,
-  });
-  const turnMessages = messages.slice(turnStartIndex);
-  const saved = await input.adapter.saveTurn({
-    agentKey: agentConfig.key,
-    messages: turnMessages,
-    result: {
-      ...result,
-      ...(toolCallCount > 0 ? { toolCallCount } : {}),
-      ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
-    },
-    ...(input.runtimeContext ? { runtimeContext: input.runtimeContext } : {}),
-    ...(input.continueDialogId ? { continueDialogId: input.continueDialogId } : {}),
-    ...(input.spaceId ? { spaceId: input.spaceId } : {}),
-    ...(input.category ? { category: input.category } : {}),
-    ...(input.inheritedFromDialogKey ? { inheritedFromDialogKey: input.inheritedFromDialogKey } : {}),
-    ...(input.parentDialogId ? { parentDialogId: input.parentDialogId } : {}),
-  });
-
-  return {
-    ...result,
-    ...(toolCallCount > 0 ? { toolCallCount } : {}),
-    ...((agentConfig as any).toolSurface ? { runtimeToolSurface: (agentConfig as any).toolSurface } : {}),
-    dialogId: saved.dialogId,
-    turnMessages,
-  };
-}

package/agent-runtime/localToolPolicy.ts

@@ -1,179 +0,0 @@
-import type {
-  AgentRuntimeToolCallInput,
-  AgentRuntimeToolResult,
-} from "./hostAdapter";
-import { canonicalizeToolName } from "../ai/tools/toolNameAliases";
-import { evaluateShellCommandPolicy } from "./shellCommandPolicy";
-
-type EnvLike = Record<string, string | undefined>;
-
-export type LocalToolPolicyDecision =
-  | { allowed: true; toolName: string }
-  | { allowed: false; toolName: string; reason: string };
-
-const NEVER_LOCAL_TOOLS = new Set([
-  "deleteSpaces",
-  "updateAgent",
-  "updateSelf",
-  "createAgent",
-]);
-
-const REMOVED_LOCAL_TOOLS = new Set([
-  "gitStatus",
-  "gitDiff",
-  "gitCreateBranch",
-  "gitAdd",
-  "gitCommit",
-  "commitWorkspace",
-]);
-
-const DEFAULT_LOCAL_TOOLS = new Set([
-  "listFiles",
-  "readFile",
-  "writeFile",
-  "editFile",
-  "globFiles",
-  "searchFiles",
-  "execShell",
-]);
-
-function parseToolAllowlist(value: string | undefined) {
-  return (value ?? "")
-    .split(",")
-    .flatMap((item) => {
-      const trimmed = item.trim();
-      return trimmed ? [trimmed] : [];
-    });
-}
-
-function normalizeLocalToolName(toolName: string) {
-  return canonicalizeToolName(
-    String(toolName ?? "").replace(/^functions\./, "").trim(),
-  );
-}
-
-function parseShellCommandPayload(rawArguments: string) {
-  try {
-    const parsed = JSON.parse(rawArguments || "{}");
-    if (!parsed || typeof parsed !== "object") return {};
-    return parsed as { command?: unknown; cmd?: unknown; input?: unknown };
-  } catch {
-    return {};
-  }
-}
-
-function isRestrictedLocalToolMode(env: EnvLike) {
-  return env.NOLO_LOCAL_TOOL_MODE === "restricted";
-}
-
-function isToolDeclaredOrExplicitlyFree(args: {
-  env: EnvLike;
-  agentToolNames?: string[];
-  toolName: string;
-}) {
-  return (
-    new Set(args.agentToolNames ?? []).has(args.toolName) ||
-    args.env.NOLO_LOCAL_ALLOW_UNDECLARED_TOOLS === "1"
-  );
-}
-
-export function resolveLocalToolPolicy(args: {
-  env: EnvLike;
-  agentToolNames?: string[];
-  toolName: string;
-}): LocalToolPolicyDecision {
-  const toolName = normalizeLocalToolName(args.toolName);
-  const restrictedMode = isRestrictedLocalToolMode(args.env);
-  if (!toolName) {
-    return {
-      allowed: false,
-      toolName,
-      reason: "Tool name is required.",
-    };
-  }
-
-  if (toolName === "execShell") {
-    return { allowed: true, toolName };
-  }
-
-  if (NEVER_LOCAL_TOOLS.has(toolName)) {
-    return {
-      allowed: false,
-      toolName,
-      reason: `${toolName} is blocked by the local runtime safety policy.`,
-    };
-  }
-
-  if (REMOVED_LOCAL_TOOLS.has(toolName)) {
-    return {
-      allowed: false,
-      toolName,
-      reason: `${toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`,
-    };
-  }
-
-  const allowedByEnv = new Set(parseToolAllowlist(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
-  const agentTools = new Set(
-    (args.agentToolNames ?? []).flatMap((item) => {
-      const normalized = normalizeLocalToolName(item);
-      return normalized ? [normalized] : [];
-    }),
-  );
-  if (!restrictedMode && agentTools.has(toolName)) {
-    return { allowed: true, toolName };
-  }
-  if (DEFAULT_LOCAL_TOOLS.has(toolName) && agentTools.has(toolName)) {
-    return { allowed: true, toolName };
-  }
-  if (allowedByEnv.has(toolName) && agentTools.has(toolName)) {
-    return { allowed: true, toolName };
-  }
-
-  return {
-    allowed: false,
-    toolName,
-    reason:
-      `${toolName} is not enabled for local runtime runs. ` +
-      "Set NOLO_LOCAL_ALLOWED_TOOLS and make sure the agent declares the tool before using it locally.",
-  };
-}
-
-export async function executeLocalToolWithPolicy(args: {
-  env: EnvLike;
-  agentToolNames?: string[];
-  call: AgentRuntimeToolCallInput;
-  executors?: Record<string, (call: AgentRuntimeToolCallInput) => Promise<AgentRuntimeToolResult>>;
-}): Promise<AgentRuntimeToolResult> {
-  const decision = resolveLocalToolPolicy({
-    env: args.env,
-    agentToolNames: args.agentToolNames,
-    toolName: args.call.name,
-  });
-  if (!decision.allowed) throw new Error(decision.reason);
-
-  const executor = args.executors?.[decision.toolName];
-  if (!executor) {
-    throw new Error(`${decision.toolName} is allowed by policy but no local executor is registered.`);
-  }
-  if (decision.toolName === "execShell") {
-    const parsed = parseShellCommandPayload(args.call.arguments);
-    const shellPolicy = evaluateShellCommandPolicy({
-      command: parsed.command ?? parsed.cmd,
-      input: parsed.input,
-      userInput: args.call.userInput,
-    });
-    if (shellPolicy.verdict === "forbidden") {
-      const error = new Error(shellPolicy.reason) as Error & {
-        code?: string;
-        policy?: Record<string, unknown>;
-      };
-      error.code = shellPolicy.code;
-      error.policy = shellPolicy.policy;
-      throw error;
-    }
-  }
-  return executor({
-    ...args.call,
-    name: decision.toolName,
-  });
-}