AWS Lambda Response Streaming: Stream Coding-Agent Tokens Without Buffering Full Completions

# ✅ create / update Function URL for RESPONSE_STREAM
aws lambda create-function-url-config \
  --function-name coding-agent-stream \
  --auth-type AWS_IAM \
  --invoke-mode RESPONSE_STREAM \
  --cors '{"AllowOrigins":["https://app.example.com"],"AllowMethods":["POST"],"AllowHeaders":["content-type","authorization"]}'

# ✅ raise the HTTP response timeout (seconds) so long reviews can finish
aws lambda update-function-url-config \
  --function-name coding-agent-stream \
  --invoke-mode RESPONSE_STREAM

// ✅ handler.js — stream tokens as NDJSON lines (easy for browsers / CLIs)
const { BedrockRuntimeClient, ConverseStreamCommand } = require("@aws-sdk/client-bedrock-runtime");
const client = new BedrockRuntimeClient({});

exports.handler = awslambda.streamifyResponse(async (event, responseStream, _context) => {
  const httpStream = awslambda.HttpResponseStream.from(responseStream, {
    statusCode: 200,
    headers: {
      "Content-Type": "application/x-ndjson",
      "Cache-Control": "no-cache",
    },
  });

  let body;
  try {
    body = JSON.parse(event.body || "{}");
  } catch {
    httpStream.write(JSON.stringify({ type: "error", message: "invalid_json" }) + "\n");
    httpStream.end();
    return;
  }

  const cmd = new ConverseStreamCommand({
    modelId: body.modelId || "anthropic.claude-3-5-sonnet-20241022-v2:0",
    messages: body.messages,
    inferenceConfig: { maxTokens: body.maxTokens || 4096, temperature: 0.2 },
  });

  try {
    const resp = await client.send(cmd);
    for await (const ev of resp.stream) {
      if (ev.contentBlockDelta?.delta?.text) {
        // ✅ flush early — do not accumulate
        httpStream.write(
          JSON.stringify({ type: "token", text: ev.contentBlockDelta.delta.text }) + "\n"
        );
      }
      if (ev.messageStop) {
        httpStream.write(JSON.stringify({ type: "stop", reason: ev.messageStop.stopReason }) + "\n");
      }
    }
  } catch (err) {
    // ❌ swallowing errors leaves the client hanging with an open stream
    httpStream.write(JSON.stringify({ type: "error", message: String(err.name || err) }) + "\n");
  } finally {
    httpStream.end();
  }
});

# ✅ Python: Lambda response streaming with a text IO wrapper
import json
from awslambdaric.lambda_response_stream import LambdaResponseStream  # runtime provides stream APIs

# Prefer the documented decorator / stream writer for your runtime version.
# Pattern: open stream → write chunks → close. Never buffer the full completion.

// ✅ AWS SDK v3 — pipe InvokeWithResponseStream to the client
import {
  LambdaClient,
  InvokeWithResponseStreamCommand,
} from "@aws-sdk/client-lambda";

const lambda = new LambdaClient({});

export async function proxyAgentStream(res: NodeJS.WritableStream, payload: unknown) {
  const out = await lambda.send(
    new InvokeWithResponseStreamCommand({
      FunctionName: "coding-agent-stream",
      Payload: Buffer.from(JSON.stringify(payload)),
    })
  );
  for await (const event of out.EventStream!) {
    if (event.PayloadChunk?.Payload) {
      res.write(event.PayloadChunk.Payload);
    }
    if (event.InvokeComplete?.ErrorCode) {
      // surface failure; pair with Destinations for async paths
      throw new Error(event.InvokeComplete.ErrorCode);
    }
  }
}

# ✅ alarm: function errors during streaming reviews
aws cloudwatch put-metric-alarm \
  --alarm-name coding-agent-stream-errors \
  --namespace AWS/Lambda \
  --metric-name Errors \
  --dimensions Name=FunctionName,Value=coding-agent-stream \
  --statistic Sum --period 60 --threshold 3 \
  --comparison-operator GreaterThanOrEqualToThreshold \
  --evaluation-periods 1