nolo-cli 0.16.0 → 0.18.0

package/{setDialogExtraReferencesAction-LR6MSIXO.js → chunk-JLA4FXYC.js}

@@ -7,23 +7,7 @@ import {
 import {
   patch,
   selectById
-} from "./chunk-3S2VOMIF.js";
-import "./chunk-O4BU24WZ.js";
-import "./chunk-I42VC5KR.js";
-import "./chunk-WWC7I6TA.js";
-import "./chunk-JTINRTBT.js";
-import "./chunk-QSJ3HFEF.js";
-import "./chunk-XPC5C7BK.js";
-import "./chunk-DVRHHFEA.js";
-import "./chunk-OOSFSFMA.js";
-import "./chunk-GBRG75BQ.js";
-import "./chunk-3EUW3WEO.js";
-import "./chunk-U6VC4MU4.js";
-import "./chunk-KUG52IAP.js";
-import "./chunk-LCBAMY2M.js";
-import "./chunk-4SN6J65J.js";
-import "./chunk-CF7PE763.js";
-import "./chunk-G3SUCT4W.js";
+} from "./chunk-XRZJGPFI.js";
 import {
   __toESM
 } from "./chunk-4VNS5WPM.js";
@@ -54,6 +38,7 @@ var setDialogExtraReferencesAction = async (extraReferences, thunkApi) => {
     })
   ).unwrap();
 };
+
 export {
   setDialogExtraReferencesAction
 };

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-4FX6NVDW.js → chunk-L4F3I4SR.js}

@@ -1,22 +1,19 @@
 import {
   readDbRecord,
   writeAgentRecord
-} from "./chunk-PCTUYVUM.js";
+} from "./chunk-DFCFMCY6.js";
 import {
   buildSkillSummaryMarker
 } from "./chunk-VF4K2QE6.js";
 import {
-  buildSkillDocMarkdown
-} from "./chunk-VC6OZXO5.js";
+  createSpaceKey
+} from "./chunk-ELT65PZW.js";
 import {
   parseUserIdFromAuthToken,
   readOption,
   resolveAuthToken,
   resolveServerUrl
 } from "./chunk-A7GB5UGH.js";
-import {
-  createSpaceKey
-} from "./chunk-IWLUTMYX.js";
 import {
   asTrimmedLowercaseString
 } from "./chunk-QSJ3HFEF.js";
@@ -30,128 +27,6 @@ import {
   normalizeServerOrigin
 } from "./chunk-CF7PE763.js";
 
-// packages/cli/docPageHelpers.ts
-import { readFileSync } from "node:fs";
-import { ulid } from "ulid";
-function getCliArg(args, flag) {
-  const idx = args.indexOf(flag);
-  return idx !== -1 ? args[idx + 1] : void 0;
-}
-function readBodyArg(args, fallback = "") {
-  const bodyFile = getCliArg(args, "--body-file");
-  if (bodyFile !== void 0) {
-    return readFileSync(bodyFile, "utf8");
-  }
-  return getCliArg(args, "--body") ?? fallback;
-}
-function textToSlate(text) {
-  return text.split("\n").map((line) => ({
-    type: "paragraph",
-    children: [{ text: line }]
-  }));
-}
-function createPageId() {
-  return ulid();
-}
-function buildPageKey(userId, pageId) {
-  return `page-${userId}-${pageId}`;
-}
-function buildPageRecord(args) {
-  const { dbKey, pageId, title, spaceId, content, existing, meta, slateData } = args;
-  const now = Date.now();
-  const createdAt = typeof existing?.createdAt === "number" ? existing.createdAt : now;
-  const created = typeof existing?.created === "string" ? existing.created : new Date(createdAt).toISOString();
-  const nextRecord = {
-    ...existing ?? {},
-    id: existing?.id ?? pageId,
-    dbKey,
-    type: "page",
-    title,
-    spaceId,
-    content,
-    updatedAt: now,
-    createdAt,
-    created
-  };
-  if (meta !== void 0) {
-    if (meta === null) {
-      delete nextRecord.meta;
-    } else {
-      nextRecord.meta = meta;
-    }
-  }
-  if (slateData !== void 0) {
-    if (slateData === null) {
-      delete nextRecord.slateData;
-    } else {
-      nextRecord.slateData = slateData;
-    }
-  } else if (!existing?.slateData) {
-    nextRecord.slateData = textToSlate(content);
-  }
-  return nextRecord;
-}
-
-// packages/cli/docSkillHelpers.ts
-function normalizeSkillSeed(input) {
-  return input.trim().toLowerCase().replace(/[^a-z0-9\u4e00-\u9fa5]+/g, "-").replace(/^-+|-+$/g, "");
-}
-function deterministicId(prefix, seed) {
-  let h = 2166136261;
-  for (let i = 0; i < seed.length; i++) {
-    h ^= seed.charCodeAt(i);
-    h = h * 16777619 >>> 0;
-  }
-  const suffix = h.toString(36).toUpperCase().padStart(14, "0");
-  return (prefix + suffix).slice(0, 26);
-}
-function buildSkillDocId(input) {
-  return deterministicId("01SK", normalizeSkillSeed(input) || input);
-}
-function buildSkillPageKey(userId, skillId) {
-  return buildPageKey(userId, skillId);
-}
-function buildSkillPageRecord(args) {
-  const {
-    dbKey,
-    skillId,
-    title,
-    spaceId,
-    body,
-    skillConfig,
-    evalConfig,
-    workflowConfig,
-    existing
-  } = args;
-  return {
-    ...buildPageRecord({
-      dbKey,
-      pageId: skillId,
-      title,
-      spaceId,
-      content: buildSkillDocMarkdown({
-        body,
-        skillConfig,
-        evalConfig,
-        workflowConfig
-      }),
-      existing,
-      meta: {
-        ...existing?.meta ?? {},
-        kind: "skill",
-        skillConfig,
-        ...evalConfig ? { evalConfig } : {},
-        ...workflowConfig ? { workflowConfig } : {}
-      },
-      slateData: null
-    })
-  };
-}
-function parseJsonArg(raw, fallback) {
-  if (raw === void 0) return fallback;
-  return JSON.parse(raw);
-}
-
 // packages/cli/docSpaceHelpers.ts
 async function ensurePageAttachedToSpace(params) {
   const { baseUrl, userId, authToken, spaceId, contentKey, title, skillSummary } = params;
@@ -333,14 +208,6 @@ function buildSkillSummaryForRecord(record) {
 }
 
 export {
-  readBodyArg,
-  createPageId,
-  buildPageKey,
-  buildPageRecord,
-  buildSkillDocId,
-  buildSkillPageKey,
-  buildSkillPageRecord,
-  parseJsonArg,
   removePageFromSpace,
   hasHelpArg,
   hasFlag,

package/{chunk-XBS2WYJ2.js → chunk-LLWKHDG4.js}

@@ -10,7 +10,7 @@ import {
   platformHostedModels,
   xaiModels,
   zaiModels
-} from "./chunk-O6W2O2DA.js";
+} from "./chunk-MKA6QE5E.js";
 
 // packages/ai/llm/modelAbility.ts
 var MODEL_ABILITY_TABLE = {

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