nolo-cli 0.1.41 → 0.1.42

package/ai/agent/streamAgentChatTurn.ts

@@ -73,9 +73,6 @@ import { getIsDesktopApp } from "../../app/utils/env";
 import { runDesktopAgentRuntimeTurn } from "../../app/utils/desktopAgentRuntimeTurnClient";
 import { resolveRuntimeToolSurfaceForAgent } from "../../agent-runtime/runtimeToolSurface";
 
-const BUILTIN_NOLO_AGENT_ID = "01NOLOAPPBLD000000019KCKT0";
-const BUILTIN_NOLO_AGENT_KEY = `agent-pub-${BUILTIN_NOLO_AGENT_ID}`;
-
 const buildParallelMessageMetadata = (
     agentConfig: Pick<Agent, "dbKey" | "name">,
     runtimeOptions?: AgentRuntimeOptions,
@@ -116,23 +113,141 @@ const filterMessagesForParallelBranch = (
     });
 };
 
-const isDesktopBuiltinNoloAgent = (
-    requestedAgentKey: string,
+const buildDesktopRuntimeToolMessagesForUi = ({
+    dialogId,
+    turnMessages,
+}: {
+    dialogId: string;
+    turnMessages?: any[];
+}) => {
+    if (!Array.isArray(turnMessages) || turnMessages.length === 0) return [];
+
+    const toolNamesByCallId = new Map<string, string>();
+    const activityByCallId = new Map<string, any>();
+    const projected: any[] = [];
+
+    for (const message of turnMessages) {
+        if (Array.isArray(message?.tool_calls)) {
+            for (const call of message.tool_calls) {
+                const callId = typeof call?.id === "string" ? call.id.trim() : "";
+                const toolName =
+                    typeof call?.function?.name === "string"
+                        ? call.function.name.trim()
+                        : "";
+                if (callId && toolName) toolNamesByCallId.set(callId, toolName);
+
+                // Extract _activity from tool call arguments for UI projection
+                if (callId) {
+                    try {
+                        const args =
+                            typeof call?.function?.arguments === "string"
+                                ? JSON.parse(call.function.arguments)
+                                : call?.function?.arguments;
+                        const rawActivity =
+                            args &&
+                            typeof args === "object" &&
+                            !Array.isArray(args)
+                                ? args._activity
+                                : undefined;
+                        const activity =
+                            rawActivity &&
+                            typeof rawActivity === "object" &&
+                            !Array.isArray(rawActivity)
+                                ? rawActivity as Record<string, unknown>
+                                : undefined;
+                        const legacyTitle =
+                            typeof activity?.title === "string" && activity.title.trim();
+                        const action = activity?.action;
+                        const actionTitle =
+                            action &&
+                            typeof action === "object" &&
+                            !Array.isArray(action) &&
+                            typeof (action as Record<string, unknown>).title === "string" &&
+                            ((action as Record<string, unknown>).title as string).trim();
+                        const plan = activity?.plan;
+                        const hasPlan =
+                            plan &&
+                            typeof plan === "object" &&
+                            !Array.isArray(plan) &&
+                            Array.isArray((plan as Record<string, unknown>).phases) &&
+                            ((plan as Record<string, unknown>).phases as unknown[]).some((phase) => {
+                                if (!phase || typeof phase !== "object" || Array.isArray(phase)) return false;
+                                const rawPhase = phase as Record<string, unknown>;
+                                return typeof rawPhase.title === "string" && !!rawPhase.title.trim();
+                            });
+                        if (activity && (legacyTitle || actionTitle || hasPlan)) {
+                            activityByCallId.set(callId, args._activity);
+                        }
+                    } catch {
+                        // Ignore malformed tool call arguments
+                    }
+                }
+            }
+            continue;
+        }
+
+        if (message?.role !== "tool") continue;
+        const toolCallId =
+            typeof message.tool_call_id === "string"
+                ? message.tool_call_id.trim()
+                : "";
+        const metadata =
+            message.tool_result_metadata &&
+            typeof message.tool_result_metadata === "object"
+                ? message.tool_result_metadata
+                : {};
+        const metadataToolName =
+            typeof metadata.toolName === "string" ? metadata.toolName.trim() : "";
+        const toolName =
+            metadataToolName ||
+            (toolCallId ? toolNamesByCallId.get(toolCallId) : "") ||
+            "tool";
+        const { key: dbKey, messageId } = createDialogMessageKeyAndId(dialogId);
+
+        // Resolve activity: prefer tool result metadata.activity, fall back to tool call _activity
+        const resultActivity =
+            metadata.activity && typeof metadata.activity === "object"
+                ? metadata.activity
+                : undefined;
+        const callActivity = toolCallId
+            ? activityByCallId.get(toolCallId)
+            : undefined;
+        const activity = resultActivity || callActivity;
+
+        // Merge activity into metadata so UI readers (ToolMessageGroup / extractActivityLines)
+        // that look at message.metadata.activity see it regardless of surface.
+        const mergedMetadata = activity
+            ? { ...metadata, activity }
+            : metadata;
+
+        projected.push({
+            id: messageId,
+            dialogId,
+            dbKey,
+            role: "tool",
+            content: message.content ?? "",
+            isStreaming: false,
+            toolName,
+            ...(toolCallId ? { toolCallId } : {}),
+            ...(Object.keys(mergedMetadata).length ? { metadata: mergedMetadata } : {}),
+        });
+    }
+
+    return projected;
+};
+
+const extractDesktopRuntimeToolCallsForUi = (turnMessages?: any[]) => {
+    if (!Array.isArray(turnMessages) || turnMessages.length === 0) return [];
+    return turnMessages.flatMap((message) =>
+        Array.isArray(message?.tool_calls) ? message.tool_calls : []
+    );
+};
+
+const shouldUseDesktopLocalRuntime = (
     agentConfig: Partial<Agent> | null | undefined,
 ) => {
     if (!getIsDesktopApp()) return false;
-    const candidates = [
-        requestedAgentKey,
-        agentConfig?.dbKey,
-        agentConfig?.agentKey,
-        agentConfig?.id,
-    ];
-    return candidates.some((value) =>
-        typeof value === "string" &&
-        (value === BUILTIN_NOLO_AGENT_KEY ||
-            value === BUILTIN_NOLO_AGENT_ID ||
-            value.endsWith(`-${BUILTIN_NOLO_AGENT_ID}`))
-    );
+    return agentConfig?.apiSource !== "cli";
 };
 
 const resolveWebAgentRuntimeToolSurface = (
@@ -261,6 +376,7 @@ const EMPTY_DYNAMIC_CONTEXTS = {
     historyContext: "",
     editingContext: null,
     appWorkingMemory: null,
+    memoryOverlay: null,
     dialogSummary: null,
     proactiveSummary: null,
     referenceKeys: [],
@@ -454,9 +570,11 @@ const canUseQuickChatEmptyDynamicContexts = (
     userInput: string | any[],
     runtimeOptions: AgentRuntimeOptions | undefined,
     dialogConfig: DialogConfig | null,
+    agentConfig?: Agent | null,
 ) => {
     if (!quickChatPerfStartedAt) return false;
     if (runtimeOptions) return false;
+    if (agentConfig?.tools?.includes("rememberMemory")) return false;
     if (!isSimpleTextInput(userInput)) return false;
     if (dialogConfig?.referenceKeys?.length) return false;
     return true;
@@ -478,6 +596,7 @@ const shouldDisableQuickChatToolsForDirectAnswer = (
         userInput,
         runtimeOptions,
         dialogConfig,
+        undefined,
     )) {
         return false;
     }
@@ -609,7 +728,8 @@ export const streamAgentChatTurnHandler = async (
         // runtimeBinding selects the bound machine. Without it, custom provider
         // requests stay on the normal OpenAI-compatible path, where
         // useServerProxy decides server proxy vs current-client direct fetch.
-        if (agentConfig.apiSource === "cli" || boundMachineId) {
+        if (agentConfig.apiSource === "cli" || (boundMachineId && !getIsDesktopApp())) {
+            console.info("[streamAgentChatTurn] Triggered CLI/machine route. apiSource:", agentConfig.apiSource, "boundMachineId:", boundMachineId, "agentKey:", agentKey);
             const currentState = getState() as RootState;
             const w =
                 typeof globalThis !== "undefined" && (globalThis as any).window
@@ -859,6 +979,7 @@ export const streamAgentChatTurnHandler = async (
             };
 
             const initialSessionId = await ensureCliSession();
+            console.info("[streamAgentChatTurn] Calling CLI turn stream. Session ID:", initialSessionId);
             let resp = await createCliChatTurnStream(
                 {
                     getState,
@@ -872,8 +993,10 @@ export const streamAgentChatTurnHandler = async (
             );
 
             if (!resp.ok && resp.status === 404) {
+                console.warn("[streamAgentChatTurn] CLI Session 404. Re-creating session...");
                 cliSessionId = null;
                 const renewedSessionId = await ensureCliSession();
+                console.info("[streamAgentChatTurn] Retrying CLI turn stream. Session ID:", renewedSessionId);
                 resp = await createCliChatTurnStream(
                     {
                         getState,
@@ -889,6 +1012,7 @@ export const streamAgentChatTurnHandler = async (
 
             if (!resp.ok) {
                 const err = await resp.json().catch(() => ({ error: resp.statusText }));
+                console.error("[streamAgentChatTurn] Local CLI fetch failed. Status:", resp.status, "Error details:", err);
                 return rejectWithValue(err.error || "CLI 执行失败");
             }
 
@@ -1015,7 +1139,7 @@ export const streamAgentChatTurnHandler = async (
             dialogId,
         });
 
-        if (isDesktopBuiltinNoloAgent(agentKey, agentConfig)) {
+        if (shouldUseDesktopLocalRuntime(agentConfig)) {
             const { key: msgKey, messageId } = createDialogMessageKeyAndId(dialogId);
             const desktopMessageMetadata = buildParallelMessageMetadata(
                 agentConfig,
@@ -1044,6 +1168,14 @@ export const streamAgentChatTurnHandler = async (
                 return rejectWithValue(localResult.error);
             }
 
+            const desktopTurnMessages = (localResult.result as any).turnMessages;
+            for (const toolMessage of buildDesktopRuntimeToolMessagesForUi({
+                dialogId,
+                turnMessages: desktopTurnMessages,
+            })) {
+                dispatch(messageStreaming(toolMessage));
+            }
+
             dispatch(messageStreaming({
                 id: messageId,
                 dialogId,
@@ -1066,7 +1198,7 @@ export const streamAgentChatTurnHandler = async (
                 dialogId,
                 dialogKey,
                 reasoningBuffer: "",
-                toolCalls: [],
+                toolCalls: extractDesktopRuntimeToolCallsForUi(desktopTurnMessages),
                 messageMetadata: desktopMessageMetadata,
             })).unwrap();
             remoteTransientMessageFinalized = true;
@@ -1475,6 +1607,7 @@ export const streamAgentChatTurnHandler = async (
                     userInput,
                     runtimeOptions,
                     currentDialog,
+                    agentConfigForCall,
                 );
                 logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dynamic-context-decision", {
                     hasRuntimeOptions: !!runtimeOptions,
@@ -1747,6 +1880,7 @@ export const streamAgentChatTurnHandler = async (
                 userInput,
                 runtimeOptions,
                 currentDialog,
+                agentConfigForCall,
             );
             logQuickChatPerfStage(quickChatPerfStartedAt, "stream-agent-dynamic-context-decision", {
                 hasRuntimeOptions: !!runtimeOptions,

package/ai/agent/streamAgentChatTurnUtils.ts

@@ -58,6 +58,7 @@ import { buildRecentAppToolMemory } from "./appWorkingMemory";
 import type { AgentRuntimeOptions } from "./types";
 import { getModelConfig, getProviderByModelName, type Provider } from "../llm/providers";
 import type { ImageGenerationState } from "../../chat/messages/types";
+import { resolveToolBaseUrl } from "../tools/toolApiClient";
 
 const BROWSER_UNAVAILABLE_CORE_TOOLS = new Set([
     "queryModelUsage",
@@ -418,11 +419,65 @@ export interface DynamicContexts {
     historyContext: string;
     editingContext: string | null;
     appWorkingMemory: string | null;
+    memoryOverlay: string | null;
     dialogSummary: string | null;
     proactiveSummary: string | null;
     referenceKeys: string[];
 }
 
+export const fetchMemoryOverlayContext = async (
+    state: RootState,
+    agentConfig: Agent,
+    userInput: string | any[],
+    dialogConfig?: DialogConfig,
+): Promise<string | null> => {
+    const token = typeof (state as any)?.auth?.currentToken === "string"
+        ? (state as any).auth.currentToken
+        : null;
+    const currentServer = typeof (state as any)?.settings?.currentServer === "string"
+        ? (state as any).settings.currentServer
+        : null;
+    const agentKey = typeof agentConfig.dbKey === "string" && agentConfig.dbKey.trim()
+        ? agentConfig.dbKey.trim()
+        : "";
+    if (!token || !currentServer || !agentKey) return null;
+
+    const baseUrl = resolveToolBaseUrl(currentServer);
+    if (!baseUrl) return null;
+
+    const inputText = typeof userInput === "string"
+        ? userInput
+        : JSON.stringify(userInput ?? "");
+    const spaceId =
+        typeof (dialogConfig as any)?.spaceId === "string" && (dialogConfig as any).spaceId.trim()
+            ? (dialogConfig as any).spaceId.trim()
+            : typeof (state as any)?.space?.currentSpaceId === "string" && (state as any).space.currentSpaceId.trim()
+                ? (state as any).space.currentSpaceId.trim()
+                : undefined;
+
+    try {
+        const response = await fetch(`${baseUrl}/api/memory/query`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                agentKey,
+                userInput: inputText,
+                ...(spaceId ? { spaceId } : {}),
+            }),
+        });
+        if (!response.ok) return null;
+        const payload = await response.json().catch(() => null);
+        return typeof payload?.promptBlock === "string" && payload.promptBlock.trim()
+            ? payload.promptBlock.trim()
+            : null;
+    } catch {
+        return null;
+    }
+};
+
 
 /**
  * 构建静态上下文（Loop 外调用一次）
@@ -644,12 +699,19 @@ export const buildDynamicContexts = async (
         currentDialogMessages,
         currentDialogToolRuns,
     );
+    const memoryOverlay = await fetchMemoryOverlayContext(
+        state,
+        agentConfig,
+        userInput,
+        dialogConfig,
+    );
 
     return {
         currentInputContext: formattedCurrentInputContext.trim() || null,
         historyContext: joinMapValues(historyMap),
         editingContext,
         appWorkingMemory,
+        memoryOverlay,
         dialogSummary,
         proactiveSummary: dialogConfig?.proactiveSummary || null,
         referenceKeys: dialogConfig?.referenceKeys || [],
@@ -672,6 +734,7 @@ export const mergeContexts = (
     historyContext: dynamicCtx.historyContext || undefined,
     editingContext: dynamicCtx.editingContext,
     appWorkingMemory: dynamicCtx.appWorkingMemory,
+    memoryOverlay: dynamicCtx.memoryOverlay,
     dialogSummary: dynamicCtx.dialogSummary,
     proactiveSummary: dynamicCtx.proactiveSummary,
     referenceKeys: dynamicCtx.referenceKeys,

package/ai/ai.locale.ts

@@ -289,6 +289,41 @@ export default {
             max_tokens: "Maximum tokens for a single response. Suggestion: Do not set this unless you have a specific need (e.g., strict limit for very short replies).",
             reasoning_effort: "Reasoning effort. Higher values are slower but more rigorous."
           }
+        },
+        checkEnv: {
+          description: "Perform environment check and return structured results. check='context' shows platform, cwd and shells; check='build' verifies compile/build status.",
+          params: {
+            check: "The check item: 'context' returns current running environment, 'build' runs a build compile check.",
+            key: "Optional: probe a specific local tool (e.g. gemini, node, npm, bun, python, git, shell) without building."
+          }
+        },
+        deleteSpaces: {
+          description: "Find and delete spaces owned by the current user. Warning: first call returns confirmation preview, deletion only executes after confirmation.",
+          params: {
+            query: "Filter term for space search, can be space name or space ID (when combined with matchMode='spaceId').",
+            matchMode: "Match mode: prefix (name prefix), exact (full name match), contains (name contains), spaceId (match by ID). Default prefix.",
+            confirmedSpaceIds: "Optional list of space IDs to confirm for deletion. If omitted, all deletable spaces in the preview will be deleted."
+          }
+        },
+        listUserSpaces: {
+          description: "List all spaces that the current user belongs to, including space name, ID and role.",
+          params: {
+            brief: "If true, returns only brief summary to save context/tokens."
+          }
+        },
+        read: {
+          description: "Read content by its database key. Useful to query page contents, dialog history, or table records.",
+          params: {
+            dbKey: "The database key of the target record, e.g. PAGE-xxx, dialog-xxx, table-xxx.",
+            waitRemote: "If true, forces a remote synchronization read to fetch latest updates."
+          }
+        },
+        rememberMemory: {
+          description: "Write important user preferences or shared space agreements into episodic memory for long-term recall.",
+          params: {
+            content: "The memory content to remember, e.g., 'User prefers dark mode and uses TypeScript.'",
+            tags: "Optional tag array for classification and quick search."
+          }
         }
       },
     },
@@ -580,6 +615,41 @@ export default {
             max_tokens: "单次回答的最大 token 数。建议：除非有特殊需求（如强制控制回复极短），否则不要设置此项。",
             reasoning_effort: "推理强度，数值越高越慢但更严谨。"
           }
+        },
+        checkEnv: {
+          description: "执行环境检查并返回结构化结果。check='context' 可查看当前平台、工作目录与可用 shell；check='build' 可快速验证是否可编译。",
+          params: {
+            check: "检查项：context 返回当前运行环境；build 执行构建检查。",
+            key: "可选：探测某个本地工具，不执行 build。常用值如 gemini、node、npm、bun、python、git、shell。"
+          }
+        },
+        deleteSpaces: {
+          description: "按名称或 ID 查找并删除当前用户拥有的 Space。这是危险操作：第一次调用会返回待删除列表并等待用户确认；确认后才执行删除。",
+          params: {
+            query: "要删除的 Space 筛选词，例如 rn_owner_verify_0504，或配合 matchMode=spaceId 传入 space id。",
+            matchMode: "匹配方式。prefix=名称前缀，exact=名称完全匹配，contains=名称包含，spaceId=按 Space ID 匹配。默认 prefix。",
+            confirmedSpaceIds: "确认阶段要删除的 Space ID 列表。不传时，用户点击确认会删除预览列表中的全部可删除项。"
+          }
+        },
+        listUserSpaces: {
+          description: "列出当前用户拥有的或加入的所有 Space，返回 Space 名称、ID、成员角色等信息。",
+          params: {
+            brief: "是否返回精简信息。若为 true，只包含基本元信息，可节省上下文 Token。"
+          }
+        },
+        read: {
+          description: "根据数据库 Key 读取任意类型的数据记录（页面内容、对话历史、表格配置等）。",
+          params: {
+            dbKey: "要读取的记录 Key，例如 PAGE-xxx, dialog-xxx, table-xxx。",
+            waitRemote: "是否等待从远端同步最新数据后返回。默认 false。"
+          }
+        },
+        rememberMemory: {
+          description: "将值得长期保留的用户偏好或空间共识写入一条 episodic memory 记忆，供后续对话长期检索。",
+          params: {
+            content: "具体的记忆内容，例如：'用户更偏好使用 TypeScript 进行编码开发。'",
+            tags: "给这条记忆打上的标签数组，用于未来的归类 and 检索。"
+          }
         }
       },
     },

package/ai/chat/inlineImageUrlsForCustomProvider.ts

@@ -13,11 +13,16 @@ type InlineOptions = {
 const FILE_CONTENT_PATH = "/api/v1/db/file/content/";
 
 export const shouldInlineImageUrlsForAgent = (
-  agentConfig: { apiSource?: string | null; provider?: string | null } | null | undefined,
+  agentConfig:
+    | { apiSource?: string | null; model?: string | null; provider?: string | null }
+    | null
+    | undefined,
 ) => {
   const apiSource = agentConfig?.apiSource?.toLowerCase();
   const provider = agentConfig?.provider?.toLowerCase();
-  return apiSource === "custom" || provider === "custom";
+  const model = agentConfig?.model?.toLowerCase();
+  if (apiSource === "custom" || provider === "custom") return true;
+  return provider === "openrouter" && model === "minimax/minimax-m3";
 };
 
 const isInlineCandidate = (url: string) =>

package/ai/chat/sendOpenAICompletionsRequest.ts

@@ -118,6 +118,22 @@ function formatStreamErrorMessage(data: any): string {
   return rawMessage;
 }
 
+function getChoiceFinishErrorMessage(data: any, choice: any): string | null {
+  if (choice?.error || choice?.message || choice?.code) {
+    const message = formatStreamErrorMessage(choice);
+    if (message && message !== "Unknown error") return message;
+  }
+  if (data?.error || data?.message || data?.code) {
+    const message = formatStreamErrorMessage(data);
+    if (message && message !== "Unknown error") return message;
+  }
+  const messageContent = choice?.message?.content;
+  if (typeof messageContent === "string" && messageContent.trim()) {
+    return messageContent.trim();
+  }
+  return null;
+}
+
 /** 单次流式请求过程中的全部中间状态（显式 state） */
 type StreamState = {
   contentBuffer: MessageContentPart[];
@@ -854,11 +870,19 @@ export const sendOpenAICompletionsRequest = async ({
               // 无论是否 handoff，都 finalize 当前 assistant 消息（stub）
               streamState = await finalizeStream(streamState, finalizeCtx);
             } else if (finishReason !== "stop") {
+              const finishErrorMessage =
+                finishReason === "error"
+                  ? getChoiceFinishErrorMessage(data, choice)
+                  : null;
               streamState = {
                 ...streamState,
                 contentBuffer: appendTextChunk(
                   streamState.contentBuffer,
-                  `\n[流结束原因: ${finishReason}]`
+                  finishErrorMessage
+                    ? `\n[API Error] Error: ${finishErrorMessage}`
+                    : finishReason === "error"
+                      ? "\n[API Error] Error: 模型响应以 error 结束，但上游未返回具体错误。请重试，或切换到其他支持图片输入的模型。"
+                      : `\n[流结束原因: ${finishReason}]`
                 ),
               };
             }

package/ai/llm/kimi.ts

@@ -1,7 +1,6 @@
 export const FIREWORKS_KIMI_LATEST_MODEL = "accounts/fireworks/models/kimi-latest";
 export const FIREWORKS_KIMI_CURRENT_MODEL = "accounts/fireworks/models/kimi-k2p6";
 export const DEEPINFRA_KIMI_FALLBACK_MODEL = "moonshotai/Kimi-K2.6";
-export const OPENROUTER_KIMI_FALLBACK_MODEL = "moonshotai/kimi-k2.6";
 export const KIMI_PLATFORM_FALLBACK_STATUSES = [401, 402, 429, 500, 502, 503, 504];
 
 export const isFireworksKimiModel = (model?: string | null): boolean =>

package/ai/llm/openrouterModels.ts

@@ -1,6 +1,31 @@
-import { ModelDefinition } from '../types';
+import type { Model } from "./types";
 
-export const OPENROUTER_MODELS: ModelDefinition[] = [
+const OPENROUTER_PRICE_MULTIPLIER = 7;
+
+export const OPENROUTER_MODELS: Model[] = [
+  {
+    name: "x-ai/grok-4.3",
+    displayName: "xAI: Grok 4.3",
+    hasVision: true,
+    contextWindow: 1_000_000,
+    supportsTool: true,
+    supportsReasoningEffort: true,
+    price: {
+      input: 1.25 * OPENROUTER_PRICE_MULTIPLIER,
+      output: 2.5 * OPENROUTER_PRICE_MULTIPLIER,
+    },
+  },
+  {
+    name: "minimax/minimax-m3",
+    displayName: "MiniMax: MiniMax M3",
+    hasVision: true,
+    contextWindow: 1_000_000,
+    supportsTool: true,
+    price: {
+      input: 0.3 * OPENROUTER_PRICE_MULTIPLIER,
+      output: 1.2 * OPENROUTER_PRICE_MULTIPLIER,
+    },
+  },
 ];
 
 export const openrouterModels = OPENROUTER_MODELS;

package/ai/memory/policy.ts

@@ -0,0 +1,49 @@
+import type { MemorySubjectRef } from "./types";
+
+export type MemoryOwnerFallback = "onSubjectMiss" | "always";
+
+export type AgentMemoryPolicy = {
+  includeUserSubject: boolean;
+  ownerFallback: MemoryOwnerFallback;
+  allowDynamicGreetingMemory: boolean;
+};
+
+export function isPublicAgentKey(agentKey?: string | null): boolean {
+  return typeof agentKey === "string" && /^agent-pub-/i.test(agentKey.trim());
+}
+
+export function resolveAgentMemoryPolicy(input: {
+  agentKey?: string | null;
+  isPublicAgent?: boolean | null;
+}): AgentMemoryPolicy {
+  const publicAgent = input.isPublicAgent === true || isPublicAgentKey(input.agentKey);
+  if (publicAgent) {
+    return {
+      includeUserSubject: false,
+      ownerFallback: "onSubjectMiss",
+      allowDynamicGreetingMemory: false,
+    };
+  }
+
+  return {
+    includeUserSubject: true,
+    ownerFallback: "always",
+    allowDynamicGreetingMemory: true,
+  };
+}
+
+export function buildMemorySubjectsForAgent(input: {
+  userId?: string | null;
+  spaceId?: string | null;
+  agentKey: string;
+  policy?: AgentMemoryPolicy;
+}): MemorySubjectRef[] {
+  const policy = input.policy ?? resolveAgentMemoryPolicy({ agentKey: input.agentKey });
+  return [
+    { subjectType: "agent" as const, subjectId: input.agentKey },
+    policy.includeUserSubject && input.userId
+      ? { subjectType: "user" as const, subjectId: input.userId }
+      : null,
+    input.spaceId ? { subjectType: "space" as const, subjectId: input.spaceId } : null,
+  ].filter((value): value is MemorySubjectRef => !!value);
+}

package/ai/memory/queryShared.ts

@@ -86,10 +86,12 @@ export const loadMemoryCandidatesFromDb = async (
     subjects: MemorySubjectRef[];
     kinds?: MemoryKind[];
     ownerLimit?: number;
+    ownerFallback?: "onSubjectMiss" | "always";
   }
 ): Promise<MemoryItem[]> => {
   const kinds = input.kinds ?? ["episodic", "semantic", "procedural"];
   const ownerLimit = input.ownerLimit ?? 12;
+  const ownerFallback = input.ownerFallback ?? "onSubjectMiss";
   const ownerKeySet = new Set(
     input.owners
       .filter((owner) => owner.ownerId)
@@ -110,10 +112,14 @@ export const loadMemoryCandidatesFromDb = async (
         )
       : [];
   const subjectHitCount = subjectResults.reduce((sum, items) => sum + items.length, 0);
-  const usingOwnerFallback = subjects.length === 0 || subjectHitCount === 0;
-  const results = usingOwnerFallback
+  const shouldLoadOwnerFallback =
+    subjects.length === 0 || subjectHitCount === 0 || ownerFallback === "always";
+  const results = shouldLoadOwnerFallback
     ? await Promise.all(
-        input.owners.map((owner) => loadOwnerItemsFromDb(db, owner, ownerLimit))
+        [
+          ...subjectResults,
+          ...input.owners.map((owner) => loadOwnerItemsFromDb(db, owner, ownerLimit)),
+        ]
       )
     : subjectResults;
 
@@ -131,7 +137,7 @@ export const loadMemoryCandidatesFromDb = async (
         continue;
       }
       if (
-        !usingOwnerFallback &&
+        !shouldLoadOwnerFallback &&
         subjects.length > 0 &&
         !subjects.some(
           (subject) =>

package/ai/memory/recentRelationshipRecap.ts

@@ -1,5 +1,6 @@
 import { createDialogKey, dialogMessageRange } from "../../database/keys";
 import { extractCustomId } from "../../core/prefix";
+import { resolveAgentMemoryPolicy } from "./policy";
 
 interface RecentDialogLike {
   dbKey?: string;
@@ -43,6 +44,9 @@ export const shouldUseRecentRelationshipRecap = (input: {
   triggerType?: "user" | "api" | "localhost" | "scheduled_run";
 }): boolean => {
   if (!input.userId || !input.agentKey) return false;
+  if (!resolveAgentMemoryPolicy({ agentKey: input.agentKey }).allowDynamicGreetingMemory) {
+    return false;
+  }
   if ((input.cybotsCount ?? 0) !== 1) return false;
   if (input.inheritFromDialogKey) return false;
   if (input.skipGreeting) return false;