Amazon Bedrock

First, install the Amazon Bedrock adapter package:

npm install @hashbrownai/bedrock

Streaming Text Responses

Hashbrown’s Bedrock adapter lets you stream chat completions from AWS Bedrock models (Claude, Mistral, Meta Llama, etc.) using the same streaming protocol Hashbrown uses for every platform.

API Reference

HashbrownBedrock.stream.text(options)

Streams an Amazon Bedrock chat completion as a series of encoded frames. Handles content, tool calls, and errors, and yields each frame as a Uint8Array.

Options:

Supported Features:

• Roles: user, assistant, tool
• Tools: Converts Hashbrown tools into Bedrock toolConfig definitions and streams tool call arguments.
• System Prompt: Added as a Bedrock system message when supplied.
• Function Calling: Streams tool call deltas (toolUse) and tool results in the order Hashbrown expects.
• Streaming: Emits resilient Hashbrown frames for every text delta, tool call update, finish reason, or error.

How It Works

• Messages: User, assistant, and tool messages are mapped to Bedrock messages (tool results become toolResult blocks).
• Tool Configuration: Tools are sent via toolConfig with the JSON schema you pass in parameters.
• Tool Call Streaming: Bedrock’s toolUse events are buffered and emitted as incremental Hashbrown tool call frames.
• Error Handling: Any SDK or service error is converted into an error frame before Hashbrown sends finish.
• Structured Output: Amazon Bedrock does not yet enforce JSON schemas—Angular apps should enable emulateStructuredOutput so Hashbrown validates locally (see below).

Example: Node.js Server Integration

import { HashbrownBedrock } from '@hashbrownai/bedrock';
import express from 'express';

const app = express();
app.use(express.json());

app.post('/chat', async (req, res) => {
  const stream = HashbrownBedrock.stream.text({
    region: process.env.AWS_REGION ?? 'us-east-1',
    request: req.body, // must be Chat.Api.CompletionCreateParams
  });

  res.header('Content-Type', 'application/octet-stream');

  for await (const chunk of stream) {
    res.write(chunk); // Pipe each encoded frame as it arrives
  }

  res.end();
});

app.listen(3000);

import { HashbrownBedrock } from '@hashbrownai/bedrock';
import Fastify from 'fastify';

const fastify = Fastify();

fastify.post('/chat', async (request, reply) => {
  const stream = HashbrownBedrock.stream.text({
    region: process.env.AWS_REGION ?? 'us-east-1',
    request: request.body, // must be Chat.Api.CompletionCreateParams
  });

  reply.header('Content-Type', 'application/octet-stream');

  for await (const chunk of stream) {
    reply.raw.write(chunk); // Pipe each encoded frame as it arrives
  }

  reply.raw.end();
});

fastify.listen({ port: 3000 });

import { Controller, Post, Body, Res } from '@nestjs/common';
import { HashbrownBedrock } from '@hashbrownai/bedrock';
import { Response } from 'express';

@Controller()
export class ChatController {
  @Post('chat')
  async chat(@Body() body: any, @Res() res: Response) {
    const stream = HashbrownBedrock.stream.text({
      region: process.env.AWS_REGION ?? 'us-east-1',
      request: body, // must be Chat.Api.CompletionCreateParams
    });

    res.header('Content-Type', 'application/octet-stream');

    for await (const chunk of stream) {
      res.write(chunk); // Pipe each encoded frame as it arrives
    }

    res.end();
  }
}

import { HashbrownBedrock } from '@hashbrownai/bedrock';
import { Hono } from 'hono';

const app = new Hono();

app.post('/chat', async (c) => {
  const body = await c.req.json();

  const stream = HashbrownBedrock.stream.text({
    region: process.env.AWS_REGION ?? 'us-east-1',
    request: body, // must be Chat.Api.CompletionCreateParams
  });

  return new Response(
    new ReadableStream({
      async start(controller) {
        for await (const chunk of stream) {
          controller.enqueue(chunk); // Pipe each encoded frame as it arrives
        }
        controller.close();
      },
    }),
    {
      headers: {
        'Content-Type': 'application/octet-stream',
      },
    },
  );
});

export default app;

AWS Credentials & Client Reuse

The adapter uses the AWS SDK’s default credential provider chain. Provide credentials via environment variables, IAM roles, or pass them explicitly:

const stream = HashbrownBedrock.stream.text({
  request,
  region: 'us-west-2',
  credentials: {
    accessKeyId: process.env.AWS_ACCESS_KEY_ID!,
    secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY!,
  },
});

If you already configure retries, logging, or custom middleware on a BedrockRuntimeClient, pass it with the client option to reuse it.

Structured Output & Angular Providers

Because Bedrock does not validate JSON schemas, enable emulateStructuredOutput in your Angular configuration so Hashbrown enforces structured responses on the client:

import { ApplicationConfig } from '@angular/core';
import { provideHashbrown } from '@hashbrownai/angular';

export const appConfig: ApplicationConfig = {
  providers: [
    provideHashbrown({
      baseUrl: '/api/chat',
      emulateStructuredOutput: true,
    }),
  ],
};

With this flag, the Angular resources/hooks keep your UI synchronized with tool responses just like the OpenAI/Azure adapters.