nolo-cli 0.1.40 → 0.1.42

package/ai/tools/modelUsageTools.ts

@@ -0,0 +1,206 @@
+export const queryModelUsageFunctionSchema = {
+  name: "queryModelUsage",
+  description:
+    "查询模型/API 用量与费用。普通用户只能查自己的用量；系统管理员可以查指定用户或全站。费用默认返回 credits，也可附带 USD 换算。",
+  parameters: {
+    type: "object",
+    properties: {
+      scope: {
+        type: "string",
+        enum: ["user", "all", "space"],
+        description:
+          "查询范围。user 为个人，all 为全站管理员查询，space 预留给空间范围。",
+        default: "user",
+      },
+      userId: {
+        type: "string",
+        description: "管理员查询指定用户时使用；普通用户不允许指定他人。",
+      },
+      spaceId: {
+        type: "string",
+        description: "空间范围查询预留字段，当前版本会返回未实现。",
+      },
+      provider: {
+        type: "string",
+        description: "可选 provider 过滤，例如 google、openai、anthropic。",
+      },
+      model: {
+        type: "string",
+        description: "可选模型过滤，例如 gemini-3.5-flash。",
+      },
+      serviceTier: {
+        type: "string",
+        description: "可选计费档位过滤，例如 standard、flex。",
+      },
+      startDate: {
+        type: "string",
+        description: "开始日期，YYYY-MM-DD。默认今天。",
+      },
+      endDate: {
+        type: "string",
+        description: "结束日期，YYYY-MM-DD。默认等于 startDate。",
+      },
+      currency: {
+        type: "string",
+        description: "展示货币/单位标签。默认 CREDITS；可填 USD、CNY 等。",
+        default: "CREDITS",
+      },
+      creditsPerUsd: {
+        type: "number",
+        description: "credits 与 USD 的换算比例，默认 8 credits = 1 USD。",
+        default: 8,
+      },
+      thresholdCredits: {
+        type: "number",
+        description:
+          "可选阈值，单位 credits；返回 threshold.exceeded 与 0-100 的 threshold.usedPercent。",
+      },
+      thresholdUsd: {
+        type: "number",
+        description:
+          "可选阈值，单位 USD；会按 creditsPerUsd 换算，并返回 0-100 的 threshold.usedPercent。",
+      },
+    },
+  },
+};
+
+export const createScheduledTaskFunctionSchema = {
+  name: "createScheduledTask",
+  description:
+    "创建一个每日/周期性后台任务。适合让 agent 按 cron 定时检查用量、生成报告或执行提醒；可选择创建后立刻试运行一次。",
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "任务标题。",
+      },
+      taskPrompt: {
+        type: "string",
+        description:
+          "定时任务每次执行时交给 agent 的完整任务描述，应包含检查条件和通知方式。",
+      },
+      schedule: {
+        type: "string",
+        description: "cron 表达式，例如每天 09:00 执行为 0 9 * * *。",
+      },
+      agentKey: {
+        type: "string",
+        description: "执行该任务的 agentKey。默认使用当前 agent。",
+      },
+      spaceId: {
+        type: "string",
+        description: "可选空间 ID；任务对话会归属到该空间。",
+      },
+      runOnceNow: {
+        type: "boolean",
+        description: "创建后是否立即执行一次，用来验证任务会产生什么结果。",
+        default: false,
+      },
+    },
+    required: ["schedule", "taskPrompt"],
+  },
+};
+
+export const createDialogGoalFunctionSchema = {
+  name: "createDialogGoal",
+  description:
+    "为当前对话创建或替换一个轻量目标，可选设置 token 预算。目标会持久化到当前 dialog。",
+  parameters: {
+    type: "object",
+    properties: {
+      objective: {
+        type: "string",
+        description: "目标描述，应该是可完成的具体任务。",
+      },
+      tokenBudget: {
+        type: "number",
+        description: "可选 token 预算。用于报告 used / remaining，不会自动中断运行。",
+      },
+      dialogId: {
+        type: "string",
+        description: "可选 dialogId。默认使用当前运行中的对话。",
+      },
+    },
+    required: ["objective"],
+  },
+};
+
+export const getDialogGoalFunctionSchema = {
+  name: "getDialogGoal",
+  description:
+    "读取当前或指定对话的 goal 状态，并返回 token 使用与剩余预算报告。",
+  parameters: {
+    type: "object",
+    properties: {
+      dialogId: {
+        type: "string",
+        description: "可选 dialogId。默认使用当前运行中的对话。",
+      },
+    },
+  },
+};
+
+export const completeDialogGoalFunctionSchema = {
+  name: "completeDialogGoal",
+  description:
+    "将当前或指定对话的 goal 标记为 complete，并持久化完成时间。",
+  parameters: {
+    type: "object",
+    properties: {
+      dialogId: {
+        type: "string",
+        description: "可选 dialogId。默认使用当前运行中的对话。",
+      },
+    },
+  },
+};
+
+export const notifyUserFunctionSchema = {
+  name: "notifyUser",
+  description:
+    "发送一条站内通知给当前用户。第一版只支持站内通知，后续可扩展邮件、桌面端、网页和移动端通知。",
+  parameters: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        description: "通知标题。",
+      },
+      message: {
+        type: "string",
+        description: "通知正文。",
+      },
+      severity: {
+        type: "string",
+        enum: ["info", "warning", "critical"],
+        description: "通知级别。",
+        default: "info",
+      },
+      href: {
+        type: "string",
+        description: "可选跳转链接。",
+      },
+      targetUserId: {
+        type: "string",
+        description:
+          "可选目标用户 ID。默认通知当前用户；只有受信任的系统 agent 或管理员可以通知其他用户。",
+      },
+    },
+    required: ["title", "message"],
+  },
+};
+
+const serverOnlyResult = (toolName: string) => ({
+  rawData: {
+    error: `${toolName} must run on the server-side agent runtime.`,
+  },
+  displayData: `${toolName} 需要在服务端 agent runtime 中执行。`,
+});
+
+export const queryModelUsageFunc = async () => serverOnlyResult("queryModelUsage");
+export const createScheduledTaskFunc = async () => serverOnlyResult("createScheduledTask");
+export const createDialogGoalFunc = async () => serverOnlyResult("createDialogGoal");
+export const getDialogGoalFunc = async () => serverOnlyResult("getDialogGoal");
+export const completeDialogGoalFunc = async () => serverOnlyResult("completeDialogGoal");
+export const notifyUserFunc = async () => serverOnlyResult("notifyUser");

package/ai/tools/noloWorkspaceReadTools.ts

@@ -0,0 +1,467 @@
+import { selectRuntimeSnapshot } from "../../app/stateViews/runtime";
+import { DataType } from "../../create/types";
+import { createSpaceKey } from "../../create/space/spaceKeys";
+import { redactAgentRecordForWorkspaceTool } from "../../agent-runtime/runtimeToolSurface";
+import {
+  clampNoloPositiveInteger,
+  getNoloComparableUpdatedAt,
+  getNoloDialogIdFromKey,
+  NOLO_WORKSPACE_TOOL_NAMES,
+  normalizeNoloSpaceInput,
+  resolveNoloDialogInput,
+} from "../../agent-runtime/noloWorkspaceTools";
+
+type ToolResult = {
+  rawData: unknown;
+  displayData?: string;
+};
+
+const jsonPreview = (value: unknown, maxLength = 1800) => {
+  const text = JSON.stringify(value, null, 2);
+  return text.length <= maxLength ? text : `${text.slice(0, maxLength)}\n...(truncated)`;
+};
+
+const normalizeServer = (value: unknown) =>
+  typeof value === "string" && value.trim()
+    ? value.trim().replace(/\/+$/, "")
+    : "";
+
+const getRuntime = (thunkApi: any) => {
+  const state = thunkApi?.getState?.();
+  return state ? selectRuntimeSnapshot(state) : null;
+};
+
+const authHeaders = (token?: string) =>
+  token ? { Authorization: `Bearer ${token}` } : {};
+
+async function readRemoteRecord(args: {
+  serverBase?: string;
+  token?: string;
+  dbKey: string;
+  includeDeleted?: boolean;
+}) {
+  const serverBase = normalizeServer(args.serverBase);
+  if (!serverBase || !args.token) return null;
+  const query = args.includeDeleted ? "?includeDeleted=true" : "";
+  const response = await fetch(
+    `${serverBase}/api/v1/db/read/${encodeURIComponent(args.dbKey)}${query}`,
+    { headers: authHeaders(args.token) }
+  );
+  if (!response.ok) return null;
+  const payload = await response.json().catch(() => null);
+  return payload?.data ?? payload;
+}
+
+async function queryRemoteUserRecords(args: {
+  serverBase?: string;
+  token?: string;
+  userId?: string;
+  type: string | string[];
+  limit: number;
+}) {
+  const serverBase = normalizeServer(args.serverBase);
+  if (!serverBase || !args.token || !args.userId) return [];
+  const response = await fetch(
+    `${serverBase}/api/v1/db/query/${encodeURIComponent(args.userId)}?limit=${args.limit}`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders(args.token),
+      },
+      body: JSON.stringify({ type: args.type }),
+    }
+  );
+  if (!response.ok) return [];
+  const payload = await response.json().catch(() => null);
+  return Array.isArray(payload?.data?.data)
+    ? payload.data.data
+    : Array.isArray(payload?.data)
+      ? payload.data
+      : [];
+}
+
+async function queryBestRecords(
+  thunkApi: any,
+  type: string | string[],
+  limit: number
+) {
+  const runtime = getRuntime(thunkApi);
+  const remoteRecords = await queryRemoteUserRecords({
+    serverBase: runtime?.currentServer,
+    token: runtime?.currentToken,
+    userId: runtime?.currentUserId,
+    type,
+    limit,
+  }).catch(() => []);
+  return remoteRecords;
+}
+
+async function readBestRecord(thunkApi: any, dbKey: string, includeDeleted = false) {
+  const runtime = getRuntime(thunkApi);
+  return readRemoteRecord({
+    serverBase: runtime?.currentServer,
+    token: runtime?.currentToken,
+    dbKey,
+    includeDeleted,
+  }).catch(() => null);
+}
+
+export const listDialogsFunctionSchema = {
+  name: "listDialogs",
+  description: "List the current user's Nolo dialogs. Use before readDialog when the target dialog is unclear.",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: { type: "integer", description: "Maximum dialogs to return. Default 100, max 500." },
+      space: { type: "string", description: "Optional space id or URL." },
+      includeScheduled: { type: "boolean", description: "Include scheduled/background run dialogs." },
+    },
+  },
+} as const;
+
+export async function listDialogsFunc(args: any, thunkApi: any): Promise<ToolResult> {
+  const limit = clampNoloPositiveInteger(args?.limit, 100, 500);
+  const includeScheduled = args?.includeScheduled === true;
+  const records = await queryBestRecords(thunkApi, DataType.DIALOG, limit * 3);
+  const dialogs = records
+    .filter((record: any) => includeScheduled || record?.triggerType !== "scheduled_run")
+    .sort((left: any, right: any) => getNoloComparableUpdatedAt(right) - getNoloComparableUpdatedAt(left))
+    .slice(0, limit)
+    .map((record: any) => ({
+      id: typeof record?.id === "string" ? record.id : getNoloDialogIdFromKey(String(record?.dbKey ?? "")),
+      dbKey: record?.dbKey ?? null,
+      title: record?.title ?? record?.taskLabel ?? "(untitled)",
+      status: record?.status ?? null,
+      updatedAt: record?.updatedAt ?? record?.updated_at ?? null,
+      createdAt: record?.createdAt ?? record?.created ?? null,
+      spaceId: record?.spaceId ?? null,
+      triggerType: record?.triggerType ?? null,
+      primaryAgentKey: record?.primaryAgentKey ?? null,
+    }));
+  return {
+    rawData: { success: true, total: dialogs.length, dialogs },
+    displayData: jsonPreview({ total: dialogs.length, dialogs }),
+  };
+}
+
+export const readDialogFunctionSchema = {
+  name: "readDialog",
+  description: "Read one persisted Nolo dialog, including metadata and recent messages.",
+  parameters: {
+    type: "object",
+    properties: {
+      dialog: { type: "string", description: "Dialog id, dialog dbKey, or dialog URL." },
+      limit: { type: "integer", description: "Message limit. Default 120, max 1000." },
+    },
+    required: ["dialog"],
+  },
+} as const;
+
+export async function readDialogFunc(args: any, thunkApi: any): Promise<ToolResult> {
+  const runtime = getRuntime(thunkApi);
+  const userId = runtime?.currentUserId;
+  if (!userId) throw new Error("readDialog requires a signed-in user.");
+  const rawDialog = typeof args?.dialog === "string"
+    ? args.dialog.trim()
+    : typeof args?.dialogId === "string"
+      ? args.dialogId.trim()
+      : typeof args?.id === "string"
+        ? args.id.trim()
+        : "";
+  if (!rawDialog) throw new Error("readDialog requires dialog.");
+  const resolved = resolveNoloDialogInput(rawDialog, userId);
+  const limit = clampNoloPositiveInteger(args?.limit, 120, 1000);
+  const meta = await readBestRecord(thunkApi, resolved.dbKey, true);
+
+  let messages: any[] = [];
+  const serverBase = normalizeServer(runtime?.currentServer);
+  if (serverBase && runtime?.currentToken) {
+    const response = await fetch(`${serverBase}/rpc/getConvMsgs`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders(runtime.currentToken),
+      },
+      body: JSON.stringify({ dialogId: resolved.dialogId, limit }),
+    }).catch(() => null);
+    if (response?.ok) {
+      const payload = await response.json().catch(() => []);
+      messages = Array.isArray(payload) ? payload : [];
+    }
+  }
+
+  return {
+    rawData: {
+      success: true,
+      dialogKey: resolved.dbKey,
+      dialogId: resolved.dialogId,
+      meta,
+      messages,
+    },
+    displayData: jsonPreview({
+      dialogKey: resolved.dbKey,
+      title: meta?.title,
+      messageCount: messages.length,
+      messages,
+    }),
+  };
+}
+
+export const listAgentsFunctionSchema = {
+  name: "listAgents",
+  description: "List the current user's Nolo agents.",
+  parameters: {
+    type: "object",
+    properties: {
+      limit: { type: "integer", description: "Maximum agents to return. Default 100, max 500." },
+      publicOnly: { type: "boolean", description: "Only show public agents." },
+    },
+  },
+} as const;
+
+export async function listAgentsFunc(args: any, thunkApi: any): Promise<ToolResult> {
+  const limit = clampNoloPositiveInteger(args?.limit, 100, 500);
+  const records = await queryBestRecords(thunkApi, DataType.AGENT, limit);
+  const agents = records
+    .sort((left: any, right: any) => getNoloComparableUpdatedAt(right) - getNoloComparableUpdatedAt(left))
+    .map((record: any) => ({
+      id: record?.id ?? null,
+      privateKey: record?.dbKey ?? null,
+      publicKey: typeof record?.id === "string" ? `agent-pub-${record.id}` : null,
+      name: record?.name ?? "(unnamed)",
+      model: record?.model ?? null,
+      provider: record?.provider ?? record?.apiSource ?? null,
+      isPublic: record?.isPublic === true,
+      updatedAt: record?.updatedAt ?? record?.createdAt ?? null,
+      tools: Array.isArray(record?.tools) ? record.tools : [],
+    }))
+    .filter((agent: any) => args?.publicOnly !== true || agent.isPublic);
+  return {
+    rawData: { success: true, total: agents.length, agents },
+    displayData: jsonPreview({ total: agents.length, agents }),
+  };
+}
+
+export const readAgentFunctionSchema = {
+  name: "readAgent",
+  description: "Read one Nolo agent config.",
+  parameters: {
+    type: "object",
+    properties: {
+      agent: { type: "string", description: "Agent key, id, alias, or URL." },
+    },
+    required: ["agent"],
+  },
+} as const;
+
+export async function readAgentFunc(args: any, thunkApi: any): Promise<ToolResult> {
+  const runtime = getRuntime(thunkApi);
+  const userId = runtime?.currentUserId;
+  if (!userId) throw new Error("readAgent requires a signed-in user.");
+  const rawAgent = typeof args?.agent === "string"
+    ? args.agent.trim()
+    : typeof args?.agentKey === "string"
+      ? args.agentKey.trim()
+      : typeof args?.id === "string"
+        ? args.id.trim()
+        : "";
+  if (!rawAgent) throw new Error("readAgent requires agent.");
+  const raw = rawAgent.startsWith("http://") || rawAgent.startsWith("https://")
+    ? new URL(rawAgent).pathname.split("/").filter(Boolean).at(-1) ?? rawAgent
+    : rawAgent;
+  const candidates = raw.startsWith("agent-")
+    ? [raw]
+    : [`agent-${userId}-${raw}`, `agent-pub-${raw}`];
+  for (const candidate of candidates) {
+    const record = await readBestRecord(thunkApi, candidate, true);
+    if (record) {
+      return {
+        rawData: {
+          success: true,
+          agentKey: candidate,
+          record: redactAgentRecordForWorkspaceTool(record),
+        },
+        displayData: jsonPreview({
+          agentKey: candidate,
+          record: redactAgentRecordForWorkspaceTool(record),
+        }),
+      };
+    }
+  }
+  throw new Error(`readAgent not found: ${rawAgent}`);
+}
+
+export const listSpacesFunctionSchema = {
+  name: "listSpaces",
+  description: "List joined Nolo spaces.",
+  parameters: {
+    type: "object",
+    properties: {},
+  },
+} as const;
+
+export async function listSpacesFunc(_args: any, thunkApi: any): Promise<ToolResult> {
+  const runtime = getRuntime(thunkApi);
+  const serverBase = normalizeServer(runtime?.currentServer);
+  if (serverBase && runtime?.currentToken && runtime?.currentUserId) {
+    const response = await fetch(`${serverBase}/rpc/getUserSpaceMemberships`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders(runtime.currentToken),
+      },
+      body: JSON.stringify({ userId: runtime.currentUserId }),
+    }).catch(() => null);
+    if (response?.ok) {
+      const memberships = await response.json().catch(() => []);
+      if (Array.isArray(memberships)) {
+        const spaces = memberships.map((membership: any) => ({
+          spaceId: membership?.spaceId ?? null,
+          spaceKey: membership?.spaceId ? createSpaceKey.space(String(membership.spaceId)) : null,
+          name: membership?.spaceName ?? membership?.name ?? membership?.spaceId ?? null,
+          role: membership?.role ?? null,
+          ownerId: membership?.ownerId ?? null,
+          visibility: membership?.visibility ?? null,
+        }));
+        return {
+          rawData: { success: true, total: spaces.length, spaces },
+          displayData: jsonPreview({ total: spaces.length, spaces }),
+        };
+      }
+    }
+  }
+  throw new Error("listSpaces requires a signed-in user and reachable Nolo server.");
+}
+
+export const readSpaceFunctionSchema = {
+  name: "readSpace",
+  description: "Read one Nolo space and optionally list its contents.",
+  parameters: {
+    type: "object",
+    properties: {
+      space: { type: "string", description: "Space id or URL." },
+      contentKey: { type: "string", description: "Optional content key inside the space." },
+      brief: { type: "boolean", description: "Return brief content entries." },
+    },
+    required: ["space"],
+  },
+} as const;
+
+export async function readSpaceFunc(args: any, thunkApi: any): Promise<ToolResult> {
+  const rawSpace = typeof args?.space === "string"
+    ? args.space.trim()
+    : typeof args?.spaceId === "string"
+      ? args.spaceId.trim()
+      : typeof args?.id === "string"
+        ? args.id.trim()
+        : "";
+  if (!rawSpace) throw new Error("readSpace requires space.");
+  const spaceId = normalizeNoloSpaceInput(rawSpace);
+  const spaceKey = createSpaceKey.space(spaceId);
+  const space = await readBestRecord(thunkApi, spaceKey, true);
+  if (!space) throw new Error(`readSpace not found: ${rawSpace}`);
+  const contentKeyFilter = typeof args?.contentKey === "string" ? args.contentKey.trim() : "";
+  const allContents = Object.entries(space?.contents ?? {})
+    .filter(([, value]) => value && typeof value === "object")
+    .map(([entryKey, value]) => ({ entryKey, ...(value as Record<string, any>) }));
+  const contents = contentKeyFilter
+    ? allContents.filter((item: any) => {
+        const contentKey = typeof item.contentKey === "string" && item.contentKey.trim()
+          ? item.contentKey.trim()
+          : item.entryKey;
+        return item.entryKey === contentKeyFilter || contentKey === contentKeyFilter;
+      })
+    : allContents;
+  const result = {
+    success: true,
+    spaceId,
+    spaceKey,
+    name: space?.name ?? null,
+    description: space?.description ?? null,
+    ownerId: space?.ownerId ?? null,
+    visibility: space?.visibility ?? null,
+    contentCount: allContents.length,
+    contents: args?.brief === true
+      ? contents.map((item: any) => ({
+          entryKey: item.entryKey,
+          contentKey: item.contentKey ?? item.entryKey,
+          type: item.type ?? null,
+          title: item.title ?? null,
+          categoryId: item.categoryId ?? null,
+        }))
+      : contents,
+    ...(contentKeyFilter ? { contentKeyFilter, matchedCount: contents.length } : {}),
+  };
+  return {
+    rawData: result,
+    displayData: jsonPreview(result),
+  };
+}
+
+export const readSkillDocFunctionSchema = {
+  name: "readSkillDoc",
+  description: "Read one Nolo skill doc/page by page dbKey.",
+  parameters: {
+    type: "object",
+    properties: {
+      id: { type: "string", description: "Skill doc page dbKey, for example page-xxx." },
+      doc: { type: "string", description: "Alias for id." },
+    },
+    required: ["id"],
+  },
+} as const;
+
+export async function readSkillDocFunc(args: any, thunkApi: any): Promise<ToolResult> {
+  const { buildReadDocResult } = await import("./readDocTool");
+  const id = args?.id ?? args?.doc ?? args?.docKey ?? args?.pageKey;
+  if (typeof id !== "string" || !id.trim()) {
+    throw new Error("readSkillDoc requires id or doc.");
+  }
+  const page = await readBestRecord(thunkApi, id.trim(), true);
+  if (!page) throw new Error(`readSkillDoc not found: ${id}`);
+  const result = buildReadDocResult(page);
+  return { rawData: result.rawData, displayData: result.displayData };
+}
+
+export const cliWhoamiFunctionSchema = {
+  name: "cliWhoami",
+  description: "Show the current Nolo runtime identity. In Web/RN this reports browser runtime identity.",
+  parameters: { type: "object", properties: {} },
+} as const;
+
+export async function cliWhoamiFunc(_args: any, thunkApi: any): Promise<ToolResult> {
+  const runtime = getRuntime(thunkApi);
+  const result = {
+    success: true,
+    runtime: "browser",
+    serverBase: runtime?.currentServer ?? null,
+    userId: runtime?.currentUserId ?? null,
+    authenticated: !!runtime?.currentToken,
+  };
+  return { rawData: result, displayData: jsonPreview(result) };
+}
+
+export const cliDoctorFunctionSchema = {
+  name: "cliDoctor",
+  description: "Show Nolo runtime diagnostics. In Web/RN this reports browser tool diagnostics.",
+  parameters: { type: "object", properties: {} },
+} as const;
+
+export async function cliDoctorFunc(_args: any, thunkApi: any): Promise<ToolResult> {
+  const runtime = getRuntime(thunkApi);
+  const result = {
+    success: true,
+    runtime: "browser",
+    serverBase: runtime?.currentServer ?? null,
+    authenticated: !!runtime?.currentToken,
+    userId: runtime?.currentUserId ?? null,
+    diagnosticScope: "nolo_workspace_subset",
+    message:
+      "workspaceTools is a subset for Nolo workspace inspection, not necessarily the complete current run tool surface.",
+    noloWorkspaceToolSubset: [...NOLO_WORKSPACE_TOOL_NAMES],
+    workspaceTools: [...NOLO_WORKSPACE_TOOL_NAMES],
+    workspaceToolsAreSubset: true,
+  };
+  return { rawData: result, displayData: jsonPreview(result) };
+}

package/ai/tools/olmOcrTool.ts

@@ -0,0 +1,33 @@
+import { callToolApi } from "./toolApiClient";
+
+export const olmOcrSchema = {
+    name: "olm_ocr",
+    description: "使用 allenai/olmOCR-2-7B-1025 模型进行光学字符识别 (OCR)。适合文档、论文等结构化文本的高质量识别。",
+    parameters: {
+        type: "object",
+        properties: {
+            imageUrl: {
+                type: "string",
+                description: "要进行 OCR 的图片 URL、base64 编码的图片数据，或者内部文件 ID (如 'file-...')。",
+            },
+            prompt: {
+                type: "string",
+                description: "可选的提示词，用于指导模型如何提取信息（例如：'提取所有表格数据' 或 '识别图片中的所有文字'）。默认为 '识别图片中的所有文字'。",
+                default: "识别图片中的所有文字"
+            }
+        },
+        required: ["imageUrl"],
+    },
+};
+
+export const olmOcrFunc = async (input: any, thunkApi: any): Promise<any> => {
+    const { imageUrl, prompt = "识别图片中的所有文字" } = input;
+
+    const data = await callToolApi(thunkApi, "/api/olm-ocr", { imageUrl, prompt }, { withAuth: true });
+
+    return {
+        summary: "OCR processing completed",
+        text: data.choices?.[0]?.message?.content || "No text detected",
+        rawData: data
+    };
+};