/api/foundry/chat (dashboard)

export async function POST(request: NextRequest) {
  const session = await getSession();
  if (!session) {
    return NextResponse.json(
      {
        error: {
          code: 'UNAUTHENTICATED',
          message: 'Sign in at auth.l1fe.ai before using Operator chat.',
        },
      },
      { status: 401, headers: noStoreHeaders() }
    );
  }

  const apiKey = engineApiKey();
  if (!apiKey) {
    return NextResponse.json(
      {
        error: {
          code: 'FOUNDRY_UNCONFIGURED',
          message:
            'FOUNDRY_ENGINE_API_KEY is not configured on the server. Contact Minds ops.',
        },
      },
      { status: 503, headers: noStoreHeaders() }
    );
  }

  let body: Record<string, unknown>;
  try {
    body = (await request.json()) as Record<string, unknown>;
  } catch {
    return NextResponse.json(
      {
        error: {
          code: 'INVALID_JSON',
          message: 'Request body must be JSON.',
        },
      },
      { status: 400, headers: noStoreHeaders() }
    );
  }

  if (!Array.isArray(body.messages) || body.messages.length === 0) {
    return NextResponse.json(
      {
        error: {
          code: 'INVALID_MESSAGES',
          message: 'messages must be a non-empty array.',
        },
      },
      { status: 400, headers: noStoreHeaders() }
    );
  }

  const wantStream = body.stream === true;
  const messages = await withOperatorContext(
    withL1feMindsSystemMessage(body.messages as ChatMessageLike[]),
    session
  );
  const payload = {
    ...body,
    messages,
    model:
      typeof body.model === 'string' && body.model.trim()
        ? body.model
        : DEFAULT_MODEL,
    stream: wantStream,
  };

  const target = `${foundryBaseUrl()}/v1/chat/completions`;
  let upstream: Response;
  try {
    upstream = await fetch(target, {
      method: 'POST',
      headers: {
        authorization: `Bearer ${apiKey}`,
        'content-type': 'application/json',
        accept: wantStream ? 'text/event-stream' : 'application/json',
      },
      body: JSON.stringify(payload),
      cache: 'no-store',
    });
  } catch (error) {
    const message =
      error instanceof Error ? error.message : 'Foundry upstream unreachable';
    return NextResponse.json(
      {
        error: {
          code: 'FOUNDRY_UPSTREAM_UNAVAILABLE',
          message,
        },
      },
      { status: 502, headers: noStoreHeaders() }
    );
  }

  const headers = new Headers(noStoreHeaders());
  const contentType = upstream.headers.get('content-type');
  if (contentType) {
    headers.set('content-type', contentType);
  }
  // Do not forward upstream auth or cookie headers.
  const requestId =
    upstream.headers.get('x-request-id') ||
    upstream.headers.get('cf-ray') ||
    upstream.headers.get('x-foundry-request-id');
  if (requestId) {
    headers.set('x-foundry-request-id', requestId);
  }

  // Stream path: scrub SSE deltas.
  if (wantStream && upstream.body && upstream.ok) {
    headers.set('content-type', contentType || 'text/event-stream');
    return new NextResponse(sanitizeSseStream(upstream.body), {
      status: upstream.status,
      headers,
    });
  }

  // Non-stream JSON: scrub assistant content before returning to UI.
  if (
    upstream.body &&
    contentType &&
    contentType.includes('application/json')
  ) {
    try {
      const rawText = await upstream.text();
      let parsed: unknown = {};
      try {
        parsed = rawText ? JSON.parse(rawText) : {};
      } catch {
        // Upstream returned non-JSON; still strip think tags from raw body.
        return new NextResponse(sanitizeAssistantText(rawText), {
          status: upstream.status,
          headers,
        });
      }
      const cleaned = sanitizeFoundryCompletionJson(parsed);
      return NextResponse.json(cleaned, {
        status: upstream.status,
        headers: noStoreHeaders(),
      });
    } catch (error) {
      const message =
        error instanceof Error
          ? error.message
          : 'Failed to sanitize Foundry response';
      return NextResponse.json(
        {
          error: {
            code: 'FOUNDRY_SANITIZE_FAILED',
            message,
          },
        },
        { status: 502, headers: noStoreHeaders() }
      );
    }
  }

  return new NextResponse(upstream.body, {
    status: upstream.status,
    headers,
  });
}

export async function GET() {
  return NextResponse.json(
    {
      error: {
        code: 'METHOD_NOT_ALLOWED',
        message: 'Use POST /api/foundry/chat with an OpenAI-compatible body.',
      },
    },
    { status: 405, headers: noStoreHeaders() }
  );
}

NextResponse.json(
      {
        error: {
          code: 'UNAUTHENTICATED',
          message: 'Sign in at auth.l1fe.ai before using Operator chat.',
        },
      },
      { status: 401, headers: noStoreHeaders() }
    )

NextResponse.json(
      {
        error: {
          code: 'FOUNDRY_UNCONFIGURED',
          message:
            'FOUNDRY_ENGINE_API_KEY is not configured on the server. Contact Minds ops.',
        },
      },
      { status: 503, headers: noStoreHeaders() }
    )

request.json()

NextResponse.json(
      {
        error: {
          code: 'INVALID_JSON',
          message: 'Request body must be JSON.',
        },
      },
      { status: 400, headers: noStoreHeaders() }
    )

NextResponse.json(
      {
        error: {
          code: 'INVALID_MESSAGES',
          message: 'messages must be a non-empty array.',
        },
      },
      { status: 400, headers: noStoreHeaders() }
    )

NextResponse.json(
      {
        error: {
          code: 'FOUNDRY_UPSTREAM_UNAVAILABLE',
          message,
        },
      },
      { status: 502, headers: noStoreHeaders() }
    )

NextResponse.json(cleaned, {
        status: upstream.status,
        headers: noStoreHeaders(),
      })

NextResponse.json(
        {
          error: {
            code: 'FOUNDRY_SANITIZE_FAILED',
            message,
          },
        },
        { status: 502, headers: noStoreHeaders() }
      )

NextResponse.json(
    {
      error: {
        code: 'METHOD_NOT_ALLOWED',
        message: 'Use POST /api/foundry/chat with an OpenAI-compatible body.',
      },
    },
    { status: 405, headers: noStoreHeaders() }
  )