linkque-cli-v2 1.0.5 → 1.0.6

package/vendor/linkque-agent-appwrite-integrate/dist/esm/chunk-OXGCUIKV.js

@@ -0,0 +1,33 @@
+import {
+  __require
+} from "./chunk-VS2QQHAK.js";
+
+// ../../node_modules/@earendil-works/pi-ai/dist/utils/provider-env.js
+var procEnvCache = null;
+function getBunSandboxEnvValue(name) {
+  if (typeof process === "undefined" || !process.versions?.bun || Object.keys(process.env).length > 0) {
+    return void 0;
+  }
+  if (procEnvCache === null) {
+    procEnvCache = /* @__PURE__ */ new Map();
+    try {
+      const { readFileSync } = __require("node:fs");
+      const data = readFileSync("/proc/self/environ", "utf-8");
+      for (const entry of data.split("\0")) {
+        const idx = entry.indexOf("=");
+        if (idx > 0) {
+          procEnvCache.set(entry.slice(0, idx), entry.slice(idx + 1));
+        }
+      }
+    } catch {
+    }
+  }
+  return procEnvCache.get(name);
+}
+function getProviderEnvValue(name, env) {
+  return env?.[name] || (typeof process !== "undefined" ? process.env[name] : void 0) || getBunSandboxEnvValue(name) || void 0;
+}
+
+export {
+  getProviderEnvValue
+};

package/vendor/linkque-agent-appwrite-integrate/dist/esm/chunk-RYONFGPP.js

@@ -0,0 +1,317 @@
+// ../../node_modules/@earendil-works/pi-ai/dist/utils/estimate.js
+var CHARS_PER_TOKEN = 4;
+var ESTIMATED_IMAGE_CHARS = 4800;
+function calculateContextTokens(usage) {
+  return usage.totalTokens || usage.input + usage.output + usage.cacheRead + usage.cacheWrite;
+}
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value) ?? "undefined";
+  } catch {
+    return "[unserializable]";
+  }
+}
+function estimateTextAndImageContentChars(content) {
+  if (typeof content === "string")
+    return content.length;
+  let chars = 0;
+  for (const block of content)
+    chars += block.type === "text" ? block.text.length : ESTIMATED_IMAGE_CHARS;
+  return chars;
+}
+function estimateTextTokens(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function estimateTextAndImageContentTokens(content) {
+  return Math.ceil(estimateTextAndImageContentChars(content) / CHARS_PER_TOKEN);
+}
+function estimateMessageTokens(message) {
+  let chars = 0;
+  if (message.role === "user")
+    return estimateTextAndImageContentTokens(message.content);
+  if (message.role === "toolResult")
+    return estimateTextAndImageContentTokens(message.content);
+  for (const block of message.content) {
+    if (block.type === "text") {
+      chars += block.text.length;
+    } else if (block.type === "thinking") {
+      chars += block.thinking.length;
+    } else {
+      chars += block.name.length + safeJsonStringify(block.arguments).length;
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function getLastAssistantUsageInfo(messages) {
+  let latestPrefixTimestamp = Number.NEGATIVE_INFINITY;
+  let usageInfo;
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i];
+    if (message.role === "assistant") {
+      const assistant = message;
+      const usageAppliesToPrefix = assistant.timestamp >= latestPrefixTimestamp;
+      if (usageAppliesToPrefix && assistant.stopReason !== "aborted" && assistant.stopReason !== "error" && calculateContextTokens(assistant.usage) > 0) {
+        usageInfo = { usage: assistant.usage, index: i };
+      }
+    }
+    latestPrefixTimestamp = Math.max(latestPrefixTimestamp, message.timestamp);
+  }
+  return usageInfo;
+}
+function estimateMessages(messages) {
+  const usageInfo = getLastAssistantUsageInfo(messages);
+  if (usageInfo) {
+    const usageTokens = calculateContextTokens(usageInfo.usage);
+    let trailingTokens = 0;
+    for (let i = usageInfo.index + 1; i < messages.length; i++) {
+      trailingTokens += estimateMessageTokens(messages[i]);
+    }
+    return { tokens: usageTokens + trailingTokens, usageTokens, trailingTokens, lastUsageIndex: usageInfo.index };
+  }
+  let tokens = 0;
+  for (const message of messages)
+    tokens += estimateMessageTokens(message);
+  return { tokens, usageTokens: 0, trailingTokens: tokens, lastUsageIndex: null };
+}
+function estimateToolsTokens(tools) {
+  if (!tools || tools.length === 0)
+    return 0;
+  return estimateTextTokens(safeJsonStringify(tools));
+}
+function isMessageArray(value) {
+  return Array.isArray(value);
+}
+function estimateContextTokens(context) {
+  if (isMessageArray(context))
+    return estimateMessages(context);
+  const estimate = estimateMessages(context.messages);
+  if (estimate.lastUsageIndex !== null) {
+    const addedNames = new Set(context.messages.slice(estimate.lastUsageIndex + 1).filter((message) => message.role === "toolResult").flatMap((message) => message.addedToolNames ?? []));
+    const addedToolTokens = estimateToolsTokens(context.tools?.filter((tool) => addedNames.has(tool.name)));
+    return {
+      tokens: estimate.tokens + addedToolTokens,
+      usageTokens: estimate.usageTokens,
+      trailingTokens: estimate.trailingTokens + addedToolTokens,
+      lastUsageIndex: estimate.lastUsageIndex
+    };
+  }
+  const prefixTokens = (context.systemPrompt ? estimateTextTokens(context.systemPrompt) : 0) + estimateToolsTokens(context.tools);
+  return {
+    tokens: estimate.tokens + prefixTokens,
+    usageTokens: estimate.usageTokens,
+    trailingTokens: estimate.trailingTokens + prefixTokens,
+    lastUsageIndex: estimate.lastUsageIndex
+  };
+}
+
+// ../../node_modules/@earendil-works/pi-ai/dist/api/simple-options.js
+var CONTEXT_SAFETY_TOKENS = 4096;
+var MIN_MAX_TOKENS = 1;
+function clampMaxTokensToContext(model, context, maxTokens) {
+  if (model.contextWindow <= 0)
+    return Math.max(MIN_MAX_TOKENS, maxTokens);
+  const available = model.contextWindow - estimateContextTokens(context).tokens - CONTEXT_SAFETY_TOKENS;
+  return Math.min(maxTokens, Math.max(MIN_MAX_TOKENS, available));
+}
+function buildBaseOptions(model, context, options, apiKey) {
+  return {
+    temperature: options?.temperature,
+    maxTokens: clampMaxTokensToContext(model, context, options?.maxTokens ?? model.maxTokens),
+    signal: options?.signal,
+    apiKey: apiKey || options?.apiKey,
+    transport: options?.transport,
+    cacheRetention: options?.cacheRetention,
+    sessionId: options?.sessionId,
+    headers: options?.headers,
+    onPayload: options?.onPayload,
+    onResponse: options?.onResponse,
+    timeoutMs: options?.timeoutMs,
+    websocketConnectTimeoutMs: options?.websocketConnectTimeoutMs,
+    maxRetries: options?.maxRetries,
+    maxRetryDelayMs: options?.maxRetryDelayMs,
+    metadata: options?.metadata,
+    env: options?.env
+  };
+}
+function clampReasoning(effort) {
+  return effort === "xhigh" || effort === "max" ? "high" : effort;
+}
+function adjustMaxTokensForThinking(baseMaxTokens, modelMaxTokens, reasoningLevel, customBudgets) {
+  const defaultBudgets = {
+    minimal: 1024,
+    low: 2048,
+    medium: 8192,
+    high: 16384
+  };
+  const budgets = { ...defaultBudgets, ...customBudgets };
+  const minOutputTokens = 1024;
+  const level = clampReasoning(reasoningLevel);
+  let thinkingBudget = budgets[level];
+  const maxTokens = baseMaxTokens === void 0 ? modelMaxTokens : Math.min(baseMaxTokens + thinkingBudget, modelMaxTokens);
+  if (maxTokens <= thinkingBudget) {
+    thinkingBudget = Math.max(0, maxTokens - minOutputTokens);
+  }
+  return { maxTokens, thinkingBudget };
+}
+
+// ../../node_modules/@earendil-works/pi-ai/dist/api/transform-messages.js
+var NON_VISION_USER_IMAGE_PLACEHOLDER = "(image omitted: model does not support images)";
+var NON_VISION_TOOL_IMAGE_PLACEHOLDER = "(tool image omitted: model does not support images)";
+function replaceImagesWithPlaceholder(content, placeholder) {
+  const result = [];
+  let previousWasPlaceholder = false;
+  for (const block of content) {
+    if (block.type === "image") {
+      if (!previousWasPlaceholder) {
+        result.push({ type: "text", text: placeholder });
+      }
+      previousWasPlaceholder = true;
+      continue;
+    }
+    result.push(block);
+    previousWasPlaceholder = block.text === placeholder;
+  }
+  return result;
+}
+function downgradeUnsupportedImages(messages, model) {
+  if (model.input.includes("image")) {
+    return messages;
+  }
+  return messages.map((msg) => {
+    if (msg.role === "user" && Array.isArray(msg.content)) {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_USER_IMAGE_PLACEHOLDER)
+      };
+    }
+    if (msg.role === "toolResult") {
+      return {
+        ...msg,
+        content: replaceImagesWithPlaceholder(msg.content, NON_VISION_TOOL_IMAGE_PLACEHOLDER)
+      };
+    }
+    return msg;
+  });
+}
+function transformMessages(messages, model, normalizeToolCallId) {
+  const toolCallIdMap = /* @__PURE__ */ new Map();
+  const normalizedMessages = messages.map((msg) => msg.content == null ? { ...msg, content: [] } : msg);
+  const imageAwareMessages = downgradeUnsupportedImages(normalizedMessages, model);
+  const transformed = imageAwareMessages.map((msg) => {
+    if (msg.role === "user") {
+      return msg;
+    }
+    if (msg.role === "toolResult") {
+      const normalizedId = toolCallIdMap.get(msg.toolCallId);
+      if (normalizedId && normalizedId !== msg.toolCallId) {
+        return { ...msg, toolCallId: normalizedId };
+      }
+      return msg;
+    }
+    if (msg.role === "assistant") {
+      const assistantMsg = msg;
+      const isSameModel = assistantMsg.provider === model.provider && assistantMsg.api === model.api && assistantMsg.model === model.id;
+      const transformedContent = assistantMsg.content.flatMap((block) => {
+        if (block.type === "thinking") {
+          if (block.redacted) {
+            return isSameModel ? block : [];
+          }
+          if (isSameModel && block.thinkingSignature)
+            return block;
+          if (!block.thinking || block.thinking.trim() === "")
+            return [];
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.thinking
+          };
+        }
+        if (block.type === "text") {
+          if (isSameModel)
+            return block;
+          return {
+            type: "text",
+            text: block.text
+          };
+        }
+        if (block.type === "toolCall") {
+          const toolCall = block;
+          let normalizedToolCall = toolCall;
+          if (!isSameModel && toolCall.thoughtSignature) {
+            normalizedToolCall = { ...toolCall };
+            delete normalizedToolCall.thoughtSignature;
+          }
+          if (!isSameModel && normalizeToolCallId) {
+            const normalizedId = normalizeToolCallId(toolCall.id, model, assistantMsg);
+            if (normalizedId !== toolCall.id) {
+              toolCallIdMap.set(toolCall.id, normalizedId);
+              normalizedToolCall = { ...normalizedToolCall, id: normalizedId };
+            }
+          }
+          return normalizedToolCall;
+        }
+        return block;
+      });
+      return {
+        ...assistantMsg,
+        content: transformedContent
+      };
+    }
+    return msg;
+  });
+  const result = [];
+  let pendingToolCalls = [];
+  let existingToolResultIds = /* @__PURE__ */ new Set();
+  const insertSyntheticToolResults = () => {
+    if (pendingToolCalls.length > 0) {
+      for (const tc of pendingToolCalls) {
+        if (!existingToolResultIds.has(tc.id)) {
+          result.push({
+            role: "toolResult",
+            toolCallId: tc.id,
+            toolName: tc.name,
+            content: [{ type: "text", text: "No result provided" }],
+            isError: true,
+            timestamp: Date.now()
+          });
+        }
+      }
+      pendingToolCalls = [];
+      existingToolResultIds = /* @__PURE__ */ new Set();
+    }
+  };
+  for (let i = 0; i < transformed.length; i++) {
+    const msg = transformed[i];
+    if (msg.role === "assistant") {
+      insertSyntheticToolResults();
+      const assistantMsg = msg;
+      if (assistantMsg.stopReason === "error" || assistantMsg.stopReason === "aborted") {
+        continue;
+      }
+      const toolCalls = assistantMsg.content.filter((b) => b.type === "toolCall");
+      if (toolCalls.length > 0) {
+        pendingToolCalls = toolCalls;
+        existingToolResultIds = /* @__PURE__ */ new Set();
+      }
+      result.push(msg);
+    } else if (msg.role === "toolResult") {
+      existingToolResultIds.add(msg.toolCallId);
+      result.push(msg);
+    } else if (msg.role === "user") {
+      insertSyntheticToolResults();
+      result.push(msg);
+    } else {
+      result.push(msg);
+    }
+  }
+  insertSyntheticToolResults();
+  return result;
+}
+
+export {
+  clampMaxTokensToContext,
+  buildBaseOptions,
+  adjustMaxTokensForThinking,
+  transformMessages
+};