[Init] Initial commit - NetMesh terminal manager

infrastructure/ai/harness/turnDrivers/cattyTurnDriver.ts

@@ -0,0 +1,549 @@
+import type { ModelMessage } from 'ai';
+import type { OpenAIChatAssistantFields } from '../../providerContinuation';
+import {
+  DEFAULT_CONTEXT_WINDOW_TOKENS,
+  DEFAULT_PROTECT_RECENT_MESSAGES,
+  estimateUnknownTokens,
+  findSafeChatMessageCompactionSplitIndex,
+  resolveContextWindow,
+} from '../../contextCompaction';
+import { buildSystemPrompt } from '../../cattyAgent/systemPrompt';
+import {
+  isWebSearchReady,
+  normalizeCommandTimeoutSeconds,
+  normalizeResponseIdleTimeoutSeconds,
+  resolveOpenAIApi,
+  resolveProviderStyle,
+} from '../../types';
+import {
+  applyResponsesApiStatelessStoreOption,
+  buildCattyReasoningProviderOptions,
+  estimateReasoningOutputReserve,
+} from '../../cattyReasoning';
+import { createModelFromConfig } from '../../sdk/providers';
+import { createCattyToolsFromCatalog } from '../capabilityTools';
+import { createInitialCattyRuntimeContext } from '../cattyRuntimeContext';
+import { prepareStepContext, extractLatestUserGoal } from '../contextManager';
+import {
+  compactCattyMessages,
+  prepareCattyMessagesForStream,
+} from '../cattyRuntime';
+import { computeTotalInputTokens, DEFAULT_MAX_OUTPUT_TOKENS } from '../contextBudget';
+import { clearChatSessionCancelled } from '../agentStop';
+import { isRequestTooLargeError } from '../../errorClassifier';
+import { getNetcattyBridge, generateId, resolveUserSkillsContext } from '../../aiChatStreamingSupport';
+import {
+  buildCattySdkMessages,
+  collectOpenAIChatAssistantFieldsForMessages,
+  collectPreservedTerminalWriteFingerprints,
+  collectToolResultsAfterMessage,
+  createContinuationContext,
+} from './cattyMessageBuilder';
+import { hadToolProgressBeforeRequestTooLarge, processCattyStream } from './cattyStreamProcessor';
+import type { CattyTurnInput, TurnDriver, TurnDriverContext } from './types';
+import { fitLargeUserInputForModel } from '../largeUserInput';
+import { buildPromptContextSnapshot } from '../promptContextSnapshot';
+
+export class CattyTurnDriver implements TurnDriver {
+  readonly backend = 'catty' as const;
+
+  async run(input: import('./types').TurnInput, ctx: TurnDriverContext): Promise<void> {
+    if (input.backend !== 'catty') {
+      throw new Error('CattyTurnDriver received non-catty input');
+    }
+    await runCattyTurn(input, ctx);
+  }
+
+  abort(): void {
+    // Abort is handled via AbortSignal on the turn input.
+  }
+}
+
+async function runCattyTurn(input: CattyTurnInput, ctx: TurnDriverContext): Promise<void> {
+  const {
+    chatSessionId: sessionId,
+    userText: trimmed,
+    signal,
+    currentSession,
+    assistantMsgId,
+    context,
+    attachments,
+    maxIterations,
+    bridge,
+    ui,
+  } = input;
+
+  const netcattyBridge = (bridge ?? getNetcattyBridge()) as NonNullable<ReturnType<typeof getNetcattyBridge>>;
+  const toolOutputTempBridge = netcattyBridge as typeof netcattyBridge & {
+    getToolOutputPersistenceStatus?: () => Promise<{ durable: boolean; reason?: string }>;
+    writeToolOutputTemp?: (
+      record: import('../toolOutputStore').PersistedToolOutputRecord,
+      content: string,
+    ) => Promise<{ ok: boolean; path?: string; error?: string }>;
+    restoreToolOutputTemp?: (
+      handleId: string,
+      chatSessionId: string,
+    ) => Promise<{ path: string; record: import('../toolOutputStore').PersistedToolOutputRecord } | null>;
+    readToolOutputTemp?: (
+      path: string,
+      request: import('../toolOutputStore').ReadToolOutputInput,
+    ) => Promise<Omit<import('../toolOutputStore').ToolOutputReadResult, 'handleId' | 'storedChars' | 'sourceTruncated'> | null>;
+    deleteToolOutputTemp?: (path: string) => Promise<{ ok: boolean }>;
+    deleteChatToolOutputsTemp?: (chatSessionId: string) => Promise<{ deletedCount: number }>;
+    deleteTerminalToolOutputsTemp?: (
+      chatSessionId: string,
+      terminalSessionId: string,
+    ) => Promise<{ deletedCount: number }>;
+  };
+  const persistenceStatus = await toolOutputTempBridge.getToolOutputPersistenceStatus?.()
+    .catch(() => ({ durable: false }));
+  if (
+    toolOutputTempBridge.writeToolOutputTemp
+    && toolOutputTempBridge.readToolOutputTemp
+    && toolOutputTempBridge.deleteToolOutputTemp
+  ) {
+    ctx.toolOutputStore.setPersistence?.({
+      write: async (record, content) => {
+        if (!persistenceStatus?.durable) {
+          throw new Error(persistenceStatus?.reason || 'Secure local storage is unavailable.');
+        }
+        const result = await toolOutputTempBridge.writeToolOutputTemp!(record, content);
+        if (!result.ok || !result.path) {
+          throw new Error(result.error || 'Unable to persist tool output.');
+        }
+        return result.path;
+      },
+      restore: persistenceStatus?.durable && toolOutputTempBridge.restoreToolOutputTemp
+        ? (handleId, chatSessionId) => toolOutputTempBridge.restoreToolOutputTemp!(handleId, chatSessionId)
+        : undefined,
+      read: (path, request) => toolOutputTempBridge.readToolOutputTemp!(path, request),
+      delete: async path => {
+        await toolOutputTempBridge.deleteToolOutputTemp!(path);
+      },
+      deleteSession: toolOutputTempBridge.deleteChatToolOutputsTemp
+        ? async chatSessionId => {
+          await toolOutputTempBridge.deleteChatToolOutputsTemp!(chatSessionId);
+        }
+        : undefined,
+      deleteTerminalSession: toolOutputTempBridge.deleteTerminalToolOutputsTemp
+        ? async (chatSessionId, terminalSessionId) => {
+          await toolOutputTempBridge.deleteTerminalToolOutputsTemp!(chatSessionId, terminalSessionId);
+        }
+        : undefined,
+      deleteTerminalEverywhere: toolOutputTempBridge.deleteTerminalToolOutputsEverywhereTemp
+        ? async terminalSessionId => {
+          await toolOutputTempBridge.deleteTerminalToolOutputsEverywhereTemp!(terminalSessionId);
+        }
+        : undefined,
+    });
+  } else {
+    ctx.toolOutputStore.setPersistence?.(undefined);
+  }
+  await clearChatSessionCancelled(sessionId, netcattyBridge);
+  if (netcattyBridge.aiMcpUpdateSessions) {
+    await netcattyBridge.aiMcpUpdateSessions(context.terminalSessions, sessionId);
+  }
+  if (attachments?.length && netcattyBridge.aiMcpUpdateAttachments) {
+    await netcattyBridge.aiMcpUpdateAttachments(attachments, sessionId);
+  }
+  const userSkillsContext = await resolveUserSkillsContext(
+    netcattyBridge,
+    trimmed,
+    context.selectedUserSkillSlugs,
+  );
+  const modelUserText = fitLargeUserInputForModel(trimmed, sessionId, ctx.toolOutputStore);
+  const getExecutorContext = context.getExecutorContext ?? (() => ({
+    sessions: context.terminalSessions,
+    workspaceId: context.scopeType === 'workspace' ? context.scopeTargetId : undefined,
+    workspaceName: context.scopeType === 'workspace' ? context.scopeLabel : undefined,
+  }));
+  const toolsBundle = createCattyToolsFromCatalog(
+    netcattyBridge,
+    getExecutorContext,
+    context.commandBlocklist,
+    context.globalPermissionMode,
+    context.webSearchConfig ?? undefined,
+    sessionId,
+    ctx.toolOutputStore,
+    ctx.toolResultDedup,
+  );
+  const { tools } = toolsBundle;
+
+  const systemPrompt = buildSystemPrompt({
+    scopeType: context.scopeType,
+    scopeLabel: context.scopeLabel,
+    hosts: context.terminalSessions,
+    permissionMode: context.globalPermissionMode,
+    webSearchEnabled: isWebSearchReady(context.webSearchConfig),
+    userSkillsContext,
+  });
+
+  if (!context.activeProvider) {
+    ui.reportStreamError(sessionId, signal, 'No AI provider configured. Please configure a provider in Settings → AI.');
+    return;
+  }
+
+  const activeModelId = context.activeModelId || context.activeProvider.defaultModel || '';
+  const promptContext = buildPromptContextSnapshot({
+    providerId: context.activeProvider.providerId,
+    modelId: activeModelId,
+    permissionMode: context.permissionMode ?? context.globalPermissionMode,
+    scopeType: context.scopeType,
+    scopeLabel: context.scopeLabel,
+    toolNames: Object.keys(tools),
+    selectedSkillSlugs: context.selectedUserSkillSlugs,
+    systemPrompt,
+    webSearchEnabled: isWebSearchReady(context.webSearchConfig),
+    hostSessionIds: context.terminalSessions.map(session => session.sessionId),
+  });
+  ctx.emit({
+    id: `context-snapshot-${ctx.turnId}`,
+    type: 'context_snapshot',
+    snapshot: promptContext,
+  } as import('../types').AgentEvent);
+  const continuationContext = createContinuationContext(
+    context.activeProvider.id,
+    context.activeProvider.providerId,
+    activeModelId,
+    resolveProviderStyle(context.activeProvider) === 'openai'
+      && resolveOpenAIApi(context.activeProvider) === 'responses',
+  );
+
+  ui.setStreamingForScope(sessionId, true);
+
+  try {
+    const openAIChatAssistantFieldsByMessage = new Map<ModelMessage, OpenAIChatAssistantFields | undefined>();
+
+    const buildSdkMessages = (
+      allMessages: import('../../types').ChatMessage[],
+      includeCurrentUserMessage: boolean,
+      options: { preserveTerminalToolResults?: ReadonlySet<import('../../types').ToolResult> } = {},
+      sessionContextCompaction = currentSession?.contextCompaction,
+    ) => buildCattySdkMessages({
+      allMessages,
+      contextCompaction: sessionContextCompaction,
+      includeCurrentUserMessage,
+      trimmed: modelUserText,
+      attachments: includeCurrentUserMessage ? attachments : undefined,
+      continuationContext,
+      preserveTerminalToolResults: options.preserveTerminalToolResults,
+      chatSessionId: sessionId,
+      toolOutputStore: ctx.toolOutputStore,
+      fieldsByMessage: openAIChatAssistantFieldsByMessage,
+    });
+
+    const responseIdleTimeoutSeconds = normalizeResponseIdleTimeoutSeconds(
+      context.responseIdleTimeout ?? Number.NaN,
+    );
+    const responseIdleTimeoutMs = responseIdleTimeoutSeconds * 1000;
+
+    let model;
+    try {
+      model = createModelFromConfig(
+        {
+          ...context.activeProvider,
+          defaultModel: activeModelId,
+        },
+        {
+          getOpenAIChatAssistantFields: () => continuationContext.openAIChatAssistantFields,
+          streamIdleTimeoutMs: responseIdleTimeoutMs,
+        },
+      );
+    } catch (e) {
+      console.error('[Catty] Model creation failed:', e);
+      ui.reportStreamError(sessionId, signal, `Model creation failed: ${e instanceof Error ? e.message : String(e)}`);
+      return;
+    }
+
+    const contextWindow = resolveContextWindow({
+      provider: context.activeProvider,
+      modelId: activeModelId,
+      defaultContextWindow: DEFAULT_CONTEXT_WINDOW_TOKENS,
+    });
+    const maxOutputTokens = context.activeProvider.advancedParams?.maxTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+    const reasoningProviderOptions = applyResponsesApiStatelessStoreOption(
+      context.activeProvider,
+      buildCattyReasoningProviderOptions(
+        context.activeProvider,
+        context.reasoningEffort,
+        activeModelId,
+      ),
+    );
+    const preserveStatelessResponsesReasoning = reasoningProviderOptions?.openai?.store === false;
+    const reasoningReserveTokens = estimateReasoningOutputReserve(reasoningProviderOptions);
+    // Fold thinking budget into compaction maxOutput only. reservedTokens is
+    // added to estimated input separately, so adding the budget there too
+    // would count the same 10k/20k twice.
+    const compactionMaxOutputTokens = maxOutputTokens + reasoningReserveTokens;
+    const providerId = context.activeProvider.providerId;
+    const outputReserveTokens = Math.min(maxOutputTokens, Math.ceil(contextWindow * 0.05));
+    const getRequestReserveTokens = () => outputReserveTokens + estimateUnknownTokens({
+      systemPrompt,
+      toolNames: Object.keys(tools),
+      openAIChatAssistantFields: Array.from(openAIChatAssistantFieldsByMessage.values()),
+    }, providerId);
+
+    const prepareMessagesForStream = (messages: ModelMessage[]): ModelMessage[] => {
+      const pruned = prepareCattyMessagesForStream(messages, {
+        preserveReasoning: preserveStatelessResponsesReasoning,
+      });
+      continuationContext.openAIChatAssistantFields = collectOpenAIChatAssistantFieldsForMessages(
+        pruned,
+        openAIChatAssistantFieldsByMessage,
+      );
+      return pruned;
+    };
+
+    const compactMessages = async (
+      messages: ModelMessage[],
+      options: {
+        force?: boolean;
+        compressForRequestTooLargeRetry?: boolean;
+        protectRecentMessages?: number;
+      },
+    ) => {
+      const pendingHandles = ctx.toolOutputStore.listPendingHandles(sessionId);
+      const sessionStateText = ctx.sessionStateStore.toReinjectionText(sessionId);
+      const result = await compactCattyMessages({
+        messages,
+        sessionId,
+        chatSessionId: sessionId,
+        provider: context.activeProvider,
+        modelId: activeModelId || context.activeProvider?.defaultModel,
+        reservedTokens: getRequestReserveTokens,
+        maxOutputTokens: compactionMaxOutputTokens,
+        model,
+        toolOutputStore: ctx.toolOutputStore,
+        abortSignal: signal,
+        trigger: options.force ? 'force' : options.compressForRequestTooLargeRetry ? '413-retry' : 'pre-turn',
+        force: options.force,
+        compressForRequestTooLargeRetry: options.compressForRequestTooLargeRetry,
+        protectRecentMessages: options.protectRecentMessages,
+        onCompactionStart: (trigger) => {
+          ctx.emit({
+            id: `compaction-start-${Date.now()}`,
+            type: 'compaction_start',
+            sessionId,
+            chatSessionId: sessionId,
+            backend: 'catty',
+            timestamp: Date.now(),
+            trigger,
+          } as import('../types').AgentEvent);
+        },
+        onCompaction: (trace) => {
+          ctx.emit({
+            id: `compaction-${Date.now()}`,
+            type: 'compaction',
+            trace,
+          } as import('../types').AgentEvent);
+          if (options.compressForRequestTooLargeRetry && trace.did413Fallback) {
+            console.warn('[Catty] Request content compressed after forced context compaction.');
+          }
+        },
+        reinjection: {
+          permissionMode: context.permissionMode ?? context.globalPermissionMode,
+          sessionStateText,
+          sessionScopeSummary: pendingHandles.length
+            ? `Pending tool output handles: ${pendingHandles.map(h => h.id).join(', ')}`
+            : undefined,
+        },
+      });
+      return result;
+    };
+
+    const emitContextSnapshot = (messages: ModelMessage[]) => {
+      ctx.emit({
+        id: `context-snapshot-${Date.now()}-${ctx.turnId}`,
+        type: 'context_snapshot',
+        snapshot: {
+          ...promptContext,
+          contextWindow,
+          estimatedInputTokens: computeTotalInputTokens({
+            messages,
+            providerId,
+            systemPrompt,
+            toolNames: Object.keys(tools),
+          }),
+        },
+      } as import('../types').AgentEvent);
+    };
+
+    if (context.forceCompaction) {
+      // Persist a tool-safe UI-message boundary and summarize only that head
+      // slice so the durable compact coordinate system matches buildCattySdkMessages.
+      const uiMessages = currentSession?.messages ?? [];
+      const compactedMessageCount = findSafeChatMessageCompactionSplitIndex(
+        uiMessages,
+        DEFAULT_PROTECT_RECENT_MESSAGES,
+      );
+      if (compactedMessageCount <= 0) {
+        emitContextSnapshot(prepareMessagesForStream(buildSdkMessages(uiMessages, false)));
+        return;
+      }
+
+      const headSdkMessages = buildSdkMessages(
+        uiMessages.slice(0, compactedMessageCount),
+        false,
+        {},
+        undefined,
+      );
+      const compacted = await compactMessages(headSdkMessages, {
+        force: true,
+        // Summarize the entire head; the protected tail lives in UI messages.
+        protectRecentMessages: 0,
+      });
+      if (compacted.summary) {
+        const nextCompaction = {
+          summary: compacted.summary,
+          compactedMessageCount,
+        };
+        ui.persistContextCompaction?.(sessionId, nextCompaction);
+        emitContextSnapshot(prepareMessagesForStream(
+          buildSdkMessages(uiMessages, false, {}, nextCompaction),
+        ));
+      } else {
+        // Non-durable outcome: keep the meter honest (full current context).
+        emitContextSnapshot(prepareMessagesForStream(buildSdkMessages(uiMessages, false)));
+      }
+      return;
+    }
+
+    let messagesForStream = buildSdkMessages(currentSession?.messages ?? [], true);
+    messagesForStream = (await compactMessages(messagesForStream, {})).messages;
+    messagesForStream = prepareMessagesForStream(messagesForStream);
+    emitContextSnapshot(messagesForStream);
+
+    const runtimeContext = createInitialCattyRuntimeContext({
+      chatSessionId: sessionId,
+      turnId: ctx.turnId,
+      providerId: context.activeProvider?.providerId,
+      modelId: activeModelId,
+      permissionMode: context.permissionMode ?? context.globalPermissionMode,
+      scopeType: context.scopeType,
+      scopeLabel: context.scopeLabel,
+      userGoal: extractLatestUserGoal(messagesForStream),
+      promptContext,
+    });
+    const commandTimeoutSeconds =
+      Number.isFinite(context.commandTimeout) && context.commandTimeout > 0
+        ? normalizeCommandTimeoutSeconds(context.commandTimeout)
+        : undefined;
+    const commandTimeoutMs =
+      commandTimeoutSeconds != null
+        ? commandTimeoutSeconds * 1000
+        : undefined;
+
+    const runStream = async (streamMessages: ModelMessage[], streamAssistantMsgId: string) => {
+      await processCattyStream({
+        streamSessionId: sessionId,
+        model,
+        systemPrompt,
+        toolsBundle,
+        sdkMessages: streamMessages,
+        signal,
+        currentAssistantMsgId: streamAssistantMsgId,
+        maxIterations,
+        advancedParams: context.activeProvider?.advancedParams,
+        reasoningProviderOptions,
+        continuationContext,
+        turnId: ctx.turnId,
+        commandTimeoutMs,
+        responseIdleTimeoutMs,
+        runtimeContext,
+        onAgentEvent: (event) => ctx.emit(event),
+        prepareStep: async ({ stepNumber, messages, runtimeContext: stepRuntimeContext }) => {
+          const prepared = await prepareStepContext({
+            messages,
+            stepNumber,
+            sessionId,
+            chatSessionId: sessionId,
+            providerId: context.activeProvider?.providerId,
+            modelId: activeModelId,
+            contextWindow,
+            reservedTokens: getRequestReserveTokens(),
+            maxOutputTokens: compactionMaxOutputTokens,
+            toolOutputStore: ctx.toolOutputStore,
+            runtimeContext: stepRuntimeContext,
+            onEvent: (event) => ctx.emit(event),
+          });
+          emitContextSnapshot(prepared.messages);
+          return {
+            messages: prepared.messages,
+            runtimeContext: prepared.runtimeContext,
+          };
+        },
+        ui: {
+          addMessageToSession: ui.addMessageToSession,
+          updateMessageById: ui.updateMessageById,
+        },
+      });
+    };
+
+    try {
+      await runStream(messagesForStream, assistantMsgId);
+    } catch (streamErr) {
+      if (signal.aborted || !isRequestTooLargeError(streamErr)) {
+        throw streamErr;
+      }
+
+      console.warn('[Catty] Request hit HTTP 413; forcing context compaction and retrying once.', streamErr);
+      const hadToolProgress = hadToolProgressBeforeRequestTooLarge(streamErr);
+      let retryBaseMessages = messagesForStream;
+      let retryAssistantMsgId = assistantMsgId;
+      let preservedWriteFingerprints: string[] = [];
+      if (hadToolProgress) {
+        const latestSession = ui.getLatestSession?.(sessionId);
+        if (latestSession) {
+          preservedWriteFingerprints = collectPreservedTerminalWriteFingerprints(
+            latestSession.messages,
+            assistantMsgId,
+            sessionId,
+          );
+          retryBaseMessages = buildSdkMessages(latestSession.messages, false, {
+            preserveTerminalToolResults: collectToolResultsAfterMessage(
+              latestSession.messages,
+              assistantMsgId,
+            ),
+          }, latestSession.contextCompaction);
+        }
+        retryAssistantMsgId = generateId();
+        ui.addMessageToSession(sessionId, {
+          id: retryAssistantMsgId,
+          role: 'assistant',
+          content: '',
+          timestamp: Date.now(),
+          model: activeModelId || context.activeProvider?.defaultModel || '',
+          providerId: context.activeProvider?.providerId,
+        });
+      } else {
+        ui.updateMessageById(sessionId, assistantMsgId, msg => ({
+          ...msg,
+          content: '',
+          thinking: undefined,
+          thinkingDurationMs: undefined,
+          providerContinuation: undefined,
+          toolCalls: undefined,
+          errorInfo: undefined,
+          executionStatus: undefined,
+          pendingApproval: undefined,
+        }));
+      }
+      ctx.toolResultDedup.enableWriteReplay(preservedWriteFingerprints);
+      const retryMessages = prepareMessagesForStream((await compactMessages(retryBaseMessages, {
+        force: true,
+        compressForRequestTooLargeRetry: true,
+      })).messages);
+      emitContextSnapshot(retryMessages);
+      await runStream(retryMessages, retryAssistantMsgId);
+    }
+  } catch (err) {
+    console.error('[Catty] streamText error:', err);
+    ui.reportStreamError(sessionId, signal, err);
+  } finally {
+    ui.updateLastMessage(sessionId, msg => msg.statusText ? { ...msg, statusText: '' } : msg);
+    ui.setStreamingForScope(sessionId, false);
+    context.autoTitleSession(sessionId, context.titleText ?? trimmed);
+  }
+}
+
+export const cattyTurnDriver = new CattyTurnDriver();