Method process

coding-agent/src/agent/coding-agent.ts:21–254

(message: string, onFirstText?: () => void)

  }

  async process(message: string, onFirstText?: () => void): Promise<string> {
    const session = sessionManager.current();

    // Add user message to session
    sessionManager.addMessage(session.id, {
      id: randomUUID(),
      role: 'user',
      content: message,
      timestamp: Date.now()
    });

    await messageBus.publish('agent:message', { message }, {
      sessionId: session.id,
      agentId: this.config.id
    });

    emitCliTimelineEvent({
      kind: 'command',
      phase: 'running',
      title: 'Task Received',
      text: message,
    });

    // Select provider with fallback support
    const { provider, resolvedModel } = selectProvider(
      this.config.model,
      this.config.provider
    );

    const tools = this.getTools();

    // Execute with automatic fallback on error
    let fullResponse = '';
    let continueLoop = true;
    let loopCount = 0;
    const maxLoops = 5; // Prevent infinite loops
    let firstTextReceived = false;

    while (continueLoop && loopCount < maxLoops) {
      loopCount++;
      continueLoop = false;
      const toolCalls: Array<{ id: string; name: string; arguments: string }> = [];
      let currentToolCall: { id: string; name: string; arguments: string } | null = null;

      await executeWithFallback(provider, resolvedModel, async (activeProvider) => {
        const toolsFormatted = formatToolsForProvider(activeProvider, tools);
        const stream = activeProvider.streamText({
          model: resolvedModel,
          messages: session.messages as any,
          tools: toolsFormatted as any,
          systemPrompt: this.config.systemPrompt,
          temperature: this.config.temperature,
          maxTokens: this.config.maxTokens
        });

        for await (const chunk of stream) {
          if (chunk.type === 'text' && chunk.content) {
            // On first text, clear spinner and keep "Agent:" label