nolo-cli 0.16.0 → 0.17.0

package/chunk-KFEVY3ST.js

@@ -0,0 +1,255 @@
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+
+// packages/agent-runtime/openAiCompatibleMessages.ts
+function preserveAgentStateFields(source, target, options) {
+  const mutableTarget = target;
+  if (source.role === "assistant") {
+    if (!options?.stripReasoningContent && typeof source.reasoning_content === "string") {
+      mutableTarget.reasoning_content = source.reasoning_content;
+    }
+    if (Array.isArray(source.tool_calls)) {
+      mutableTarget.tool_calls = source.tool_calls;
+    }
+  }
+  if (source.role === "tool") {
+    const toolCallId = typeof source.tool_call_id === "string" ? source.tool_call_id.trim() : typeof source.toolCallId === "string" ? source.toolCallId.trim() : "";
+    if (toolCallId) mutableTarget.tool_call_id = toolCallId;
+  }
+  return target;
+}
+function toOpenAiCompatibleMessages(messages, options) {
+  return messages.map(
+    (message) => preserveAgentStateFields(message, {
+      role: message.role,
+      content: message.content ?? ""
+    }, options)
+  );
+}
+function shouldStripReasoningContentForOutbound(provider, model) {
+  const p = provider?.trim().toLowerCase();
+  const m = model?.trim().toLowerCase();
+  if (!p || !m) return false;
+  if (p === "deepseek" || p === "nolo") return m === "deepseek-v4-flash";
+  return false;
+}
+
+// packages/integrations/openai/responsesHelpers.ts
+var RESPONSES_TOP_LEVEL_SCHEMA_KEYS = ["anyOf", "oneOf", "allOf", "enum", "not"];
+var sanitizeResponsesParameters = (parameters) => {
+  if (!isRecord(parameters)) {
+    return parameters;
+  }
+  const next = { ...parameters };
+  for (const key of RESPONSES_TOP_LEVEL_SCHEMA_KEYS) {
+    delete next[key];
+  }
+  return next;
+};
+var appendTextPart = (parts, text, role) => {
+  if (!text) return;
+  const last = parts.at(-1);
+  const textType = role === "assistant" ? "output_text" : "input_text";
+  if (last?.type === textType) {
+    last.text += text;
+    return;
+  }
+  parts.push({ type: textType, text });
+};
+var normalizeMessageParts = (content, role) => {
+  if (typeof content === "string") {
+    if (!content) return [];
+    return [
+      {
+        type: role === "assistant" ? "output_text" : "input_text",
+        text: content
+      }
+    ];
+  }
+  const parts = [];
+  for (const part of content ?? []) {
+    const typedPart = part;
+    if (typedPart?.type === "text" && typeof typedPart.text === "string") {
+      appendTextPart(parts, typedPart.text, role);
+      continue;
+    }
+    if (typedPart?.type === "image_url" && typeof typedPart.image_url?.url === "string" && typedPart.image_url.url) {
+      if (role === "assistant") continue;
+      parts.push({
+        type: "input_image",
+        image_url: typedPart.image_url.url,
+        detail: typedPart.image_url.detail
+      });
+    }
+  }
+  return parts;
+};
+var normalizeToolOutput = (content) => {
+  if (typeof content === "string") return content;
+  return JSON.stringify(content ?? "");
+};
+var toResponsesTools = (tools) => {
+  if (!Array.isArray(tools) || tools.length === 0) return void 0;
+  return tools.map((tool) => {
+    const fn = tool?.function;
+    if (!fn?.name) return null;
+    return {
+      type: "function",
+      name: fn.name,
+      description: fn.description,
+      parameters: sanitizeResponsesParameters(fn.parameters),
+      strict: fn.strict
+    };
+  }).filter(Boolean);
+};
+var convertMessagesToResponsesInput = (messages, options) => {
+  const input = [];
+  for (const message of messages) {
+    if (!message?.role) continue;
+    if (message.role === "tool") {
+      if (!message.tool_call_id) continue;
+      input.push({
+        type: "function_call_output",
+        call_id: message.tool_call_id,
+        output: normalizeToolOutput(message.content)
+      });
+      continue;
+    }
+    const role = message.role;
+    if (role === "assistant" && !options?.stripReasoningContent && typeof message.reasoning_content === "string" && message.reasoning_content) {
+      input.push({ type: "reasoning", content: message.reasoning_content });
+    }
+    const contentParts = normalizeMessageParts(message.content, role);
+    if (contentParts.length > 0) {
+      input.push({
+        type: "message",
+        role,
+        content: contentParts
+      });
+    }
+    if (role === "assistant" && Array.isArray(message.content)) {
+      const replayImages = message.content.map((part) => part).filter(
+        (part) => part?.type === "image_url" && typeof part.image_url?.url === "string" && Boolean(part.image_url.url)
+      ).map((part) => ({
+        type: "input_image",
+        image_url: part.image_url.url,
+        detail: part.image_url.detail
+      }));
+      if (replayImages.length > 0) {
+        input.push({
+          type: "message",
+          role: "user",
+          content: replayImages
+        });
+      }
+    }
+    if (role === "assistant" && Array.isArray(message.tool_calls)) {
+      for (const toolCall of message.tool_calls) {
+        if (!toolCall?.id || !toolCall.function?.name) continue;
+        input.push({
+          type: "function_call",
+          call_id: toolCall.id,
+          name: toolCall.function.name,
+          arguments: typeof toolCall.function.arguments === "string" ? toolCall.function.arguments : JSON.stringify(toolCall.function.arguments ?? {})
+        });
+      }
+    }
+  }
+  return input;
+};
+var extractTextFromResponseOutput = (response) => {
+  const parts = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      if (content?.type === "output_text" && typeof content.text === "string") {
+        parts.push(content.text);
+      }
+    }
+  }
+  return parts.join("");
+};
+var toDataUrl = (base64Data, mimeType) => {
+  const normalizedMimeType = asOptionalTrimmedString(mimeType) ?? "image/png";
+  return `data:${normalizedMimeType};base64,${base64Data}`;
+};
+var extractImagePartsFromResponseOutput = (response) => {
+  const images = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type === "image_generation_call") {
+      const result = asOptionalTrimmedString(item.result);
+      if (result) {
+        const outputFormat = asOptionalTrimmedString(item.output_format);
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              result,
+              outputFormat ? `image/${outputFormat}` : void 0
+            )
+          }
+        });
+      }
+      continue;
+    }
+    if (item?.type !== "message") continue;
+    for (const content of item.content ?? []) {
+      const result = asOptionalTrimmedString(content?.result);
+      if (content?.type === "output_image" && result) {
+        images.push({
+          type: "image_url",
+          image_url: {
+            url: toDataUrl(
+              result,
+              content.mime_type ?? content.mimeType ?? null
+            )
+          }
+        });
+      }
+    }
+  }
+  return images;
+};
+var extractToolCallsFromResponseOutput = (response) => {
+  const calls = [];
+  for (const item of response?.output ?? []) {
+    if (item?.type !== "function_call") continue;
+    if (!item.call_id || !item.name) continue;
+    calls.push({
+      id: item.call_id,
+      type: "function",
+      function: {
+        name: item.name,
+        arguments: typeof item.arguments === "string" ? item.arguments : JSON.stringify(item.arguments ?? {})
+      }
+    });
+  }
+  return calls;
+};
+
+// packages/core/chat/imageParts.ts
+function isImageUrlPart(part) {
+  return isRecord(part) && part.type === "image_url";
+}
+function hasImageParts(messages) {
+  return messages.some(
+    (message) => Array.isArray(message.content) && message.content.some(isImageUrlPart)
+  );
+}
+
+export {
+  isImageUrlPart,
+  hasImageParts,
+  preserveAgentStateFields,
+  toOpenAiCompatibleMessages,
+  shouldStripReasoningContentForOutbound,
+  toResponsesTools,
+  convertMessagesToResponsesInput,
+  extractTextFromResponseOutput,
+  extractImagePartsFromResponseOutput,
+  extractToolCallsFromResponseOutput
+};

package/{chunk-P3RIAYGG.js → chunk-L2MLZQXU.js}

@@ -7,11 +7,11 @@ import {
   listUserRecordsFromServers,
   readDbRecordFromServers,
   readLiveDbRecordAfterTombstoneMerge
-} from "./chunk-NVEWUJVX.js";
+} from "./chunk-ZVOZH2HW.js";
 import {
   buildDialogAttachmentPlan,
   extractFileContentIds
-} from "./chunk-MTU75CZ2.js";
+} from "./chunk-B5TOXZAK.js";
 import {
   toErrorMessage
 } from "./chunk-HNMXYYJR.js";
@@ -625,7 +625,7 @@ async function tryHttpDialogCandidates(args) {
   throw Object.assign(new Error("All HTTP dialog reads failed"), { attempts });
 }
 async function readDialogFromLocalDb(dialogKey, dialogId, limit) {
-  const { readDialogFromLocalDb: readLocalDialog } = await import("./localDialogRead-2VRI24F4.js");
+  const { readDialogFromLocalDb: readLocalDialog } = await import("./localDialogRead-HQZPVIE3.js");
   const result = await readLocalDialog({ dialogKey, dialogId, limit });
   return {
     ...result,

package/{chunk-55NSNCFM.js → chunk-L6NVTGI7.js}

@@ -1,6 +1,6 @@
 import {
   trimTrailingSlash
-} from "./chunk-6EVITP2G.js";
+} from "./chunk-MUCU6ATG.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";

package/{chunk-3WGLLTK4.js → chunk-LSFAWXKC.js}

@@ -1,6 +1,4 @@
-// packages/agent-runtime/thinkTagParser.ts
-var OPEN_TAG = "<think>";
-var CLOSE_TAG = "</think>";
+// packages/agent-runtime/tagPrefixMatch.ts
 function longestTagPrefixLength(buffer, tag) {
   const max = Math.min(buffer.length, tag.length - 1);
   for (let len = max; len > 0; len--) {
@@ -10,6 +8,10 @@ function longestTagPrefixLength(buffer, tag) {
   }
   return 0;
 }
+
+// packages/agent-runtime/thinkTagParser.ts
+var OPEN_TAG = "<think>";
+var CLOSE_TAG = "</think>";
 function extractThinkContent(content) {
   const regex = new RegExp(`${OPEN_TAG}([\\s\\S]*?)${CLOSE_TAG}`, "g");
   const matches = [...content.matchAll(regex)];
@@ -81,6 +83,98 @@ function flushThinkParser(state) {
   };
 }
 
+// packages/agent-runtime/toolCallTextParser.ts
+var OPEN_TAG2 = "<tool_call>";
+var CLOSE_TAG2 = "</tool_call>";
+function createToolCallTextParserState() {
+  return { mode: "content", buffer: "" };
+}
+function processToolCallTextChunk(chunk, state) {
+  let visible = "";
+  let toolCallTexts = [];
+  let { mode, buffer } = state;
+  buffer += chunk;
+  while (true) {
+    if (mode === "content") {
+      const idx = buffer.indexOf(OPEN_TAG2);
+      if (idx === -1) {
+        const keep = longestTagPrefixLength(buffer, OPEN_TAG2);
+        visible += buffer.slice(0, buffer.length - keep);
+        buffer = buffer.slice(buffer.length - keep);
+        break;
+      }
+      visible += buffer.slice(0, idx);
+      buffer = buffer.slice(idx + OPEN_TAG2.length);
+      mode = "toolcall";
+    } else {
+      const idx = buffer.indexOf(CLOSE_TAG2);
+      if (idx === -1) {
+        break;
+      }
+      toolCallTexts.push(buffer.slice(0, idx));
+      buffer = buffer.slice(idx + CLOSE_TAG2.length);
+      mode = "content";
+    }
+  }
+  return {
+    content: visible,
+    toolCallTexts,
+    state: { mode, buffer }
+  };
+}
+function flushToolCallTextParser(state) {
+  const { mode, buffer } = state;
+  if (mode === "toolcall") {
+    const keep = longestTagPrefixLength(buffer, CLOSE_TAG2);
+    const text = buffer.slice(0, buffer.length - keep);
+    return {
+      content: "",
+      toolCallTexts: text ? [text] : [],
+      state: { mode: "content", buffer: "" }
+    };
+  }
+  return {
+    content: buffer,
+    toolCallTexts: [],
+    state: { mode: "content", buffer: "" }
+  };
+}
+function tryParseToolCallText(text) {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed === "object" && parsed !== null && typeof parsed.name === "string") {
+      return {
+        name: parsed.name,
+        arguments: typeof parsed.arguments === "string" ? parsed.arguments : JSON.stringify(parsed.arguments ?? {})
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+function processContentChunkWithToolCallStripping(chunk, state, onToolCall) {
+  const stripped = processToolCallTextChunk(chunk, state);
+  for (const text of stripped.toolCallTexts) {
+    const parsedTc = tryParseToolCallText(text);
+    if (parsedTc) {
+      onToolCall(parsedTc.name, parsedTc.arguments);
+    }
+  }
+  return { cleanedContent: stripped.content, state: stripped.state };
+}
+function flushToolCallTextParserIntoCallback(state, onToolCall) {
+  const flushed = flushToolCallTextParser(state);
+  for (const text of flushed.toolCallTexts) {
+    const parsedTc = tryParseToolCallText(text);
+    if (parsedTc) {
+      onToolCall(parsedTc.name, parsedTc.arguments);
+    }
+  }
+  return { residualContent: flushed.content, state: flushed.state };
+}
+
 // packages/agent-runtime/toolCallAccumulator.ts
 function createToolCallAccumulator() {
   return { slots: [] };
@@ -141,6 +235,9 @@ export {
   createThinkParserState,
   processThinkChunk,
   flushThinkParser,
+  createToolCallTextParserState,
+  processContentChunkWithToolCallStripping,
+  flushToolCallTextParserIntoCallback,
   createToolCallAccumulator,
   accumulateToolCallDelta,
   finalizeAccumulatedToolCalls

package/{chunk-S2LXHNHG.js → chunk-MD3V54DA.js}

@@ -11,16 +11,16 @@ import {
   patch,
   remove,
   write
-} from "./chunk-3S2VOMIF.js";
+} from "./chunk-XRZJGPFI.js";
 import {
   createAgentKey,
   toTrimmedString
-} from "./chunk-O4BU24WZ.js";
+} from "./chunk-6Y7A3OQQ.js";
 import {
   asyncThunkCreator,
   buildCreateSlice,
   getRuntimeServerContext
-} from "./chunk-DVRHHFEA.js";
+} from "./chunk-XMLRJUU5.js";
 import {
   asTrimmedString
 } from "./chunk-3EUW3WEO.js";
@@ -300,7 +300,7 @@ var slice = createSliceWithThunks({
       const overrides = {};
       if (args.systemPromptOverride !== void 0) overrides.prompt = args.systemPromptOverride;
       if (args.toolsOverride !== void 0) overrides.tools = args.toolsOverride;
-      const { _executeModel } = await import("./_executeModel-AVCA2NAV.js");
+      const { _executeModel } = await import("./_executeModel-WPNX5DH4.js");
       return _executeModel(
         {
           isStreaming: args.isStreaming ?? false,
@@ -321,7 +321,7 @@ var slice = createSliceWithThunks({
      * - 循环直到无工具调用或触发其他运行时停止条件
      */
     runAgent: create.asyncThunk(async (args, thunkApi) => {
-      const { runAgentClientLoop } = await import("./runAgentClientLoop-JZCOP7LG.js");
+      const { runAgentClientLoop } = await import("./runAgentClientLoop-OBD2AVEL.js");
       const { content: loopContent, toolCallCount } = await runAgentClientLoop(
         {
           agentKey: args.agentKey,
@@ -337,7 +337,7 @@ var slice = createSliceWithThunks({
      * 聊天轮次流式 Agent 调用
      */
     streamAgentChatTurn: create.asyncThunk(async (args, thunkApi) => {
-      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-Y6WGATQR.js");
+      const { streamAgentChatTurnHandler } = await import("./streamAgentChatTurn-UHEMNI3X.js");
       return streamAgentChatTurnHandler(args, thunkApi);
     }),
     /**