@ai-setting/roy-agent-core 1.7.46 → 1.7.47

package/dist/shared/@ai-setting/{roy-agent-core-r4z6h3ch.js → roy-agent-core-zy3hqfwg.js}

@@ -60,18 +60,212 @@ function buildOpencodeHeaders(providerId, conversationId, baseURL) {
 }
 
 // src/env/llm/invoke.ts
-init_logger();
 import { randomUUID } from "crypto";
 import { streamText, jsonSchema } from "ai";
 import { createOpenAI } from "@ai-sdk/openai";
 import { createAnthropic } from "@ai-sdk/anthropic";
 import { createGoogleGenerativeAI } from "@ai-sdk/google";
 import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+
+// src/env/llm/tool-schema.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
+function isZodSchema(obj) {
+  return !!obj && typeof obj === "object" && "_def" in obj;
+}
+function dereference(node, root, seenRefs = new Set) {
+  if (Array.isArray(node)) {
+    return node.map((n) => dereference(n, root, seenRefs));
+  }
+  if (!node || typeof node !== "object")
+    return node;
+  const obj = node;
+  const ref = obj["$ref"];
+  if (typeof ref === "string" && ref.startsWith("#/")) {
+    if (seenRefs.has(ref)) {
+      return { type: "object" };
+    }
+    const target = resolvePointer(root, ref);
+    if (target === undefined) {
+      return { type: "object" };
+    }
+    const nextSeen = new Set(seenRefs);
+    nextSeen.add(ref);
+    const resolved = dereference(target, root, nextSeen);
+    const { $ref: _drop, ...rest } = obj;
+    if (resolved && typeof resolved === "object" && !Array.isArray(resolved)) {
+      return { ...resolved, ...rest };
+    }
+    return resolved;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "definitions" || k === "$defs" || k === "$schema")
+      continue;
+    out[k] = dereference(v, root, seenRefs);
+  }
+  return out;
+}
+function resolvePointer(root, ref) {
+  const path = ref.replace(/^#\//, "").split("/").filter((s) => s.length > 0);
+  let cur = root;
+  for (const rawSeg of path) {
+    const seg = rawSeg.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (cur === null || cur === undefined || typeof cur !== "object")
+      return;
+    cur = cur[seg];
+  }
+  return cur;
+}
+function toolParametersToJsonSchema(parameters) {
+  const EMPTY = {
+    type: "object",
+    properties: {}
+  };
+  if (parameters === null || parameters === undefined)
+    return EMPTY;
+  if (typeof parameters !== "object")
+    return EMPTY;
+  let raw;
+  if (isZodSchema(parameters)) {
+    try {
+      raw = zodToJsonSchema(parameters, "zod");
+    } catch {
+      return EMPTY;
+    }
+  } else {
+    raw = JSON.parse(JSON.stringify(parameters));
+  }
+  const deref = dereference(raw, raw);
+  if (deref["type"] !== "object") {
+    if (deref["properties"] && typeof deref["properties"] === "object") {
+      deref["type"] = "object";
+    } else {
+      return EMPTY;
+    }
+  }
+  if (!deref["properties"] || typeof deref["properties"] !== "object") {
+    deref["properties"] = {};
+  }
+  delete deref["definitions"];
+  delete deref["$defs"];
+  delete deref["$schema"];
+  return deref;
+}
+
+// src/env/llm/invoke.ts
+init_logger();
 
 // src/env/llm/tool-args-parser.ts
 init_logger();
 var logger = createLogger("llm:tool-args-parser");
+var ARG_KEY_RE = /<arg_key>([\s\S]*?)<\/arg_key>\s*<arg_value>([\s\S]*?)<\/arg_value>/g;
+function salvageTextualToolArgs(raw) {
+  if (!raw.includes("<arg_key>"))
+    return;
+  const out = {};
+  let matched = false;
+  ARG_KEY_RE.lastIndex = 0;
+  let m;
+  while ((m = ARG_KEY_RE.exec(raw)) !== null) {
+    const key = m[1].trim();
+    if (!key)
+      continue;
+    const value = m[2];
+    try {
+      out[key] = JSON.parse(value);
+    } catch {
+      out[key] = value;
+    }
+    matched = true;
+  }
+  return matched ? out : undefined;
+}
+function stripTextualToolArgsMarkers(raw) {
+  return raw.replace(/<\/?arg_key>/g, "").replace(/<\/?arg_value>/g, "").replace(/<\/?tool_call>/g, "");
+}
+function parseToolArgsStrict(args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    return { ok: true, args };
+  }
+  if (typeof args !== "string") {
+    return {
+      ok: false,
+      args: {},
+      error: `tool arguments must be a JSON object, got ${args === null ? "null" : typeof args}`
+    };
+  }
+  const raw = args.trim();
+  if (raw.length === 0) {
+    return { ok: true, args: {} };
+  }
+  const direct = tryParseObject(raw);
+  if (direct.ok) {
+    if (raw.includes("<arg_key>") || raw.includes("<arg_value>") || raw.includes("<tool_call>")) {
+      logger.warn("[parseToolArgsStrict] arguments 里出现上游文本工具调用标记，已清洗值中的 marker");
+      return { ok: true, args: sanitizeArgValues(direct.args), salvaged: true };
+    }
+    return { ok: true, args: direct.args };
+  }
+  if (raw.includes("<arg_key>") || raw.includes("<arg_value>")) {
+    const stripped = stripTextualToolArgsMarkers(raw);
+    const afterStrip = tryParseObject(stripped);
+    if (afterStrip.ok) {
+      logger.warn("[parseToolArgsStrict] 上游把文本工具调用标记混进了 arguments，已剥离 marker 后恢复");
+      return { ok: true, args: afterStrip.args, salvaged: true };
+    }
+    const salvaged = salvageTextualToolArgs(raw);
+    if (salvaged) {
+      logger.warn("[parseToolArgsStrict] 上游输出的是文本工具调用格式，已按 <arg_key>/<arg_value> 重建参数", { keys: Object.keys(salvaged).join(",") });
+      return { ok: true, args: salvaged, salvaged: true };
+    }
+  }
+  const nested = tryParseObject(raw);
+  if (!nested.ok && raw.length > 1) {
+    const rec = safeParseToolArgs(raw);
+    if (Object.keys(rec).length > 0) {
+      return { ok: true, args: rec, salvaged: true };
+    }
+  }
+  return {
+    ok: false,
+    args: {},
+    error: "tool arguments 不是合法 JSON（上游模型输出可能已损坏）。请重新调用该工具，确保 arguments 是合法 JSON 对象。" + ` 原始片段：${raw.slice(0, 200)}`
+  };
+}
+function sanitizeArgValues(args) {
+  const clean = (v) => {
+    if (typeof v === "string")
+      return stripTextualToolArgsMarkers(v);
+    if (Array.isArray(v))
+      return v.map(clean);
+    if (v && typeof v === "object") {
+      const out = {};
+      for (const [k, val] of Object.entries(v)) {
+        out[k] = clean(val);
+      }
+      return out;
+    }
+    return v;
+  };
+  return clean(args);
+}
+function tryParseObject(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+      return { ok: true, args: parsed };
+    }
+    if (typeof parsed === "string") {
+      const twice = JSON.parse(parsed);
+      if (twice && typeof twice === "object" && !Array.isArray(twice)) {
+        return { ok: true, args: twice };
+      }
+    }
+    return { ok: false };
+  } catch {
+    return { ok: false };
+  }
+}
 var MAX_SAFE_DEPTH = 5;
 function safeParseToolArgs(args, depth = 0) {
   if (depth >= MAX_SAFE_DEPTH) {
@@ -448,23 +642,7 @@ function convertToolsToSDK(tools, providerName) {
   return result;
 }
 function extractToolSchema(parameters) {
-  if (parameters && typeof parameters === "object" && "_def" in parameters) {
-    const zodSchema = parameters;
-    const schema = zodToJsonSchema(zodSchema, "zod");
-    if ("$ref" in schema && schema.definitions) {
-      const def = schema.definitions.zod;
-      if (def && def.type === "object" && def.properties) {
-        return {
-          type: "object",
-          properties: def.properties,
-          required: def.required,
-          additionalProperties: true
-        };
-      }
-    }
-    return schema;
-  }
-  return parameters;
+  return toolParametersToJsonSchema(parameters);
 }
 function generateProviderOptions(providerType, options) {
   const result = {
@@ -948,4 +1126,4 @@ function createInvokeConfig(model, apiKey, baseURL) {
   };
 }
 
-export { safeParseToolArgs, generateOpencodeSessionId, isOpencodeProvider, isOpencodeEndpoint, getOrCreateOpencodeSessionId, buildOpencodeHeaders, canonicalizeParts, withTimeout, parseModelString, convertToSDKMessages, invoke, invokeNonStream, createInvokeConfig };
+export { toolParametersToJsonSchema, parseToolArgsStrict, safeParseToolArgs, generateOpencodeSessionId, isOpencodeProvider, isOpencodeEndpoint, getOrCreateOpencodeSessionId, buildOpencodeHeaders, canonicalizeParts, withTimeout, parseModelString, convertToSDKMessages, invoke, invokeNonStream, createInvokeConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.46",
+  "version": "1.7.47",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",