nolo-cli 0.8.0 → 0.9.0

package/chunk-JRKKFRAV.js

@@ -0,0 +1,537 @@
+import {
+  getModelConfig
+} from "./chunk-BBYVOSU2.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/agent-runtime/agentConfigOptions.ts
+function pickAgentRuntimeInferenceOptions(agentConfig) {
+  return {
+    ...agentConfig.temperature !== void 0 ? { temperature: agentConfig.temperature } : {},
+    ...agentConfig.top_p !== void 0 ? { top_p: agentConfig.top_p } : {},
+    ...agentConfig.frequency_penalty !== void 0 ? { frequency_penalty: agentConfig.frequency_penalty } : {},
+    ...agentConfig.presence_penalty !== void 0 ? { presence_penalty: agentConfig.presence_penalty } : {},
+    ...agentConfig.max_tokens !== void 0 ? { max_tokens: agentConfig.max_tokens } : {},
+    ...agentConfig.reasoning_effort ? { reasoning_effort: agentConfig.reasoning_effort } : {}
+  };
+}
+
+// packages/agent-runtime/platformProviderEndpoints.ts
+var OPENAI_RESPONSES_ENDPOINT = "https://api.openai.com/v1/responses";
+var PLATFORM_CHAT_COMPLETIONS_ENDPOINTS = {
+  deepinfra: "https://api.deepinfra.com/v1/openai/chat/completions",
+  deepseek: "https://api.deepseek.com/chat/completions",
+  fireworks: "https://api.fireworks.ai/inference/v1/chat/completions",
+  google: "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions",
+  openai: "https://api.openai.com/v1/chat/completions",
+  openrouter: "https://openrouter.ai/api/v1/chat/completions",
+  // 千问 AI 平台 OpenAI 兼容模式
+  qwen: "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
+  // Moonshot AI（月之暗面）开放平台 OpenAI 兼容模式（按量计费）
+  moonshot: "https://api.moonshot.cn/v1/chat/completions",
+  // Open-source default: nolo provider 中转 ollama cloud。
+  // 内部多后端组合路由不开源，由内部 provider 路由层接管。
+  nolo: "https://ollama.com/v1/chat/completions"
+};
+function isOpenAiResponsesModel(args) {
+  if (asTrimmedLowercaseString(args.provider) !== "openai") return false;
+  if (args.endpointKey === "responses") return true;
+  if (!args.model) return false;
+  try {
+    return getModelConfig("openai", args.model).endpointKey === "responses";
+  } catch {
+    return false;
+  }
+}
+function resolvePlatformChatCompletionsEndpoint(provider) {
+  const key = asTrimmedLowercaseString(provider);
+  if (!key) return void 0;
+  return PLATFORM_CHAT_COMPLETIONS_ENDPOINTS[key];
+}
+
+// packages/agent-runtime/providerResolution.ts
+function resolvePlatformProviderEndpoint(agentConfig) {
+  const customProviderUrl = agentConfig.customProviderUrl?.trim();
+  if (customProviderUrl) return resolveChatCompletionsEndpoint(customProviderUrl);
+  const provider = asTrimmedLowercaseString(
+    agentConfig.provider ?? agentConfig.apiSource ?? "openai"
+  );
+  if (!provider) {
+    throw new Error("Platform chat provider requires agentConfig.provider.");
+  }
+  if (isOpenAiResponsesModel({
+    provider,
+    model: agentConfig.model,
+    endpointKey: agentConfig.endpointKey
+  })) {
+    return OPENAI_RESPONSES_ENDPOINT;
+  }
+  const endpoint = resolvePlatformChatCompletionsEndpoint(provider);
+  if (!endpoint) {
+    throw new Error(`Platform chat provider does not support provider "${provider}".`);
+  }
+  return endpoint;
+}
+async function resolveCredentialFromBroker(broker, ref) {
+  const trimmed = asTrimmedString(ref);
+  if (!trimmed) return null;
+  try {
+    if (!await broker.has(trimmed)) return null;
+    const secret = await broker.get(trimmed);
+    return asOptionalTrimmedString(secret) ?? null;
+  } catch {
+    return null;
+  }
+}
+function trimTrailingSlash(value) {
+  return normalizeServerOrigin(value);
+}
+function resolveChatCompletionsEndpoint(value) {
+  const trimmed = trimTrailingSlash(value);
+  return trimmed.endsWith("/chat/completions") ? trimmed : `${trimmed}/chat/completions`;
+}
+function resolveOpenAiCompatibleBaseUrl(env) {
+  return env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || "https://api.openai.com/v1";
+}
+function resolveOpenAiCompatibleApiKey(env) {
+  return env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_API_KEY || "";
+}
+function resolvePlatformServerUrl(env) {
+  return trimTrailingSlash(env.NOLO_SERVER || env.BASE_URL || "https://nolo.chat");
+}
+function resolvePlatformAuthToken(env) {
+  return env.AUTH_TOKEN || env.AUTH || env.BENCHMARK_AUTH_TOKEN || "";
+}
+function canUsePlatformChatProvider(env) {
+  return Boolean(resolvePlatformAuthToken(env));
+}
+function hasDirectOpenAiCompatibleProvider(env) {
+  return Boolean(
+    env.NOLO_LOCAL_OPENAI_API_KEY || env.OPENAI_API_KEY || env.NOLO_LOCAL_OPENAI_BASE_URL || env.OPENAI_BASE_URL || env.OLLAMA_BASE_URL
+  );
+}
+function resolveAgentProviderMode(agentConfig) {
+  if (agentConfig.apiSource === "cli" || agentConfig.provider === "cli" || agentConfig.cliProvider) {
+    return "cli";
+  }
+  if (agentConfig.apiSource === "custom" || agentConfig.customProviderUrl) {
+    return "custom";
+  }
+  return "platform";
+}
+function resolveAgentRuntimeLocation(args) {
+  const runtimeBinding = args.agentConfig.runtimeBinding;
+  const machineId = asTrimmedString(runtimeBinding?.machineId);
+  if (machineId) return "bound-machine";
+  if (args.runtimeKind === "server") return "server";
+  return "local-host";
+}
+function resolveProviderTransportDecision(args) {
+  const mode = resolveAgentProviderMode(args.agentConfig);
+  if (mode === "cli") {
+    return { mode, transport: "direct", reason: "cli-provider" };
+  }
+  if (mode === "custom") {
+    if (args.runtimeLocation === "server" && args.agentConfig.useServerProxy === true) {
+      return { mode, transport: "proxy", reason: "custom-server-proxy" };
+    }
+    return { mode, transport: "direct", reason: "custom-provider" };
+  }
+  if (args.agentConfig.apiSource === "platform" || args.agentConfig.useServerProxy === true) {
+    return { mode, transport: "proxy", reason: "platform-agent" };
+  }
+  if (args.env.NOLO_LOCAL_LLM === "platform") {
+    return { mode, transport: "proxy", reason: "forced-platform-env" };
+  }
+  if (args.env.NOLO_LOCAL_LLM === "direct") {
+    return { mode, transport: "direct", reason: "forced-direct-env" };
+  }
+  if (hasDirectOpenAiCompatibleProvider(args.env)) {
+    return { mode, transport: "direct", reason: "direct-provider-env" };
+  }
+  if (canUsePlatformChatProvider(args.env)) {
+    return { mode, transport: "proxy", reason: "platform-proxy-fallback" };
+  }
+  return { mode, transport: "direct", reason: "direct-provider-env" };
+}
+function resolveProviderAuthHeaderName(args) {
+  const explicitHeader = args.apiKeyHeader?.trim();
+  if (explicitHeader) return explicitHeader;
+  if (/xiaomimimo\.com/i.test(args.endpoint)) return "api-key";
+  return "Authorization";
+}
+function buildProviderAuthHeaders(args) {
+  if (!args.apiKey) return {};
+  const headerName = resolveProviderAuthHeaderName(args);
+  return headerName.toLowerCase() === "authorization" ? { Authorization: `Bearer ${args.apiKey}` } : { [headerName]: args.apiKey };
+}
+async function buildProviderExecutionPlan(args) {
+  const { agentConfig, env } = args;
+  const mode = resolveAgentProviderMode(agentConfig);
+  const runtimeLocation = resolveAgentRuntimeLocation({
+    agentConfig,
+    runtimeKind: args.runtimeKind
+  });
+  const transportDecision = resolveProviderTransportDecision({
+    agentConfig,
+    env,
+    runtimeLocation
+  });
+  const model = agentConfig.model || "gpt-4.1-mini";
+  const requestOptions = pickAgentRuntimeInferenceOptions(agentConfig);
+  if (mode === "cli") {
+    return {
+      mode,
+      transport: "direct",
+      cliProvider: agentConfig.cliProvider || agentConfig.provider || "codex",
+      model,
+      provider: agentConfig.provider || "cli",
+      requestOptions
+    };
+  }
+  if (mode === "custom") {
+    const endpoint2 = resolveChatCompletionsEndpoint(agentConfig.customProviderUrl || resolveOpenAiCompatibleBaseUrl(env));
+    let apiKey2 = "";
+    const credentialRef2 = agentConfig.credentialRef?.trim();
+    const apiKeyRef = agentConfig.apiKeyRef?.trim();
+    if (args.credentialBroker) {
+      const brokerRefs = [credentialRef2, apiKeyRef].filter(
+        (ref) => Boolean(ref)
+      );
+      for (const ref of brokerRefs) {
+        const fromBroker = await resolveCredentialFromBroker(args.credentialBroker, ref);
+        if (fromBroker) {
+          apiKey2 = fromBroker;
+          break;
+        }
+      }
+    }
+    if (!apiKey2 && agentConfig.credentialSynced && args.syncFetcher && credentialRef2) {
+      const synced = await args.syncFetcher(credentialRef2);
+      const trimmed = asTrimmedString(synced);
+      if (trimmed) {
+        try {
+          await args.credentialBroker?.put(credentialRef2, trimmed);
+        } catch {
+        }
+        apiKey2 = trimmed;
+      }
+    }
+    if (!apiKey2 && apiKeyRef && args.apiKeyRefResolver) {
+      const resolved = await args.apiKeyRefResolver(apiKeyRef);
+      if (resolved) {
+        apiKey2 = resolved;
+      } else if (!agentConfig.apiKey?.trim() && !agentConfig.apiKeyFromAgentKey?.trim()) {
+        const isApiKeyRef = apiKeyRef.startsWith("api-key:");
+        const hint = isApiKeyRef ? agentConfig.credentialSynced ? `Local credential for "${apiKeyRef}" not found. It is synced to your account \u2014 run this agent once on a device that has the key, or re-enter it in agent settings.` : `Local credential for "${apiKeyRef}" not found. Re-enter the API key in agent settings, or enable cross-device sync.` : `OAuth credential for "${apiKeyRef}" not found locally. Run \`nolo auth ${apiKeyRef}\` (and \`--sync-to-server\` for server-side agent runs).`;
+        throw new Error(hint);
+      }
+    }
+    if (!apiKey2) {
+      apiKey2 = asOptionalTrimmedString(agentConfig.apiKey) ?? asOptionalTrimmedString(agentConfig.apiKeyFromAgentKey) ?? "";
+    }
+    const apiKeyHeader = resolveProviderAuthHeaderName({
+      endpoint: endpoint2,
+      apiKeyHeader: agentConfig.apiKeyHeader
+    });
+    if (transportDecision.transport === "proxy") {
+      return {
+        mode,
+        transport: "proxy",
+        model,
+        provider: agentConfig.provider || "custom",
+        endpoint: endpoint2,
+        requestOptions,
+        serverUrl: resolvePlatformServerUrl(env),
+        authToken: resolvePlatformAuthToken(env),
+        agentKey: agentConfig.key,
+        ...agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {},
+        ...apiKey2 ? { apiKey: apiKey2 } : {},
+        ...apiKeyHeader ? { apiKeyHeader } : {}
+      };
+    }
+    return {
+      mode,
+      transport: "direct",
+      model,
+      provider: agentConfig.provider || "custom",
+      endpoint: endpoint2,
+      requestOptions,
+      apiKey: apiKey2,
+      ...apiKeyHeader ? { apiKeyHeader } : {}
+    };
+  }
+  const provider = agentConfig.provider || agentConfig.apiSource || "openai";
+  const endpoint = transportDecision.transport === "proxy" ? resolvePlatformProviderEndpoint(agentConfig) : resolveChatCompletionsEndpoint(resolveOpenAiCompatibleBaseUrl(env));
+  if (transportDecision.transport === "proxy") {
+    return {
+      mode,
+      transport: "proxy",
+      model,
+      provider,
+      endpoint,
+      requestOptions,
+      serverUrl: resolvePlatformServerUrl(env),
+      authToken: resolvePlatformAuthToken(env),
+      agentKey: agentConfig.key,
+      ...agentConfig.apiSource ? { apiSource: agentConfig.apiSource } : {},
+      ...agentConfig.apiKey?.trim() ? { apiKey: agentConfig.apiKey.trim() } : {},
+      ...agentConfig.apiKeyHeader?.trim() ? { apiKeyHeader: agentConfig.apiKeyHeader.trim() } : {}
+    };
+  }
+  let apiKey = "";
+  const credentialRef = agentConfig.credentialRef?.trim();
+  if (args.credentialBroker && credentialRef) {
+    const fromBroker = await resolveCredentialFromBroker(args.credentialBroker, credentialRef);
+    if (fromBroker) {
+      apiKey = fromBroker;
+    }
+  }
+  if (!apiKey && agentConfig.credentialSynced && args.syncFetcher && credentialRef) {
+    const synced = await args.syncFetcher(credentialRef);
+    const trimmed = asTrimmedString(synced);
+    if (trimmed) {
+      try {
+        await args.credentialBroker?.put(credentialRef, trimmed);
+      } catch {
+      }
+      apiKey = trimmed;
+    }
+  }
+  if (!apiKey) {
+    apiKey = resolveOpenAiCompatibleApiKey(env);
+  }
+  return {
+    mode,
+    transport: "direct",
+    model,
+    provider: agentConfig.provider || "openai-compatible",
+    endpoint,
+    requestOptions,
+    apiKey
+  };
+}
+
+// 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) => {
+  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;
+    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;
+};
+
+export {
+  pickAgentRuntimeInferenceOptions,
+  OPENAI_RESPONSES_ENDPOINT,
+  isOpenAiResponsesModel,
+  resolvePlatformChatCompletionsEndpoint,
+  trimTrailingSlash,
+  resolvePlatformServerUrl,
+  resolvePlatformAuthToken,
+  canUsePlatformChatProvider,
+  hasDirectOpenAiCompatibleProvider,
+  resolveAgentRuntimeLocation,
+  resolveProviderTransportDecision,
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan,
+  toResponsesTools,
+  convertMessagesToResponsesInput,
+  extractTextFromResponseOutput,
+  extractImagePartsFromResponseOutput,
+  extractToolCallsFromResponseOutput
+};

package/chunk-JZPBVBIY.js

@@ -0,0 +1,94 @@
+// packages/agent-runtime/oauthTokenStore.ts
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+var DEFAULT_REFRESH_SKEW_MS = 5 * 60 * 1e3;
+function getCredentialsDir(homeDir = homedir()) {
+  return join(homeDir, ".nolo", "credentials");
+}
+function getCredentialPath(provider, homeDir = homedir()) {
+  return join(getCredentialsDir(homeDir), `${provider}.json`);
+}
+function ensurePrivateDir(dir) {
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  try {
+    chmodSync(dir, 448);
+  } catch {
+  }
+}
+function writePrivateFile(path, body) {
+  writeFileSync(path, body, { encoding: "utf8", mode: 384 });
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function readOAuthCredential(provider, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf8");
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed?.provider || !parsed?.accessToken) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeOAuthCredential(provider, credential, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  ensurePrivateDir(getCredentialsDir(homeDir));
+  writePrivateFile(path, `${JSON.stringify(credential, null, 2)}
+`);
+}
+function removeOAuthCredential(provider, homeDir = homedir()) {
+  const path = getCredentialPath(provider, homeDir);
+  if (!existsSync(path)) return;
+  unlinkSync(path);
+}
+function createOAuthTokenStore(homeDir = homedir()) {
+  return {
+    read(provider) {
+      return readOAuthCredential(provider, homeDir);
+    },
+    write(provider, credential) {
+      writeOAuthCredential(provider, credential, homeDir);
+    },
+    remove(provider) {
+      removeOAuthCredential(provider, homeDir);
+    }
+  };
+}
+function isTokenExpired(credential, skewMs = DEFAULT_REFRESH_SKEW_MS, now = Date.now()) {
+  if (!credential.expiresAt) return false;
+  return credential.expiresAt - now <= skewMs;
+}
+async function resolveFreshAccessToken(args) {
+  const store = args.store ?? createOAuthTokenStore(args.homeDir);
+  const now = args.now ?? Date.now;
+  const credential = store.read(args.provider);
+  if (!credential) return null;
+  if (!args.force && !isTokenExpired(credential, args.skewMs ?? DEFAULT_REFRESH_SKEW_MS, now())) {
+    return credential.accessToken;
+  }
+  if (!credential.refreshToken || !args.refresh) return null;
+  const refreshed = await args.refresh(credential);
+  store.write(args.provider, refreshed);
+  return refreshed.accessToken;
+}
+
+export {
+  getCredentialsDir,
+  readOAuthCredential,
+  writeOAuthCredential,
+  createOAuthTokenStore,
+  isTokenExpired,
+  resolveFreshAccessToken
+};

package/chunk-KKY4B2Q2.js

@@ -0,0 +1,21 @@
+// packages/agent-runtime/staleReplayGuard.ts
+var wrapHistoricalSummaryWithReplayGuard = (summary) => {
+  const trimmed = summary.trim();
+  if (!trimmed) return "";
+  return [
+    "\u3010\u5386\u53F2\u53C2\u8003\uFF0C\u975E\u6D3B\u6307\u4EE4\u3011\u4EE5\u4E0B\u4E3A\u51BB\u7ED3\u6458\u8981\uFF0C\u5176\u4E2D\u7684\u4EFB\u52A1/skill/ARGUMENTS \u9ED8\u8BA4\u5DF2\u8FC7\u671F\uFF0C\u4E0D\u5F97\u91CD\u65B0\u6267\u884C\u3002",
+    trimmed
+  ].join("\n");
+};
+
+// packages/agent-runtime/memoryUseGuidance.ts
+var MEMORY_USE_GUIDANCE = `--- \u8BB0\u5FC6\u4F7F\u7528\u65B9\u5F0F ---
+- \u8BB0\u5FC6\u662F\u4E2A\u6027\u5316\u589E\u5F3A\u5C42\uFF1B\u5F53\u524D\u8F93\u5165/\u5BF9\u8BDD/\u7CFB\u7EDF\u89C4\u5219/Agent prompt/skill/\u7528\u6237\u5168\u5C40\u504F\u597D\u90FD\u4F18\u5148\u4E8E\u5B83\u3002\u5F53\u524D\u8F93\u5165\u7ED9\u51FA\u65B0\u8BED\u8A00\u3001\u6280\u672F\u6808\u3001\u6570\u503C\u3001\u7EA6\u675F\u6216\u660E\u786E\u8986\u76D6\u65E7\u504F\u597D\u65F6\uFF0C\u91C7\u7528\u5F53\u524D\u8F93\u5165\uFF0C\u4E0D\u8981\u628A\u65E7\u8BB0\u5FC6\u5F53\u66F4\u9AD8\u771F\u503C\u3002
+- \u8BB0\u5FC6\u542B\u7528\u6237\u8EAB\u4EFD/\u79F0\u547C/\u5173\u7CFB/\u957F\u671F\u504F\u597D/\u9879\u76EE\u80CC\u666F\u65F6\uFF0C\u76F8\u5173\u5904\u81EA\u7136\u4F53\u73B0\uFF08\u5F00\u573A\u79F0\u547C\u3001\u4E0A\u4E0B\u6587\u786E\u8BA4\u3001\u56DE\u7B54\u7ED3\u6784\u3001\u53D6\u820D\u6807\u51C6\uFF09\uFF0C\u4E0D\u8981\u6BCF\u53E5\u673A\u68B0\u79F0\u547C\u7528\u6237\u3002
+- \u201C\u4E0A\u6B21/\u7EE7\u7EED/\u8FD9\u4E2A\u9879\u76EE\u201D\u7B49\u6307\u4EE3\u4F18\u5148\u6309\u5F53\u524D dialog/space/project/agent/sourceDialog \u7B49 KV \u8DEF\u5F84\u548C\u65F6\u95F4\u7EBF\u5B9A\u4F4D\uFF0C\u4E0D\u8981\u53EA\u6309\u8BED\u4E49\u76F8\u4F3C\u5EA6\u635E\u4E00\u6761\u3002
+- \u63A8\u65AD\u578B\u8BB0\u5FC6\u53EA\u7528\u4E8E\u628A\u63E1\u8BED\u6C14\u3001\u72B6\u6001\u548C\u672A\u5B8C\u6210\u4E8B\u9879\uFF0C\u4E0D\u8981\u8BF4\u6210\u201C\u4F60\u660E\u786E\u544A\u8BC9\u8FC7\u6211\u201D\u6216\u5F53\u6210\u7528\u6237\u5DF2\u6388\u6743\u4FDD\u5B58\u7684\u4E8B\u5B9E\u3002\u51B2\u7A81\u6216\u573A\u666F\u4E0D\u660E\u65F6\u8BF4\u660E\u4F9D\u636E\u6216\u7B80\u77ED\u786E\u8BA4\uFF0C\u4E0D\u8981\u786C\u5957\u3002`;
+
+export {
+  wrapHistoricalSummaryWithReplayGuard,
+  MEMORY_USE_GUIDANCE
+};