Agent Runtime

export type AcpRuntimeHandle = {
  sessionKey: string;
  backend: string;
  runtimeSessionName: string;
  cwd?: string;
  backendSessionId?: string;
  agentSessionId?: string;
};

export type AcpRuntimeTurnInput = {
  handle: AcpRuntimeHandle;
  text: string;
  attachments?: AcpRuntimeTurnAttachment[];
  mode: "prompt" | "steer";
  requestId: string;
  signal?: AbortSignal;
};

export function createInMemorySessionStore(): AcpSessionStore {
  const sessions = new Map<string, AcpSession>();

  const createSession = (params) => {
    const sessionId = params.sessionId ?? randomUUID();
    const existing = sessions.get(sessionId);
    if (existing) {
      existing.sessionKey = params.sessionKey;
      existing.cwd = params.cwd;
      return existing;
    }
    const session = { sessionId, sessionKey: params.sessionKey, cwd: params.cwd };
    sessions.set(sessionId, session);
    return session;
  };

  return { createSession, getSession, cancelActiveRun, deleteSession };
}

export function buildSessionContext(pathEntries: SessionTreeEntry[]): SessionContext {
  let compaction: CompactionEntry | null = null;
  for (const entry of pathEntries) {
    if (entry.type === "compaction") compaction = entry;
  }

  const messages: AgentMessage[] = [];
  const appendMessage = (entry: SessionTreeEntry) => {
    if (entry.type === "message") messages.push(entry.message);
    if (entry.type === "branch_summary" && entry.summary) {
      messages.push(asAgentMessage(createBranchSummaryMessage(entry.summary)));
    }
  };

  if (compaction) {
    messages.push(asAgentMessage(
      createCompactionSummaryMessage(
        compaction.summary,
        compaction.tokensBefore,
        compaction.timestamp,
      ),
    ));
    const compactionIdx = pathEntries.findIndex(
      (e) => e.type === "compaction" && e.id === compaction.id,
    );
    let foundFirstKept = false;
    for (let i = 0; i < compactionIdx; i++) {
      const entry = pathEntries[i];
      if (entry.id === compaction.firstKeptEntryId) foundFirstKept = true;
      if (foundFirstKept) appendMessage(entry);
    }
    for (let i = compactionIdx + 1; i < pathEntries.length; i++) {
      appendMessage(pathEntries[i]);
    }
  } else {
    for (const entry of pathEntries) appendMessage(entry);
  }

  return { messages, thinkingLevel, model };
}

export class Session {
  async buildContext(): Promise<SessionContext> {
    return buildSessionContext(await this.getBranch());
  }
}

async function runLoop(
  initialContext: AgentContext,
  newMessages: AgentMessage[],
  initialConfig: AgentLoopConfig,
  signal: AbortSignal | undefined,
  emit: AgentEventSink,
): Promise<void> {
  let currentContext = initialContext;
  let pendingMessages = (await initialConfig.getSteeringMessages?.()) || [];

  while (true) {
    let hasMoreToolCalls = true;

    while (hasMoreToolCalls || pendingMessages.length > 0) {
      for (const message of pendingMessages) {
        currentContext.messages.push(message);
        newMessages.push(message);
      }

      const message = await streamAssistantResponse(
        currentContext, initialConfig, signal, emit,
      );
      newMessages.push(message);

      const toolCalls = message.content.filter((c) => c.type === "toolCall");
      hasMoreToolCalls = false;
      if (message.stopReason === "toolUse" && toolCalls.length > 0) {
        const batch = await executeToolCalls(
          currentContext, message, initialConfig, signal, emit,
        );
        for (const result of batch.messages) currentContext.messages.push(result);
        hasMoreToolCalls = !batch.terminate;
      }

      if (await initialConfig.shouldStopAfterTurn?.({ message, context: currentContext })) {
        await emit({ type: "agent_end", messages: newMessages });
        return;
      }
      pendingMessages = (await initialConfig.getSteeringMessages?.()) || [];
    }
    break;
  }
  await emit({ type: "agent_end", messages: newMessages });
}

async function executeToolCalls(
  currentContext: AgentContext,
  assistantMessage: AssistantMessage,
  config: AgentLoopConfig,
  signal: AbortSignal | undefined,
  emit: AgentEventSink,
): Promise<ExecutedToolCallBatch> {
  const toolCalls = assistantMessage.content.filter((c) => c.type === "toolCall");
  const resolvedToolCalls = new Map<AgentToolCall, ResolvedToolCallOutcome>();

  let hasSequentialToolCall = false;
  if (config.toolExecution !== "sequential") {
    for (const toolCall of toolCalls) {
      const resolution = await resolveToolCallTool(
        currentContext, assistantMessage, toolCall, config, signal, resolvedToolCalls,
      );
      if (resolution.kind === "resolved" && resolution.tool?.executionMode === "sequential") {
        hasSequentialToolCall = true;
        break;
      }
    }
  }

  if (config.toolExecution === "sequential" || hasSequentialToolCall) {
    return executeToolCallsSequential(
      currentContext, assistantMessage, toolCalls, resolvedToolCalls, config, signal, emit,
    );
  }

  return executeToolCallsParallel(
    currentContext, assistantMessage, toolCalls, resolvedToolCalls, config, signal, emit,
  );
}

function createLoopConfig(): AgentLoopConfig {
  return {
    beforeToolCall: async ({ toolCall, args }) =>
      emitHook({ type: "tool_call", toolName: toolCall.name, input: args }),
    afterToolCall: async ({ toolCall, result, isError }) =>
      emitHook({
        type: "tool_result",
        toolName: toolCall.name,
        content: result.content,
        isError,
      }),
  };
}

export class Session {
  private async appendTypedEntry(entry: SessionTreeEntry): Promise<string> {
    await this.storage.appendEntry(entry);
    return entry.id;
  }

  async appendMessage(message: AgentMessage): Promise<string> {
    return this.appendTypedEntry({
      type: "message",
      id: await this.storage.createEntryId(),
      parentId: await this.getAppendParentId(),
      timestamp: new Date().toISOString(),
      message,
    });
  }
}

export class JsonlSessionStorage extends BaseSessionStorage {
  static async create(fs, filePath, options): Promise<JsonlSessionStorage> {
    const header = {
      type: "session",
      version: 3,
      id: options.sessionId,
      timestamp: new Date().toISOString(),
      cwd: options.cwd,
      parentSession: options.parentSessionPath,
    };
    await fs.writeFile(filePath, `${JSON.stringify(header)}\n`);
    return new JsonlSessionStorage(fs, filePath, header, [], null, null);
  }

  override async appendEntry(entry: SessionTreeEntry): Promise<void> {
    this.validateEntryForAppend(entry);
    await this.fs.appendFile(this.filePath, `${JSON.stringify(entry)}\n`);
    this.recordEntry(entry);
  }
}