minimal-agent 0.12.0 → 0.14.0

package/src/session/runAgentTurn.ts

@@ -1,30 +1,32 @@
-import {
-  buildBaseSystemPrompt,
-  buildTransientPromptBundle,
-} from '../prompts/system.js';
-import { ALL_TOOLS } from '../tools/index.js';
-import type { LoopEvent, Provider } from '../types.js';
-import { sessionFileFor } from '../context/sessionPath.js';
-import {
-  getOrCreateSessionState,
-  sessionStateKey,
-  type SessionState,
-} from './sessionState.js';
-import { hydrateSessionWorktree } from '../tools/worktree/sessionWorktree.js';
-import { runTurn } from './runTurn.js';
 import { withWorkingDir } from '../bootstrap/workingDir.js';
+import { configService } from '../config/configService.js';
+import { sessionFileFor } from '../context/sessionPath.js';
 import {
   listSessionSummaries,
   updateSessionMetadata,
 } from '../context/sessionRegistry.js';
 import { workspaceIndexService } from '../context/workspaceIndex.js';
-import { configService } from '../config/configService.js';
 import { createPromptCacheContext } from '../llm/promptCache.js';
+import { type ModelRef, modelRefFromLegacy } from '../modelRef.js';
+import {
+  buildBaseSystemPrompt,
+  buildTransientPromptBundle,
+} from '../prompts/system.js';
 import {
   createAgentRuntimeContext,
   filterToolsForRuntime,
   memoryContextFromRuntime,
 } from '../runtime/agentRuntimeContext.js';
+import { filterToolsForCategories } from '../team/toolPolicy.js';
+import { ALL_TOOLS } from '../tools/index.js';
+import { hydrateSessionWorktree } from '../tools/worktree/sessionWorktree.js';
+import type { LoopEvent, Provider } from '../types.js';
+import { runTurn } from './runTurn.js';
+import {
+  type SessionState,
+  getOrCreateSessionState,
+  sessionStateKey,
+} from './sessionState.js';
 
 export interface RunAgentTurnOptions {
   input: string;
@@ -59,6 +61,17 @@ export async function runAgentTurn(
     (item) => item.id === opts.sessionId,
   );
   let sessionModelId = session?.modelId;
+  const preferredModel = session?.preferredModel;
+  // Sessions created before source-aware model references were introduced may
+  // still carry only the legacy `online:<id>` value. Treat that value as the
+  // same gateway preference so fallback and recovery follow one state machine.
+  const storedModelRef =
+    preferredModel ??
+    (sessionModelId?.startsWith('online:')
+      ? modelRefFromLegacy(sessionModelId)
+      : undefined);
+  if (!opts.model && preferredModel?.source === 'local')
+    sessionModelId = preferredModel.modelId;
   if (!opts.model && !sessionModelId) {
     sessionModelId =
       (await configService.getSnapshot()).config?.baseModelId ?? undefined;
@@ -68,13 +81,56 @@ export async function runAgentTurn(
       }).catch(() => {});
     }
   }
-  const sessionProvider =
-    !opts.model && sessionModelId
-      ? await configService.providerForModel(sessionModelId)
+  const gatewayResolution =
+    !opts.model && storedModelRef?.source === 'gateway'
+      ? await configService
+          .resolveModelRef(storedModelRef)
+          .catch(() => ({ provider: null, fallbackReason: 'offline' as const }))
+      : null;
+  const sessionProvider = !opts.model
+    ? (gatewayResolution?.provider ??
+      (await configService
+        .providerForRef(storedModelRef as ModelRef | null)
+        .catch(() => null)))
+    : null;
+  const localSessionModelId =
+    storedModelRef?.source === 'local'
+      ? storedModelRef.modelId
+      : sessionModelId && !sessionModelId.startsWith('online:')
+        ? sessionModelId
+        : undefined;
+  const legacySessionProvider =
+    !opts.model && !sessionProvider && localSessionModelId
+      ? await configService.providerForModel(localSessionModelId)
+      : null;
+  const fallbackProvider =
+    !opts.model && gatewayResolution && !gatewayResolution.provider
+      ? await configService.providerForModel(null).catch(() => null)
       : null;
   const provider = opts.model
     ? { ...opts.provider, model: opts.model }
-    : (sessionProvider ?? opts.provider);
+    : (sessionProvider ??
+      fallbackProvider ??
+      legacySessionProvider ??
+      opts.provider);
+  if (
+    !opts.model &&
+    gatewayResolution &&
+    !gatewayResolution.provider &&
+    fallbackProvider
+  ) {
+    await updateSessionMetadata(opts.cwd, opts.sessionId, {
+      ...(storedModelRef?.source === 'gateway' && !preferredModel
+        ? { preferredModel: storedModelRef }
+        : {}),
+      effectiveModel: {
+        source: 'local',
+        modelId: localSessionModelId ?? fallbackProvider.model,
+      },
+      fallbackReason: gatewayResolution.fallbackReason,
+      restoreWhenAvailable: true,
+    }).catch(() => {});
+  }
   const workspace = await workspaceIndexService
     .register(opts.cwd)
     .catch(() => undefined);
@@ -117,7 +173,31 @@ export async function runAgentTurn(
       memoryAccess: opts.memoryAccess ?? 'denied',
       interactiveAsk: false,
     });
-    const turnTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+    const runtimeTools = filterToolsForRuntime(ALL_TOOLS, runtimeContext);
+    const effectiveGatewayCategories =
+      provider.source === 'gateway'
+        ? [
+            ...new Set(
+              (
+                session?.onlineToolCategories ??
+                provider.gatewayDefaultToolCategories ??
+                provider.gatewayMaxToolCategories ??
+                []
+              ).filter(
+                (category) =>
+                  provider.gatewayMaxToolCategories?.includes(category) ?? true,
+              ),
+            ),
+          ]
+        : undefined;
+    const turnProvider =
+      provider.source === 'gateway'
+        ? { ...provider, gatewayToolCategories: effectiveGatewayCategories }
+        : provider;
+    const turnTools =
+      provider.source === 'gateway'
+        ? filterToolsForCategories(runtimeTools, effectiveGatewayCategories)
+        : runtimeTools;
     const systemPrompt = await buildBaseSystemPrompt(effectiveCwd, turnTools);
     const transientBundle = await buildTransientPromptBundle({
       cwd: effectiveCwd,
@@ -137,7 +217,7 @@ export async function runAgentTurn(
     }).catch(() => {});
     for await (const ev of run({
       userInput: opts.input,
-      provider,
+      provider: turnProvider,
       sessionFile,
       systemPrompt,
       ...(transientBundle ? { transientBundle } : {}),
@@ -154,6 +234,8 @@ export async function runAgentTurn(
       if (isEventLike(ev)) {
         events.push(ev);
         if (ev.type === 'text') result += ev.delta;
+        if (ev.type === 'assistant_draft_discarded' && ev.textLength > 0)
+          result = result.slice(0, Math.max(0, result.length - ev.textLength));
         if (ev.type === 'assistant_message') numTurns++;
         // compact_failed 是非致命（loop 压缩失败后 snip 兜底继续跑完，types.ts 有约定；
         // print.ts 同样特判）——不置 error，否则 cron 会把自愈轮误判失败。
@@ -175,7 +257,7 @@ export async function runAgentTurn(
 function isEventLike(ev: unknown): ev is LoopEvent {
   return Boolean(
     ev &&
-    typeof ev === 'object' &&
-    typeof (ev as { type?: unknown }).type === 'string',
+      typeof ev === 'object' &&
+      typeof (ev as { type?: unknown }).type === 'string',
   );
 }

package/src/session/runTurn.js

@@ -18,14 +18,15 @@
  *    消息追加到 history，所以落盘的也是合法且完整的会话状态。
  * ============================================================
  */
-import { loadContext, saveContext } from '../context/persistContext.js';
 import { acquireContextLock } from '../context/contextLock.js';
+import { loadContext, saveContext } from '../context/persistContext.js';
 import { startTurnJournal } from '../memory/turnJournal.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
+import { upsertStableSystemMessage } from '../prompts/stableSystemPrompt.js';
 /**
  * 已有历史时，用调用方新算好的 systemPrompt（含当前日期/实时扫描的 skills·plugins 清单/
  * 项目指令）替换旧的 system 消息，其余历史原样保留——与 ui/Root.tsx 的 TUI 启动逻辑、
- * workflow-runner::refreshWorkflowSystemPrompt 行为一致。堵上 headless 会话（cron-runner
+ * `refreshStableSystemPrompt()` 行为一致。堵上 headless 会话（cron-runner
  * 纯文本 action 等长期复用同一 sessionFile 的调用方）系统提示词只在首次开会话时生效、
  * 此后永久冻结的口子——此前的行为是"已有历史就完全忽略新 systemPrompt"，日期/skills/
  * plugins/项目指令都不会再刷新，与"运行时实时扫描"的设计承诺矛盾。
@@ -41,13 +42,10 @@ import { runWithPlugins } from '../plugins/pluginRunner.js';
  *   既保住了"运行时实时扫描"的承诺，又不破坏缓存。
  */
 function buildInitialHistory(loaded, systemPrompt) {
-    if (!loaded) {
-        return systemPrompt ? [{ role: 'system', content: systemPrompt }] : [];
-    }
-    if (!systemPrompt)
-        return loaded;
-    const rest = loaded[0]?.role === 'system' ? loaded.slice(1) : loaded;
-    return [{ role: 'system', content: systemPrompt }, ...rest];
+    const history = loaded ? [...loaded] : [];
+    if (systemPrompt)
+        upsertStableSystemMessage(history, systemPrompt);
+    return history;
 }
 export async function* runTurn(opts) {
     const persist = opts.persist !== false;
@@ -71,6 +69,7 @@ export async function* runTurn(opts) {
             maxTurns: opts.maxTurns,
             runtimeContext: opts.runtimeContext,
             allowedTools: opts.allowedTools,
+            availableTools: opts.availableTools,
             sessionState: opts.sessionState,
             chat: opts.chat,
             executeTool: opts.executeTool,
@@ -80,7 +79,9 @@ export async function* runTurn(opts) {
             transientBundle: opts.transientBundle,
             promptCache: opts.promptCache,
             userAttachments: opts.userAttachments,
+            inputResources: opts.inputResources,
             userMessageId: opts.userMessageId,
+            messageProvenance: opts.messageProvenance,
             userBrowserReferences: opts.userBrowserReferences,
             imageInputs: opts.imageInputs,
             parseInlineImages: opts.parseInlineImages,

package/src/session/runTurn.ts

@@ -19,11 +19,12 @@
  * ============================================================
  */
 
-import { loadContext, saveContext } from '../context/persistContext.js';
 import { acquireContextLock } from '../context/contextLock.js';
+import { loadContext, saveContext } from '../context/persistContext.js';
 import { startTurnJournal } from '../memory/turnJournal.js';
 import type { PluginEvent } from '../plugins/pluginApi.js';
 import { runWithPlugins } from '../plugins/pluginRunner.js';
+import { upsertStableSystemMessage } from '../prompts/stableSystemPrompt.js';
 import type {
   ImageDetail,
   ImageInputSpec,
@@ -45,6 +46,12 @@ export interface RunTurnOptions {
   maxTurns?: number;
   runtimeContext?: import('../runtime/agentRuntimeContext.js').AgentRuntimeContext;
   allowedTools?: import('../loop.js').RunQueryOptions['allowedTools'];
+  /**
+   * 本回合实际可调用的工具对象池（不只是名字）。缺省时 `loop.ts` 退回 `ALL_TOOLS`
+   * 静态注册表，装不下按回合动态构造的工具（群协作工具、每次都要闭包捕获当次
+   * owner/群 id/回复回调）。见 `pluginRunner.ts` 里这个字段的完整头注。
+   */
+  availableTools?: import('../loop.js').RunQueryOptions['availableTools'];
   /** DI：透传给 runWithPlugins→runQuery（仅测试用，生产不传走默认实现）。
    *  让测试用显式注入替代 mock.module(loop.js)——后者会全局泄漏污染其它测试文件。 */
   chat?: import('../plugins/pluginRunner.js').PluginRunnerOptions['chat'];
@@ -57,8 +64,10 @@ export interface RunTurnOptions {
   transientBundle?: import('../plugins/pluginRunner.js').PluginRunnerOptions['transientBundle'];
   promptCache?: import('../plugins/pluginRunner.js').PluginRunnerOptions['promptCache'];
   userAttachments?: MessageAttachmentRef[];
+  inputResources?: readonly import('../types.js').InvocationResource[];
   /** Stable message identity supplied by a host/runtime request. */
   userMessageId?: string;
+  messageProvenance?: import('../types.js').ConversationProvenance;
   userBrowserReferences?: MessageBrowserReference[];
   imageInputs?: ImageInputSpec[];
   parseInlineImages?: boolean;
@@ -77,7 +86,7 @@ export interface RunTurnOptions {
 /**
  * 已有历史时，用调用方新算好的 systemPrompt（含当前日期/实时扫描的 skills·plugins 清单/
  * 项目指令）替换旧的 system 消息，其余历史原样保留——与 ui/Root.tsx 的 TUI 启动逻辑、
- * workflow-runner::refreshWorkflowSystemPrompt 行为一致。堵上 headless 会话（cron-runner
+ * `refreshStableSystemPrompt()` 行为一致。堵上 headless 会话（cron-runner
  * 纯文本 action 等长期复用同一 sessionFile 的调用方）系统提示词只在首次开会话时生效、
  * 此后永久冻结的口子——此前的行为是"已有历史就完全忽略新 systemPrompt"，日期/skills/
  * plugins/项目指令都不会再刷新，与"运行时实时扫描"的设计承诺矛盾。
@@ -96,12 +105,9 @@ function buildInitialHistory(
   loaded: Message[] | null,
   systemPrompt: string | undefined,
 ): Message[] {
-  if (!loaded) {
-    return systemPrompt ? [{ role: 'system', content: systemPrompt }] : [];
-  }
-  if (!systemPrompt) return loaded;
-  const rest = loaded[0]?.role === 'system' ? loaded.slice(1) : loaded;
-  return [{ role: 'system', content: systemPrompt }, ...rest];
+  const history = loaded ? [...loaded] : [];
+  if (systemPrompt) upsertStableSystemMessage(history, systemPrompt);
+  return history;
 }
 
 export async function* runTurn(
@@ -129,6 +135,7 @@ export async function* runTurn(
       maxTurns: opts.maxTurns,
       runtimeContext: opts.runtimeContext,
       allowedTools: opts.allowedTools,
+      availableTools: opts.availableTools,
       sessionState: opts.sessionState,
       chat: opts.chat,
       executeTool: opts.executeTool,
@@ -138,7 +145,9 @@ export async function* runTurn(
       transientBundle: opts.transientBundle,
       promptCache: opts.promptCache,
       userAttachments: opts.userAttachments,
+      inputResources: opts.inputResources,
       userMessageId: opts.userMessageId,
+      messageProvenance: opts.messageProvenance,
       userBrowserReferences: opts.userBrowserReferences,
       imageInputs: opts.imageInputs,
       parseInlineImages: opts.parseInlineImages,

package/src/session/sessionState.ts

@@ -31,6 +31,8 @@ export interface SessionState {
   fileReads: FileReadState;
   backgroundTasks: BackgroundTaskState;
   agentTasks: AgentTaskState;
+  /** Short-lived evidence that this Session actually used native desktop automation. */
+  computerAutomation?: { lastUsedAt: number };
   /** Main-agent worktree changes the effective cwd without changing workspace identity. */
   activeWorktree?: {
     id: string;

package/src/team/auth.js

@@ -0,0 +1,186 @@
+/** Minimal, opt-in team credential store.  Standalone startup never imports or
+ * reads it; only explicit team commands / online-model resolution do. */
+import { chmod, mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getConfigFilePath } from '../config/configFile.js';
+const TEAM_REQUEST_TIMEOUT_MS = Math.max(3_000, Math.min(60_000, Number(process.env.MINIMAL_AGENT_TEAM_REQUEST_TIMEOUT_MS ?? 15_000)));
+function authPath() {
+    return join(dirname(getConfigFilePath()), 'team-auth.json');
+}
+export function normalizeTeamServerUrl(value) {
+    const url = new URL(value.trim());
+    if (url.protocol !== 'https:' && url.protocol !== 'http:')
+        throw new Error('团队服务器必须使用 http(s) 地址');
+    const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    const isLocalDevelopmentHost = hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '::1';
+    if (url.protocol === 'http:' &&
+        !isLocalDevelopmentHost &&
+        process.env.KAKADEAI_ALLOW_HTTP_TEAM_SERVER !== '1') {
+        throw new Error('团队服务器必须使用 HTTPS（开发环境可使用本机地址或显式允许 HTTP）');
+    }
+    url.search = '';
+    url.hash = '';
+    return url.toString().replace(/\/$/, '');
+}
+export async function loadTeamCredentials(expectedServerUrl) {
+    const rawServerUrl = process.env.KAKADEAI_SOCIAL_SERVER_URL;
+    // The Desktop shell deliberately injects an empty value in standalone mode.
+    // An empty environment value is an explicit opt-out and must not fall back
+    // to a stale team-auth.json left by an earlier team-mode run.
+    if (rawServerUrl !== undefined && !rawServerUrl.trim())
+        return null;
+    const serverUrl = rawServerUrl?.trim() ?? expectedServerUrl?.trim();
+    if (rawServerUrl?.trim() &&
+        expectedServerUrl?.trim() &&
+        normalizeTeamServerUrl(rawServerUrl) !==
+            normalizeTeamServerUrl(expectedServerUrl))
+        return null;
+    const deviceToken = process.env.KAKADEAI_TEAM_DEVICE_TOKEN?.trim();
+    if (serverUrl && deviceToken) {
+        return {
+            serverUrl: normalizeTeamServerUrl(serverUrl),
+            deviceToken,
+            ...(process.env.KAKADEAI_TEAM_DEVICE_LABEL
+                ? { deviceLabel: process.env.KAKADEAI_TEAM_DEVICE_LABEL }
+                : {}),
+            updatedAt: Date.now(),
+        };
+    }
+    try {
+        const raw = JSON.parse(await readFile(authPath(), 'utf8'));
+        if (!raw.serverUrl || !raw.deviceToken)
+            return null;
+        const storedServerUrl = normalizeTeamServerUrl(raw.serverUrl);
+        if (serverUrl && storedServerUrl !== normalizeTeamServerUrl(serverUrl))
+            return null;
+        return {
+            serverUrl: storedServerUrl,
+            deviceToken: raw.deviceToken,
+            ...(raw.deviceLabel ? { deviceLabel: raw.deviceLabel } : {}),
+            updatedAt: Number(raw.updatedAt) || 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveTeamCredentials(value) {
+    const path = authPath();
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify({ ...value, serverUrl: normalizeTeamServerUrl(value.serverUrl) }, null, 2)}\n`, { mode: 0o600 });
+    await chmod(temporary, 0o600).catch(() => { });
+    await rename(temporary, path);
+    await chmod(path, 0o600).catch(() => { });
+}
+export async function clearTeamCredentials() {
+    const path = authPath();
+    await writeFile(path, '{}\n', { mode: 0o600 }).catch(() => { });
+}
+/**
+ * Revoke exactly the credentials supplied by the caller, then clear the local
+ * copy. A null value is deliberately local-only: silently discovering an old
+ * team-auth.json here could make standalone logout contact a historical
+ * server. Callers that want remote revocation must first load credentials
+ * against the currently configured server.
+ */
+export async function revokeTeamCredentials(credentials) {
+    if (credentials?.serverUrl && credentials.deviceToken) {
+        await fetch(`${credentials.serverUrl}/api/auth/device/logout`, {
+            method: 'POST',
+            headers: { authorization: `Bearer ${credentials.deviceToken}` },
+        }).catch(() => { });
+    }
+    await clearTeamCredentials();
+}
+export async function fetchOnlineModels(credentials) {
+    const response = await fetch(`${credentials.serverUrl}/api/models`, {
+        headers: { authorization: `Bearer ${credentials.deviceToken}` },
+        signal: AbortSignal.timeout(TEAM_REQUEST_TIMEOUT_MS),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        const code = body.code ??
+            (response.status === 401
+                ? 'DEVICE_REVOKED'
+                : response.status === 403
+                    ? 'MODEL_UNAVAILABLE'
+                    : `HTTP_${response.status}`);
+        throw new Error(`[${code}] ${body.error ?? `读取在线模型失败（${response.status}）`}`);
+    }
+    return (body.models ?? []).filter((model) => typeof model.id === 'string');
+}
+export async function fetchTeamSubscription(credentials) {
+    const response = await fetch(`${credentials.serverUrl}/api/account/subscription`, {
+        headers: { authorization: `Bearer ${credentials.deviceToken}` },
+        signal: AbortSignal.timeout(TEAM_REQUEST_TIMEOUT_MS),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        throw new Error(body.error ?? `读取订阅失败（${response.status}）`);
+    return body.subscription ?? null;
+}
+export async function fetchTeamUsage(credentials) {
+    const response = await fetch(`${credentials.serverUrl}/api/account/usage`, {
+        headers: { authorization: `Bearer ${credentials.deviceToken}` },
+        signal: AbortSignal.timeout(TEAM_REQUEST_TIMEOUT_MS),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        throw new Error(body.error ?? `读取用量失败（${response.status}）`);
+    return body.usage ?? [];
+}
+export async function resolveOnlineModel(modelId, expectedServerUrl) {
+    const credentials = await loadTeamCredentials(expectedServerUrl);
+    if (!credentials)
+        return null;
+    const models = await fetchOnlineModels(credentials);
+    const model = models.find((item) => item.id === modelId);
+    return model ? { credentials, model } : null;
+}
+export async function beginTeamLogin(serverUrl, deviceLabel = 'minimal-agent') {
+    const normalized = normalizeTeamServerUrl(serverUrl);
+    const start = await fetch(`${normalized}/api/auth/device/start`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ clientLabel: deviceLabel }),
+        signal: AbortSignal.timeout(TEAM_REQUEST_TIMEOUT_MS),
+    });
+    const authorization = (await start.json().catch(() => ({})));
+    if (!start.ok ||
+        !authorization.requestId ||
+        !authorization.deviceCode ||
+        !authorization.authorizeUrl)
+        throw new Error(authorization.error ?? '无法发起团队登录');
+    return {
+        authorizeUrl: authorization.authorizeUrl,
+        complete: async () => {
+            const deadline = Date.now() + 10 * 60_000;
+            while (Date.now() < deadline) {
+                const poll = await fetch(`${normalized}/api/auth/device/poll?requestId=${encodeURIComponent(authorization.requestId)}`, {
+                    headers: {
+                        'x-kakadeai-device-code': authorization.deviceCode,
+                    },
+                    signal: AbortSignal.timeout(TEAM_REQUEST_TIMEOUT_MS),
+                });
+                const result = (await poll.json().catch(() => ({})));
+                if (result.state === 'approved' && result.deviceToken) {
+                    const credentials = {
+                        serverUrl: normalized,
+                        deviceToken: result.deviceToken,
+                        deviceLabel,
+                        updatedAt: Date.now(),
+                    };
+                    await saveTeamCredentials(credentials);
+                    return credentials;
+                }
+                if (result.state === 'expired')
+                    throw new Error('浏览器授权已过期，请重新登录');
+                if (!poll.ok && result.error)
+                    throw new Error(result.error);
+                await new Promise((resolve) => setTimeout(resolve, 1500));
+            }
+            throw new Error('等待浏览器授权超时');
+        },
+    };
+}