@opentiny/next-sdk 0.2.7 → 0.2.8

package/agent/AgentModelProvider.ts

@@ -1,4 +1,4 @@
-import { streamText, stepCountIs, generateText, StreamTextResult } from 'ai'
+import { streamText, stepCountIs, generateText } from 'ai'
 import { MCPClientConfig, createMCPClient } from '@ai-sdk/mcp'
 import type { ToolSet } from 'ai'
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'
@@ -281,18 +281,27 @@ export class AgentModelProvider {
     this.onUpdatedTools?.()
   }
 
-  /** 创建临时允许调用的tools集合 */
-  private _tempMergeTools(extraTool = {}) {
-    // 将对象的值转换为数组后再 reduce
-    const toolsResult = Object.values(this.mcpTools).reduce((acc, curr) => ({ ...acc, ...curr }), {})
+  /** 创建临时允许调用的 tools 集合，合并 mcpTools 与 extraTool */
+  private _tempMergeTools(extraTool: ToolSet = {} as ToolSet, deleteIgnored = true): ToolSet {
+    const toolsResult: ToolSet = Object.values(this.mcpTools).reduce(
+      (acc, curr) => ({ ...acc, ...curr } as ToolSet),
+      {} as ToolSet
+    )
     Object.assign(toolsResult, extraTool)
 
-    this.ignoreToolnames.forEach((name) => {
-      delete toolsResult[name]
-    })
+    if (deleteIgnored) {
+      this.ignoreToolnames.forEach((name) => {
+        delete toolsResult[name]
+      })
+    }
     return toolsResult
   }
 
+  /** 获取当前激活的 tools 名称列表（过滤 ignoreToolnames） */
+  private _getActiveToolNames(tools: ToolSet): string[] {
+    return Object.keys(tools).filter((name) => !this.ignoreToolnames.includes(name))
+  }
+
   /** 生成 ReAct 模式的系统提示词（包含工具描述） */
   private _generateReActSystemPrompt(tools: ToolSet, modelName: string, baseSystemPrompt?: string): string {
     // 统一使用 XML 格式的 ReAct 提示词（所有 ReAct 模式都使用相同格式）
@@ -342,7 +351,7 @@ export class AgentModelProvider {
     await this.initClientsAndTools()
 
     // 合并所有可用工具
-    const allTools = this._tempMergeTools(options.tools) as ToolSet
+    const allTools = this._tempMergeTools(options.tools)
     const toolNames = Object.keys(allTools)
 
     // 如果没有工具，回退到普通模式
@@ -810,12 +819,15 @@ export class AgentModelProvider {
 
     await this.initClientsAndTools()
 
+    const allTools = this._tempMergeTools(options.tools, false)
+
     const chatOptions = {
       // @ts-ignore  ProviderV2 是所有llm的父类， 在每一个具体的llm 类都有一个选择model的函数用法
       model: this.llm(model),
       stopWhen: stepCountIs(maxSteps),
       ...options,
-      tools: this._tempMergeTools(options.tools) as ToolSet
+      tools: allTools,
+      activeTools: this._getActiveToolNames(allTools),
     }
 
     // 保存最后一条 user 消息，用于后续缓存

package/dist/agent/AgentModelProvider.d.ts

@@ -53,8 +53,10 @@ export declare class AgentModelProvider {
     insertMcpServer(serverName: string, mcpServer: McpServerConfig): Promise<false | WebMcpClient | import('@ai-sdk/mcp').MCPClient | null>;
     /** 通过服务器名称删除mcpServer： mcpServers mcpClients  mcpTools ignoreToolnames  */
     removeMcpServer(serverName: string): Promise<void>;
-    /** 创建临时允许调用的tools集合 */
+    /** 创建临时允许调用的 tools 集合，合并 mcpTools 与 extraTool */
     private _tempMergeTools;
+    /** 获取当前激活的 tools 名称列表（过滤 ignoreToolnames） */
+    private _getActiveToolNames;
     /** 生成 ReAct 模式的系统提示词（包含工具描述） */
     private _generateReActSystemPrompt;
     /** 执行 ReAct 模式下的工具调用 */

package/dist/index.d.ts

@@ -26,5 +26,5 @@ export { AgentModelProvider } from './agent/AgentModelProvider';
 export { getAISDKTools } from './agent/utils/getAISDKTools';
 export { QrCode, type QrCodeOption } from './remoter/QrCode';
 export type * from './agent/type';
-export * from './page-tool-bridge';
+export * from './page-tools/bridge';
 export { getSkillOverviews, formatSkillsForSystemPrompt, getSkillMdPaths, getSkillMdContent, getMainSkillPaths, getMainSkillPathByName, parseSkillFrontMatter, createSkillTools, type SkillMeta, type SkillToolsSet } from './skills/index';

package/dist/index.es.dev.js

@@ -27758,6 +27758,19 @@ class FloatingBlock {
       this.dropdownMenu.parentNode.removeChild(this.dropdownMenu);
     }
   }
+  // 隐藏组件
+  hide() {
+    if (this.floatingBlock) {
+      this.floatingBlock.style.display = "none";
+    }
+    this.closeDropdown();
+  }
+  // 显示组件
+  show() {
+    if (this.floatingBlock) {
+      this.floatingBlock.style.display = "flex";
+    }
+  }
 }
 const createRemoter = (options = {}) => {
   return new FloatingBlock(options);
@@ -49772,15 +49785,24 @@ class AgentModelProvider {
     }
     this.onUpdatedTools?.();
   }
-  /** 创建临时允许调用的tools集合 */
-  _tempMergeTools(extraTool = {}) {
-    const toolsResult = Object.values(this.mcpTools).reduce((acc, curr) => ({ ...acc, ...curr }), {});
+  /** 创建临时允许调用的 tools 集合，合并 mcpTools 与 extraTool */
+  _tempMergeTools(extraTool = {}, deleteIgnored = true) {
+    const toolsResult = Object.values(this.mcpTools).reduce(
+      (acc, curr) => ({ ...acc, ...curr }),
+      {}
+    );
     Object.assign(toolsResult, extraTool);
-    this.ignoreToolnames.forEach((name16) => {
-      delete toolsResult[name16];
-    });
+    if (deleteIgnored) {
+      this.ignoreToolnames.forEach((name16) => {
+        delete toolsResult[name16];
+      });
+    }
     return toolsResult;
   }
+  /** 获取当前激活的 tools 名称列表（过滤 ignoreToolnames） */
+  _getActiveToolNames(tools) {
+    return Object.keys(tools).filter((name16) => !this.ignoreToolnames.includes(name16));
+  }
   /** 生成 ReAct 模式的系统提示词（包含工具描述） */
   _generateReActSystemPrompt(tools, modelName, baseSystemPrompt) {
     const toolsPrompt = generateReActToolsPrompt(tools);
@@ -50124,12 +50146,14 @@ ${observationText}
       throw new Error("LLM is not initialized");
     }
     await this.initClientsAndTools();
+    const allTools = this._tempMergeTools(options.tools, false);
     const chatOptions = {
       // @ts-ignore  ProviderV2 是所有llm的父类， 在每一个具体的llm 类都有一个选择model的函数用法
       model: this.llm(model),
       stopWhen: stepCountIs(maxSteps),
       ...options,
-      tools: this._tempMergeTools(options.tools)
+      tools: allTools,
+      activeTools: this._getActiveToolNames(allTools)
     };
     let lastUserMessage = null;
     if (options.message && !options.messages) {
@@ -50159,6 +50183,282 @@ ${observationText}
     return this._chat(streamText, options);
   }
 }
+let overlayElement = null;
+let labelElement = null;
+let styleElement = null;
+let activeCount = 0;
+const BODY_GLOW_CLASS = "next-sdk-tool-body-glow";
+function ensureDomReady() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function ensureStyleElement() {
+  if (!ensureDomReady()) return;
+  if (styleElement) return;
+  const style = document.createElement("style");
+  style.textContent = `
+  .${BODY_GLOW_CLASS} {
+    position: relative;
+  }
+
+  .next-sdk-tool-overlay {
+    position: fixed;
+    inset: 0;
+    z-index: 999999;
+    pointer-events: none;
+    display: flex;
+    align-items: flex-end;
+    justify-content: flex-start;
+    padding: 0 0 18px 18px;
+    background: transparent;
+    animation: next-sdk-overlay-fade-in 260ms ease-out;
+  }
+
+  .next-sdk-tool-overlay--exit {
+    animation: next-sdk-overlay-fade-out 220ms ease-in forwards;
+  }
+
+  .next-sdk-tool-overlay__glow-ring {
+    display: none;
+  }
+
+  .next-sdk-tool-overlay__panel {
+    position: relative;
+    min-width: min(320px, 78vw);
+    max-width: min(420px, 82vw);
+    padding: 10px 14px;
+    border-radius: 999px;
+    background:
+      linear-gradient(135deg, rgba(15, 23, 42, 0.9), rgba(17, 24, 39, 0.9)),
+      radial-gradient(circle at top left, rgba(96, 165, 250, 0.25), transparent 55%),
+      radial-gradient(circle at bottom right, rgba(45, 212, 191, 0.22), transparent 60%);
+    box-shadow:
+      0 12px 28px rgba(15, 23, 42, 0.78),
+      0 0 0 1px rgba(148, 163, 184, 0.26);
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    pointer-events: none;
+    transform-origin: center;
+    animation: next-sdk-panel-pop-in 260ms cubic-bezier(0.18, 0.89, 0.32, 1.28);
+    color: #e5e7eb;
+    font-family: system-ui, -apple-system, BlinkMacSystemFont, "SF Pro Text", sans-serif;
+  }
+
+  .next-sdk-tool-overlay__indicator {
+    width: 26px;
+    height: 26px;
+    border-radius: 999px;
+    background: radial-gradient(circle at 30% 10%, #f9fafb, #93c5fd);
+    box-shadow:
+      0 0 0 1px rgba(191, 219, 254, 0.6),
+      0 8px 18px rgba(37, 99, 235, 0.8),
+      0 0 28px rgba(56, 189, 248, 0.9);
+    position: relative;
+    flex-shrink: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    overflow: hidden;
+  }
+
+  .next-sdk-tool-overlay__indicator-orbit {
+    position: absolute;
+    inset: 2px;
+    border-radius: inherit;
+    border: 1px solid rgba(248, 250, 252, 0.6);
+    box-sizing: border-box;
+    opacity: 0.9;
+  }
+
+  .next-sdk-tool-overlay__indicator-orbit::before {
+    content: '';
+    position: absolute;
+    width: 6px;
+    height: 6px;
+    border-radius: 999px;
+    background: #f9fafb;
+    box-shadow:
+      0 0 12px rgba(248, 250, 252, 0.9),
+      0 0 24px rgba(250, 249, 246, 0.9);
+    top: 0;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    transform-origin: 50% 18px;
+    animation: next-sdk-indicator-orbit 1.4s linear infinite;
+  }
+
+  .next-sdk-tool-overlay__indicator-core {
+    width: 14px;
+    height: 14px;
+    border-radius: inherit;
+    background: radial-gradient(circle at 30% 20%, #f9fafb, #bfdbfe);
+    box-shadow:
+      0 0 12px rgba(248, 250, 252, 0.9),
+      0 0 32px rgba(191, 219, 254, 0.8);
+    opacity: 0.96;
+  }
+
+  .next-sdk-tool-overlay__content {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    min-width: 0;
+  }
+
+  .next-sdk-tool-overlay__title {
+    font-size: 11px;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+    color: rgba(156, 163, 175, 0.96);
+    display: flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .next-sdk-tool-overlay__title-dot {
+    width: 6px;
+    height: 6px;
+    border-radius: 999px;
+    background: #22c55e;
+    box-shadow:
+      0 0 8px rgba(34, 197, 94, 0.9),
+      0 0 14px rgba(22, 163, 74, 0.9);
+  }
+
+  .next-sdk-tool-overlay__label {
+    font-size: 12px;
+    font-weight: 500;
+    color: #e5e7eb;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    overflow: hidden;
+  }
+
+  @keyframes next-sdk-overlay-fade-in {
+    from { opacity: 0; }
+    to { opacity: 1; }
+  }
+
+  @keyframes next-sdk-overlay-fade-out {
+    from { opacity: 1; }
+    to { opacity: 0; }
+  }
+
+  @keyframes next-sdk-indicator-orbit {
+    from {
+      transform: translate(-50%, -50%) rotate(0deg) translateY(0);
+    }
+    to {
+      transform: translate(-50%, -50%) rotate(360deg) translateY(0);
+    }
+  }
+
+  @keyframes next-sdk-panel-pop-in {
+    0% {
+      opacity: 0;
+      transform: scale(0.92) translateY(10px);
+    }
+    100% {
+      opacity: 1;
+      transform: scale(1) translateY(0);
+    }
+  }
+  `;
+  document.head.appendChild(style);
+  styleElement = style;
+}
+function ensureOverlayElement() {
+  if (!ensureDomReady()) return;
+  if (overlayElement) return;
+  ensureStyleElement();
+  const overlay = document.createElement("div");
+  overlay.className = "next-sdk-tool-overlay";
+  const glowRing = document.createElement("div");
+  glowRing.className = "next-sdk-tool-overlay__glow-ring";
+  const panel = document.createElement("div");
+  panel.className = "next-sdk-tool-overlay__panel";
+  const indicator = document.createElement("div");
+  indicator.className = "next-sdk-tool-overlay__indicator";
+  const indicatorOrbit = document.createElement("div");
+  indicatorOrbit.className = "next-sdk-tool-overlay__indicator-orbit";
+  const indicatorCore = document.createElement("div");
+  indicatorCore.className = "next-sdk-tool-overlay__indicator-core";
+  const content = document.createElement("div");
+  content.className = "next-sdk-tool-overlay__content";
+  const titleRow = document.createElement("div");
+  titleRow.className = "next-sdk-tool-overlay__title";
+  titleRow.textContent = "AI 正在调用页面工具";
+  const titleDot = document.createElement("span");
+  titleDot.className = "next-sdk-tool-overlay__title-dot";
+  const label = document.createElement("div");
+  label.className = "next-sdk-tool-overlay__label";
+  titleRow.prepend(titleDot);
+  content.appendChild(titleRow);
+  content.appendChild(label);
+  indicator.appendChild(indicatorOrbit);
+  indicator.appendChild(indicatorCore);
+  panel.appendChild(indicator);
+  panel.appendChild(content);
+  overlay.appendChild(glowRing);
+  overlay.appendChild(panel);
+  document.body.appendChild(overlay);
+  overlayElement = overlay;
+  labelElement = label;
+}
+function updateOverlay(config2) {
+  if (!ensureDomReady()) return;
+  ensureOverlayElement();
+  if (!overlayElement || !labelElement) return;
+  overlayElement.classList.remove("next-sdk-tool-overlay--exit");
+  labelElement.textContent = config2.label;
+}
+function removeOverlayWithAnimation() {
+  if (!overlayElement) return;
+  overlayElement.classList.add("next-sdk-tool-overlay--exit");
+  const localOverlay = overlayElement;
+  let handled = false;
+  let timerId;
+  const handle = () => {
+    if (handled) return;
+    handled = true;
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+      timerId = void 0;
+    }
+    if (localOverlay.parentNode) {
+      localOverlay.parentNode.removeChild(localOverlay);
+    }
+    if (overlayElement === localOverlay) {
+      overlayElement = null;
+      labelElement = null;
+    }
+    localOverlay.removeEventListener("animationend", handle);
+  };
+  localOverlay.addEventListener("animationend", handle);
+  timerId = setTimeout(handle, 500);
+}
+function showToolInvokeEffect(config2) {
+  if (!ensureDomReady()) return;
+  activeCount += 1;
+  updateOverlay(config2);
+}
+function hideToolInvokeEffect() {
+  if (!ensureDomReady() || activeCount <= 0) return;
+  activeCount -= 1;
+  if (activeCount === 0) {
+    removeOverlayWithAnimation();
+  }
+}
+function resolveRuntimeEffectConfig(toolName, toolTitle, value) {
+  if (!value) return void 0;
+  const baseLabel = toolTitle || toolName;
+  if (typeof value === "boolean") {
+    return value ? { label: baseLabel } : void 0;
+  }
+  return {
+    label: value.label || baseLabel
+  };
+}
 const MSG_TOOL_CALL = "next-sdk:tool-call";
 const MSG_TOOL_RESPONSE = "next-sdk:tool-response";
 const MSG_PAGE_READY = "next-sdk:page-ready";
@@ -50212,7 +50512,7 @@ let _navigator = null;
 function setNavigator(fn) {
   _navigator = fn;
 }
-function buildPageHandler(name16, route, timeout = 3e4) {
+function buildPageHandler(name16, route, timeout = 3e4, effectConfig) {
   return (input) => {
     const callId = randomUUID();
     return new Promise((resolve2, reject) => {
@@ -50224,6 +50524,9 @@ function buildPageHandler(name16, route, timeout = 3e4) {
         if (readyHandler) {
           window.removeEventListener("message", readyHandler);
         }
+        if (effectConfig) {
+          hideToolInvokeEffect();
+        }
       };
       timer = setTimeout(() => {
         cleanup();
@@ -50247,6 +50550,9 @@ function buildPageHandler(name16, route, timeout = 3e4) {
       };
       const run = async () => {
         try {
+          if (effectConfig) {
+            showToolInvokeEffect(effectConfig);
+          }
           if (activePages.get(route)) {
             sendCallOnce();
             return;
@@ -50283,9 +50589,10 @@ function withPageTools(server) {
           if (typeof handlerOrRoute === "function") {
             return rawRegister(name16, config2, handlerOrRoute);
           }
-          const { route, timeout } = handlerOrRoute;
+          const { route, timeout, invokeEffect } = handlerOrRoute;
           toolRouteMap.set(name16, route);
-          return rawRegister(name16, config2, buildPageHandler(name16, route, timeout));
+          const effectConfig = resolveRuntimeEffectConfig(name16, config2?.title, invokeEffect);
+          return rawRegister(name16, config2, buildPageHandler(name16, route, timeout, effectConfig));
         };
       }
       return Reflect.get(target, prop, receiver);
@@ -50383,33 +50690,95 @@ function getSkillMdPaths(modules) {
 }
 function getSkillMdContent(modules, path) {
   const normalized = normalizeSkillModuleKeys(modules);
-  return normalized[path];
+  const exactMatch = normalized[path];
+  if (exactMatch) return exactMatch;
+  const suffix = path.replace(/^\.?\//, "/");
+  const matchingKey = Object.keys(normalized).find((key) => key.endsWith(suffix));
+  return matchingKey ? normalized[matchingKey] : void 0;
 }
 function getMainSkillPathByName(modules, name16) {
-  return getMainSkillPaths(modules).find((p) => p.startsWith(`./${name16}/SKILL.md`));
+  const normalizedModules = normalizeSkillModuleKeys(modules);
+  const paths = getMainSkillPaths(normalizedModules);
+  const dirMatch = paths.find((p) => p.startsWith(`./${name16}/SKILL.md`));
+  if (dirMatch) return dirMatch;
+  for (const p of paths) {
+    const content = normalizedModules[p];
+    if (content) {
+      const parsed = parseSkillFrontMatter(content);
+      if (parsed && parsed.name === name16) {
+        return p;
+      }
+    }
+  }
+  return void 0;
 }
 const SKILL_INPUT_SCHEMA = objectType({
-  skillName: stringType().optional().describe("技能名称，与目录名一致，如 calculator"),
-  path: stringType().optional().describe("文档相对路径，如 ./calculator/SKILL.md 或 ./product-guide/reference/xxx.json")
+  skillName: stringType().optional().describe(
+    '进入某个技能的主入口名称。优先匹配技能的目录名（如 ecommerce），或者技能的中文名称（如"客户价保单创建及审核"）。'
+  ),
+  path: stringType().optional().describe("你想查阅的文档的路径。如 ./calculator/SKILL.md 或从其他文档里看到的相对路径 ./reference/inventory.md。"),
+  currentPath: stringType().optional().describe(
+    "你当前正在阅读的文档路径（如果有）。比如你刚刚读取了 ./ecommerce/SKILL.md，请把这个路径原样传回来，这样系统才能根据你的相对路径准确找到下一份文件。"
+  )
 });
 function createSkillTools(modules) {
   const normalizedModules = normalizeSkillModuleKeys(modules);
   const getSkillContent = tool({
-    description: "根据技能名称或文档路径获取该技能的完整文档内容。传入 skillName（如 calculator）或 path（如 ./calculator/SKILL.md）。支持 .md、.json、.xml 等各类文本格式文件。",
+    description: "根据技能名称或文档路径获取该技能的完整文档内容。如果你想根据相对路径查阅文件，请务必同时提供你当前所在的文件路径 currentPath。",
     inputSchema: SKILL_INPUT_SCHEMA,
     execute: (args) => {
-      const { skillName, path: pathArg } = args;
+      const { skillName, path: pathArg, currentPath: currentPathArg } = args;
       let content;
+      let resolvedPath = "";
       if (pathArg) {
-        content = getSkillMdContent(normalizedModules, pathArg);
+        let basePathContext = ".";
+        if (currentPathArg) {
+          const lastSlashIndex = currentPathArg.lastIndexOf("/");
+          if (lastSlashIndex >= 0) {
+            basePathContext = currentPathArg.slice(0, lastSlashIndex);
+          }
+        }
+        const dummyBase = `http://localhost/${basePathContext}/`;
+        const url2 = new URL(pathArg, dummyBase);
+        resolvedPath = "." + url2.pathname;
+        content = getSkillMdContent(normalizedModules, resolvedPath);
+        if (content === void 0 && (pathArg.startsWith("./") || pathArg.startsWith("../")) && currentPathArg) {
+          const baseParts = currentPathArg.split("/");
+          if (baseParts.length >= 2) {
+            const skillRoot = baseParts[1];
+            const fallbackDummyBase = `http://localhost/${skillRoot}/`;
+            const fallbackUrl = new URL(pathArg, fallbackDummyBase);
+            const fallbackPath = "." + fallbackUrl.pathname;
+            content = getSkillMdContent(normalizedModules, fallbackPath);
+            if (content) {
+              resolvedPath = fallbackPath;
+            }
+          }
+        }
+        if (content && !normalizedModules[resolvedPath]) {
+          const suffix = resolvedPath.replace(/^\.?\//, "/");
+          const matchingKey = Object.keys(normalizedModules).find((key) => key.endsWith(suffix));
+          if (matchingKey) {
+            resolvedPath = matchingKey;
+          }
+        }
       } else if (skillName) {
         const mainPath = getMainSkillPathByName(normalizedModules, skillName);
-        content = mainPath ? getSkillMdContent(normalizedModules, mainPath) : void 0;
+        if (mainPath) {
+          resolvedPath = mainPath;
+          content = getSkillMdContent(normalizedModules, mainPath);
+        }
       }
       if (content === void 0) {
-        return { error: "未找到对应技能文档", skillName: skillName ?? pathArg };
+        return {
+          error: "未找到对应技能文档",
+          skillName,
+          path: pathArg,
+          providedCurrentPath: currentPathArg,
+          attemptedPath: resolvedPath
+        };
       }
-      return { content, path: pathArg ?? getMainSkillPathByName(normalizedModules, skillName) };
+      return { content, path: resolvedPath };
     }
   });
   return {